qtforum.de

Code: Alles auswählen

#include <QTranslator>
#include <QLocale>

#include "languagesupport.h"

/** Static list of supported languages and codes. */
QMap<QString, QString> LanguageSupport::_languages;

/** Initializes the list of available languages. */
void
LanguageSupport::initialize()
{
  _languages.clear();
  _languages.insert("en",    "English");
  _languages.insert("de",    "Deutsch");


}

/** Returns the default language code for the system locale. */
QString
LanguageSupport::defaultLanguageCode()
{
  QString localeName = QLocale::system().name();
  QString language   = localeName.mid(0, localeName.indexOf("_"));
  if (!isValidLanguageCode(language)) {
    language = "en";
  }
  return language;
}

/** Returns the language code for a given language name. */
QString
LanguageSupport::languageCode(QString languageName)
{
  return _languages.key(languageName);
}

/** Returns a list of all supported language codes. (e.g., "en"). */
QStringList
LanguageSupport::languageCodes()
{
  return _languages.keys();
}

/** Returns the language name for a given language code. */
QString
LanguageSupport::languageName(QString languageCode)
{
  return _languages.value(languageCode);
}

/** Returns a list of all supported language names (e.g., "English"). */
QStringList
LanguageSupport::languageNames()
{
  return _languages.values();
}

/** Returns a list of all supported language codes and names. */
QMap<QString, QString>
LanguageSupport::languages()
{
  return _languages;
}

/** Returns true if we understand the given language code. */
bool
LanguageSupport::isValidLanguageCode(QString code)
{
  return languageCodes().contains(code.toLower());
}

/** Sets the application's translator to the specified language. */
bool
LanguageSupport::translate(QString langCode)
{
  if (isValidLanguageCode(langCode)) {
    QTranslator *translator = new QTranslator();
    if (translator->load(QString(":/lang/") + langCode.toLower())) {
      QApplication::installTranslator(translator);
      return true;
    }
    delete translator;
  }
  return false;
}

Code: Alles auswählen

#ifndef _LANGUAGESUPPORT_H
#define _LANGUAGESUPPORT_H

#include <QApplication>
#include <QStringList>
#include <QMap>


class LanguageSupport
{
public:
  /** Initializes the list of supported languages. */
  static void initialize();
  /** Returns the default language code for the system locale. */
  static QString defaultLanguageCode();
  /** Returns the language code for a given language name. */
  static QString languageCode(QString languageName);
  /** Returns a list of all supported language codes (e.g., "en"). */
  static QStringList languageCodes();
  /** Returns the language name for a given language code. */
  static QString languageName(QString languageCode);
  /** Returns a list of all supported language names (e.g., "English"). */
  static QStringList languageNames();
  /** Returns a list of all supported language codes and names. */
  static QMap<QString, QString> languages();
  /** Returns true if we understand the given language code. */
  static bool isValidLanguageCode(QString code);
  /** Sets the application's translator to the specified language. */
  static bool translate(QString langCode);

private:
  static QMap<QString,QString> _languages; /**< List of support languages. */
};

#endif

Code: Alles auswählen

#ifndef _PREFERENCESDIALOG_H
#define _PREFERENCESDIALOG_H

#include <QFileDialog>
#include <QStyleFactory>
#include <QLineEdit>

#include <config/mysettings.h>
#include <lang/languagesupport.h>

#include "gui/configpage.h"
#include "ui_PreferencesDialog.h"

class PreferencesDialog : public ConfigPage 
{
  Q_OBJECT

public:
  /** Default Constructor */
  PreferencesDialog(QWidget *parent = 0);
  /** Default Destructor */ 
  ~PreferencesDialog();
  /** Saves the changes on this page */
  bool save(QString &errmsg);
  /** Loads the settings for this page */
  void load();


private slots:

  
private:
  /** A mySettings object used for saving/loading settings */
  MySettings* _settings;

  /** Qt Designer generated object */
  Ui::PreferencesDialog ui;
};

#endif

Code: Alles auswählen

#ifndef _PREFERENCESDIALOG_H
#define _PREFERENCESDIALOG_H

#include <QFileDialog>
#include <QStyleFactory>
#include <QLineEdit>

#include <config/mysettings.h>
#include <lang/languagesupport.h>

#include "gui/configpage.h"
#include "ui_PreferencesDialog.h"

class PreferencesDialog : public ConfigPage 
{
  Q_OBJECT

public:
  /** Default Constructor */
  PreferencesDialog(QWidget *parent = 0);
  /** Default Destructor */ 
  ~PreferencesDialog();
  /** Saves the changes on this page */
  bool save(QString &errmsg);
  /** Loads the settings for this page */
  void load();


private slots:

  
private:
  /** A MySettings object used for saving/loading settings */
  mySettings* _settings;

  /** Qt Designer generated object */
  Ui::PreferencesDialog ui;
};

#endif

Code: Alles auswählen

#include <gui/MainWindow.h>

int main( int argc, char ** argv )
{ 
  QApplication app( argc, argv ); 

  MainWindow w; 
  w.show();

  return app.exec();
}

Code: Alles auswählen

#include <QDir>
#include <QTextStream>
#include <QStyleFactory>
#include <util/string.h>
#include <lang/languagesupport.h>


#include "myapp.h"

/* Available command-line arguments. */
#define ARG_LANGUAGE   "lang"    /**< Argument specifying language.    */
#define ARG_GUISTYLE   "style"   /**< Argument specfying GUI style.    */
#define ARG_RESET      "reset"   /**< Reset Myapp's saved settings.  */
#define ARG_DATADIR    "datadir" /**< Directory to use for data files. */
#define ARG_PIDFILE    "pidfile" /**< Location and name of our pidfile.*/

/* Static member variables */
QMap<QString, QString> Myapp::_args; /**< List of command-line arguments.  */
QString Myapp::_style;               /**< The current GUI style.           */
QString Myapp::_language;            /**< The current language.            */
MySettings Myapp::_settings;    /**< Myapp's configurable settings. */



/** Constructor. Parses the command-line arguments, resets Myapp's
 * configuration (if requested), and sets up the GUI style and language
 * translation. */
Myapp::Myapp(QStringList args, int &argc, char **argv)
: QApplication(argc, argv)
{
  /* Read in all our command-line arguments. */
  parseArguments(args);

  /* Check if we're supposed to reset our config before proceeding. */
  if (_args.contains(ARG_RESET)) {
    _settings.reset();
  }

  /** Initialize support for language translations. */
  LanguageSupport::initialize();

  /** Translate the GUI to the appropriate language. */
  setLanguage(_args.value(ARG_LANGUAGE));

  /** Set the GUI style appropriately. */
  setStyle(_args.value(ARG_GUISTYLE));


}



#if defined(Q_OS_WIN)
/** On Windows, we need to catch the WM_QUERYENDSESSION message
 * so we know that it is time to shutdown. */
bool
Myapp::winEventFilter(MSG *msg, long *result)
{
  if (msg->message == WM_QUERYENDSESSION) {
    emit shutdown();
  }
  return QApplication::winEventFilter(msg, result);
}
#endif

/** Display usage information regarding command-line arguments. */
void
Myapp::printUsage(QString errmsg)
{
  QTextStream out(stdout);

  /* If there was an error message, print it out. */
  if (!errmsg.isEmpty()) {
    out << "** " << errmsg << " **" << endl << endl;
  }

  /* Now print the application usage */
  out << "Usage: " << endl;
  out << "\t" << qApp->arguments().at(0) << " [options]"    << endl;

  /* And available options */
  out << endl << "Available Options:"                                   << endl;
  out << "\t-"ARG_RESET"\t\tResets ALL stored Myapp settings."        << endl;
  out << "\t-"ARG_DATADIR"\tSets the directory Myapp uses for data files"<< endl;
  out << "\t-"ARG_PIDFILE"\tSets the name and location of Myapp's pidfile"<< endl;
  out << "\t-"ARG_GUISTYLE"\t\tSets Myapp's interface style."         << endl;
  out << "\t\t\t[" << QStyleFactory::keys().join("|") << "]"            << endl;
  out << "\t-"ARG_LANGUAGE"\t\tSets Myapp's language."                << endl;
  out << "\t\t\t[" << LanguageSupport::languageCodes().join("|") << "]" << endl;
}

/** Returns true if the specified argument expects a value. */
Myapp::argNeedsValue(QString argName)
{
  return (argName == ARG_GUISTYLE ||
          argName == ARG_LANGUAGE ||
          argName == ARG_DATADIR  ||
          argName == ARG_PIDFILE);
}

/** Parses the list of command-line arguments for their argument names and
 * values. */
void
Myapp::parseArguments(QStringList args)
{
  QString arg, value;

  /* Loop through all command-line args/values and put them in a map */
  for (int i = 0; i < args.size(); i++) {
    /* Get the argument name and set a blank value */
    arg   = args.at(i).toLower();
    value = "";

    /* Check if it starts with a - or -- */
    if (arg.startsWith("-")) {
      arg = arg.mid((arg.startsWith("--") ? 2 : 1));
    }
    /* Check if it takes a value and there is one on the command-line */
    if (i < args.size()-1 && argNeedsValue(arg)) {
      value = args.at(++i);
    }
    /* Place this arg/value in the map */
    _args.insert(arg, value);
  }
}

/** Verifies that all specified arguments were valid. */
bool
Myapp::validateArguments(QString &errmsg)
{
  /* If they want help, just return false now 
  if (_args.contains(ARG_HELP)) {
    return false;
  }*/
  /* Check for a language that Myapp recognizes. */
  if (_args.contains(ARG_LANGUAGE) &&
      !LanguageSupport::isValidLanguageCode(_args.value(ARG_LANGUAGE))) {
    errmsg = tr("Invalid language code specified: ") + _args.value(ARG_LANGUAGE);
    return false;
  }
  /* Check for a valid GUI style */
  if (_args.contains(ARG_GUISTYLE) &&
      !QStyleFactory::keys().contains(_args.value(ARG_GUISTYLE),
                                      Qt::CaseInsensitive)) {
    errmsg = tr("Invalid GUI style specified: ") + _args.value(ARG_GUISTYLE);
    return false;
  }
  return true;
}

/** Sets the translation Myapp will use. If one was specified on the
 * command-line, we will use that. Otherwise, we'll check to see if one was
 * saved previously. If not, we'll default to one appropriate for the system
 * locale. */
bool
Myapp::setLanguage(QString languageCode)
{
  /* If the language code is empty, use the previously-saved setting */
  if (languageCode.isEmpty()) {
    languageCode = _settings.getLanguageCode();
  }
  /* Translate into the desired langauge */
  if (LanguageSupport::translate(languageCode)) {
    _language = languageCode;
    return true;
  }
  return false;
}

/** Sets the GUI style Myapp will use. If one was specified on the
 * command-line, we will use that. Otherwise, we'll check to see if one was
 * saved previously. If not, we'll default to one appropriate for the
 * operating system. */
bool
Myapp::setStyle(QString styleKey)
{
  /* If no style was specified, use the previously-saved setting */
  if (styleKey.isEmpty()) {
    styleKey = _settings.getInterfaceStyle();
  }
  /* Apply the specified GUI style */
  if (QApplication::setStyle(styleKey)) {
    _style = styleKey;
    return true;
  }
  return false;
}



/** Returns the directory Myapp uses for its data files. */
QString
Myapp::dataDirectory()
{
  if (_args.contains(ARG_DATADIR)) {
    return _args.value(ARG_DATADIR);
  }
  return defaultDataDirectory();
}

/** Returns the default location of Myapp's data directory. */
QString
Myapp::defaultDataDirectory()
{
#if defined(Q_OS_WIN32)
  return (win32_app_data_folder() + "\\Myapp");
#else
  return (QDir::homePath() + "/.Myapp");
#endif
}

/** Creates Myapp's data directory, if it doesn't already exist. */
bool
Myapp::createDataDirectory(QString *errmsg)
{
  QDir datadir(dataDirectory());
  if (!datadir.exists()) {
    QString path = datadir.absolutePath();
    if (!datadir.mkpath(path)) {
      return err(errmsg, 
                 QString("Could not create data directory: %1").arg(path));
    }
  }
  return true;
}

/** Returns the location of Myapp's pid file. */
QString
Myapp::pidFile()
{
  if (_args.contains(ARG_PIDFILE)) {
    return _args.value(ARG_PIDFILE);
  }
  return QDir::convertSeparators(dataDirectory() + "/Myapp.pid");
}

Code: Alles auswählen

#ifndef _MYAPP_H
#define _MYAPP_H

#if defined(Q_OS_WIN)
#include <windows.h>
#include <util/win32.h>
#endif

#include <QApplication>
#include <QMap>
#include <QString>


#include <config/mysettings.h>





class Myapp : public QApplication
{
  Q_OBJECT

public:
  /** Constructor. */
  Myapp(QStringList args, int &argc, char **argv);
  /** Destructor. */
  ~Myapp();

  /** Return the map of command-line arguments and values. */
  static QMap<QString, QString> arguments() { return _args; }
  /** Validates that all arguments were well-formed. */
  bool validateArguments(QString &errmsg);
  /** Prints usage information to the given text stream. */
  void printUsage(QString errmsg = QString());

  /** Sets the current language. */
  static bool setLanguage(QString languageCode = QString());
  /** Sets the current GUI style. */
  static bool setStyle(QString styleKey = QString());
  /** Shows the specified help topic, or the default if empty. */
  //static void help(QString topic = QString());

  /** Returns the current language. */
  static QString language() { return _language; }
  /** Returns the current GUI style. */
  static QString style() { return _style; }
  /** Returns Myapp's application version. */



  
  /** Returns the location Myapp uses for its data files. */
  static QString dataDirectory();
  /** Returns the default location of Myapp's data directory. */
  static QString defaultDataDirectory();
  /** Creates Myapp's data directory, if it doesn't already exist. */
  static bool createDataDirectory(QString *errmsg);
  
  /** Returns the location of Myapp's pid file. */
  static QString pidFile();
  
signals:
  /** Signals that the application needs to shutdown now. */
  void shutdown();

protected:
#if defined(Q_OS_WIN)
  /** Filters Windows events, looking for events of interest */
  bool winEventFilter(MSG *msg, long *result);
#endif

private:
  /** Parse the list of command-line arguments. */
  void parseArguments(QStringList args);
  /** Returns true if the specified arguments wants a value. */
  bool argNeedsValue(QString argName);

  static QMap<QString, QString> _args; /**< List of command-line arguments.  */
  static QString _style;               /**< The current GUI style.           */
  static QString _language;            /**< The current language.            */
  static MySettings _settings;    /**< Myapp's configurable settings. */


};

#endif