How to create a multi language application/de

This article may require cleanup to meet the Qt Wiki's quality standards. Reason: Auto-imported from ExpressionEngine. Please improve this article if you can. Remove the {{cleanup}} tag and add this page to Updated pages list after it's clean.

English German Ελληνικά

[toc align_right="yes" depth="2"]

Wie erstelle ich eine Applikation, welche die Sprache zur Laufzeit umschalten kann?

Erstellen einer Standardapplikation mit einem Hauptfenster

Hauptfenster der Applikation

In diesem Beispiel gibt es ein Hauptfenster mit dem Hauptmenü "Language" und ein paar Widgets im Hauptfenster. Wenn das Sprachmenü aufgeklappt wird, soll dynamisch eine Sprachauswahl angezeigt werden, je nachdem, welche Sprachdateien vorhanden sind:

Hauptfenster der Applikation mit Sprachmenü

Ordnerstruktur der Applikation:

• <Applikationsverzeichnis>
  • ausführbare Dateien
• <Applikationsverzeichnis>/languages
  • für jede Sprache ein Bild (max 16x16) mit der Fahne (z.B. de.png)
  • für jede Sprache die übersetzte Datei mit den Texten der Applikation (z.B. TranslationExample_de.qm)
  • für jede Sprache die übersetzte Datei mit den Texten von Qt (z.B. qt_de.qm)

Klassendefinition

In der Hauptfensterklasse wird die Funktion changeEvent(QEvent*) überschrieben. Für die zu ladenden Sprachdateien wird jeweils eine QTranslator Instanz angelegt. Um die Sprachumschaltung nur auszuführen, wenn sie geändert wurde, wird die aktuelle Sprache gespeichert.

class MainWindow : public QMainWindow
{
 …

protected:
 /** this event is called, when a new translator is loaded or the system language is changed
 */
 void changeEvent(QEvent''');

protected slots:
 /** this slot is called by the language menu actions
 */
 void slotLanguageChanged(QAction''' action);

private:
 /** loads a language by the given language shortcur (e.g. de, en, …)
 */
 void loadLanguage(const QString& rLanguage);

 /'''* creates the language menu dynamically from the content of m_langPath
 */
 void createLanguageMenu(void);

 Ui::MainWindow ui; /< ui definition from designer*/
 QTranslator m_translator; /*'''< contains the translations for this application*/
 QTranslator m_translatorQt; /*'''< contains the translations for qt*/
 QString m_currLang; /*'''< contains the currently loaded language*/
 QString m_langPath; /*'''< Path of language files. This is always fixed to /languages.*/
};

Erstellen des Sprachmenüs

Das Sprachmenü wird über vorhandene Sprachdateien dynamisch erstellt. Der Vorteil ist, dass nach einem Neustart des Programms neue Übersetzungen genutzt werden können. In diesem Beispiel liegen die Sprachdateien (sowohl für Qt, als auch für die Applikation) im Unterverzeichnis "languages". Dort kann für jede Sprache ein png angelegt werden, um diese als Icon darzustellen (z.B. mit einer Fahne). Für jede Sprache wird ein QAction Objekt erstellt und in eine QActionGroup hinzugefügt. Das ermöglicht, alles über einen Slot zu lösen: connect(langGroup, SIGNAL (triggered(QAction *)), this, SLOT (slotLanguageChanged(QAction *)));

// we create the menu entries dynamically, dependant on the existing translations.
void MainWindow::createLanguageMenu(void)
{
 QActionGroup* langGroup = new QActionGroup(ui.menuLanguage);
 langGroup->setExclusive(true);

connect(langGroup, SIGNAL (triggered(QAction *)), this, SLOT (slotLanguageChanged(QAction *)));

// format systems language
 QString defaultLocale = QLocale::system().name(); // e.g. "de_DE"
 defaultLocale.truncate(defaultLocale.lastIndexOf('''')); // e.g. "de"

 m_langPath = QApplication::applicationDirPath();
 m_langPath.append("/languages");
 QDir dir(m_langPath);
 QStringList fileNames = dir.entryList(QStringList("TranslationExample'''''.qm"));

 for (int i = 0; i < fileNames.size(); ++i)
 {
 // get locale extracted by filename
 QString locale;
 locale = fileNames[i]; // "TranslationExample_de.qm"
 locale.truncate(locale.lastIndexOf('.')); // "TranslationExample_de"
 locale.remove(0, locale.indexOf('''') + 1); // "de"

 QString lang = QLocale::languageToString(QLocale(locale).language());
 QIcon ico(QString("%1/%2.png").arg(m_langPath).arg(locale));

 QAction *action = new QAction(ico, lang, this);
 action->setCheckable(true);
 action->setData(locale);

 ui.menuLanguage->addAction(action);
 langGroup->addAction(action);

 // set default translators and language checked
 if (defaultLocale == locale)
 {
 action->setChecked(true);
 }
 }
}

h2. Sprachumschaltung

Für die Sprachumschaltung wird aus dem QAction Objekt das Sprachkürzel geholt, der vorhandene Translator entladen (QApplication::removeTranslator ) und die neue Sprachdatei geladen. Wenn das geklappt hat, wird der Translator wieder installiert (QApplication::installTranslator ). Dies sorgt dafür, dass das Event QEvent::LanguageChange ausgelöst wird, das an alle Widgets der Applikation gesendet wird. Wenn es sich nur um ein Top-Level-Fenster handelt und alle Texte dort gelesen werden, kann man auch den Translator die neue Datei lesen lassen und ui.retranslateUi(this) direkt aufrufen.

// Called every time, when a menu entry of the language menu is called
void MainWindow::slotLanguageChanged(QAction* action)
{
 if(0 != action)
 {
 // load the language dependant on the action content
 loadLanguage(action->data().toString());
 setWindowIcon(action->icon());
 }
}

void switchTranslator(QTranslator& translator, const QString& filename)
{
 // remove the old translator
 qApp->removeTranslator(&translator);

 // load the new translator
 if(translator.load(filename))
 qApp->installTranslator(&translator);
}

void MainWindow::loadLanguage(const QString& rLanguage)
{
 if(m_currLang != rLanguage)
 {
 m_currLang = rLanguage;
 QLocale locale = QLocale(m_currLang);
 QLocale::setDefault(locale);
 QString languageName = QLocale::languageToString(locale.language());
 switchTranslator(m_translator, QString("TranslationExample''%1.qm").arg(rLanguage));
 switchTranslator(m_translatorQt, QString("qt_%1.qm").arg(rLanguage));
 ui.statusBar->showMessage(tr("Current Language changed to %1").arg(languageName));
 }
}

QEvent::LanguageChange * wird immer dann aufgerufen, wenn ein neuer Translator mittels QApplication::installTranslator hinzugefügt wird.

• QEvent::LocaleChange * wird aufgerufen, wenn die Systemsprache umgeschaltet wird.

void MainWindow::changeEvent(QEvent* event)
{
 if(0 != event)
 {
 switch(event->type())
 {
 // this event is send if a translator is loaded
 case QEvent::LanguageChange:
 ui.retranslateUi(this);
 break;
 // this event is send, if the system, language changes
 case QEvent::LocaleChange:
 {
 QString locale = QLocale::system().name();
 locale.truncate(locale.lastIndexOf('_'));
 loadLanguage(locale);
 }
 break;
 }
 }

QMainWindow::changeEvent(event);
}

Hinzufügen der Übersetzung zur QMake Projektdatei

In der QMake projektdatei fügt man die Variable TRANSLATIONS hinzu und trägt alle Sprachen, die man erstellen möchte, ein.

TRANSLATIONS = languages/TranslationExample_en.ts  languages/TranslationExample_de.ts

Mittels lupdate

lupdate -verbose TranslationExample.pro

erzeugt man die Sprachdateien, die mit dem Qt Linguist übersetzt werden.

linguist languages/TranslationExample_en.ts languages/TranslationExample_de.ts

Dann werden die übersetzten Dateien mittels lrelease

lrelease TranslationExample.pro

in das Binärformat *.qm compiliert.

Hoffentlich kann das etwas weiterhelfen.