Qt/QML Sprache zur Laufzeit ändern

Software wird heutzutage meist für den internationalen Gebrauch erstellt. Neben Internationalisierung und Lokalisierung, also dem Auslegen der Software für die Unterstützung mehrerer Sprachen, Kulturen, Gebiete, besteht oftmals auch die Anforderung, die Sprache bzw. besser die Lokalisierung der Applikation zur Laufzeit zu ändern. In diesem Artikel erfahren Sie, wie Sie in Qt/QML die Sprache zur Laufzeit ändern können.

Grundlagen

Internationalisierung und Lokalisierung von Qt/QML Applikationen

Hier die Ultra-Kurzfassung über den Internationalisierungs- und Lokalisierungsworkflow mit dem Qt Framework. Einen umfassenden Artikel zur Internationalisierung und Lokalisierung von Qt/QML Applikationen finden Sie hier.

Um Texte in einer Qt/QML Applikation in mehreren Sprachen anzuzeigen, werden diese im Source Code mit einer Methode gewrapped. In den meisten Fällen wird hierzu die Methode qsTr() verwendet, die als Argument den Text in der Basissprache erwartet.

Text {
    text: qsTr("Order");
}

Anhand dieser Funktion erkennt das im Qt Framework vorhandene Tool lupdate zu übersetzenden Stellen und extrahiert diese in eine Übersetzungsdatei. In diese Übersetzungsdatei (*.ts) fügt der Übersetzer die Zielsprachen ein. Anschließend wird die um die Zielsprachen ergänzte *.ts Datei mit dem Tool lrelease in eine *.qm Datei compiliert. Die *.qm Dateien werden auch als Lokalisierungsdatei bezeichnet. Für jede Zielsprache wird eine separate Datei generiert. Zur Laufzeit liefert die qsTr() Methode dann den Text in der eingestellten Zielsprache zurück. Mehr dazu weiter unten im Artikel.

Einbinden von Übersetzungen

Damit qsTr() den zum eingestellten Gebietsschema (engl. Locale) passenden Text anzeigen kann, greift die Methode auf die QTranslator Klasse zu. QTranslator stellt im Wesentlichen Methoden zum Zugriff auf eine Lokalisierungsdatei (*.qm) zur Verfügung.

QTranslator Objekte werden der Applikation (QCoreApplication) über die installTranslator() Methode bekannt gemacht. Generell können einer Applikation über diesen Weg mehrere Translators übergeben werden, wobei Qt in umgekehrter Intsallationsreiehenfolge nach einer passenden Übersetzung sucht.

Bei jeder Änderung an den installierten Translators wird ein LanguageChange Event generiert.

Dynamische Sprachumschaltung in QML

Vor der Version 5.10

Bis zur Qt Version 5.10 war die Änderung der Sprache zur Laufzeit in QML nur mit einem Workaround möglich. Die Ursache dafür ist, dass die qsTr() Methode nicht auf das LanguageChanged Event der QCoreApplication reagiert hat.

Ein gängiger Workaround für diese Problem sieht folgendermaßen aus.

Text {
   text: qsTr("Hi World!") + context.emptyDummyString
}

Jeder zu internationalisierende Text, hier qsTr(“Hi World!”), wird mit einem globalen QML Property (emptyDummyString im obigen Beispiel) verkettet, das einen leeren String zurück liefert. Das Notify Signal dieses Properties wird dann entweder manuell beim Umschalten der Sprache oder in einem Event Handler auf das LanguageChanged Event der QCoreApplication emittiert. Die Implementierung des “Dummy” Properties erfolgt üblicherweise im C++ Raum und wird als Context Property (context im obigen Beispiel) nach QML exportiert. Durch das Emittieren des Notify Signals des emptyDummyString Properties, wird der komplette Ausdruck des Bindings inklusive des qsTr() Teils neu evaluiert und somit auch neu übersetzt.

Ein Beispiel für die prinzipielle Implementierung dieses Workarounds ist hier zu finden.

Ab der Version 5.10

Ab der Version 5.10 stellt das Qt Framework nun eine bessere Lösung für dieses Problem zur Verfügung. Die Methode QQmlEngine::retranslate(). In der aktuellen Version 5.14, evaluiert diese Methode alle QML Bindings erneut. Dies führt dazu, dass auch alle über die qsTr() Funktion übersetzten Strings aktualisiert werden. Es ist geplant, dass in einer späteren Qt Version nur noch die Bindings mit einem Aufruf von qsTr() neu evaluiert werden. QQmlEngine::retranslate() macht den in Version 5.10 nötigen Workaround somit überflüssig. Der Quelltext verkürzt sich somit zu dem einfachen Ausdruck:

Text {
   text: qsTr("Hi World!")
}

Die C++ Funktion zur Umschaltung der Sprache bzw. allgemein der Lokalisierung (engl. Locale) während der Laufzeit sieht folgendermaßen aus (ohne Error Handling).

void Application::switchLocale(const QString &locale)
{
    if (!mTranslator->isEmpty())
        QCoreApplication::removeTranslator(mTranslator);

    mTranslator->load(QStringLiteral(":/translations/") + locale);
    QCoreApplication::installTranslator(mTranslator);

    mQmlEngine->retranslate();
}

Ist bereits ein Translator installiert, wird dieser deinstalliert. Dann lädt der Translator eine neue Lokalisierungsdatei. Danach wird der Translator installiert. Im letzten Schritt wird mQmlEngine->retranslate() aufgerufen, so dass alle Property Bindings mit qsTr() erneut ausgewertet werden. Dieses neue Feature erhöht die Robustheit des Codes und führt zu einfacherem QML Code.

Hier ist das komplette Beispiel auf Github.


Über den Autor

Dominik Prause

Dominik ist passionierter Designer und Ingenieur und sucht ständig nach besseren Lösungen für die Kunden von Inspirent. Er hat langjährige Erfahrung im Design und der Realisierung von erfolgreichen High Tech Geräten für Industrie, Forschung und Entwicklung.

Qt Internationalisierung und Lokalisierung

Einführung

Fast in allen Branchen herrscht heutzutage ein globales Marktumfeld. Applikationen, Geräte und Maschinen werden deshalb in der Regel für einen internationalen Markt ausgelegt und müssen dementsprechend mehrere Sprachen, Datums-, Zeit- und Währungsformate sowie Schreibrichtungen unterstützen. Ziel ist die leichte Anpassbarkeit an andere Sprachen und Kulturen. Oftmals werden die Applikationen von den Herstellern zunächst auf einen Hauptmarkt bzw. einige Hauptmärkte angepasst und werden dann bei Bedarf nach und nach erweitert.

Was ist Internationalisierung?

Die Anpassbarkeit von Software an unterschiedliche Sprachen und Kulturen wird in der Informatik als Internationalisierung (engl. Internationalization) bezeichnet und oftmals mit i18n abgekürzt. Hierzu gehört zum Beispiel, dass Texte in der Bedienoberfläche nicht im Quellcode fest codiert sind, sondern zur Laufzeit eingelesen werden. Weiterhin werden in unterschiedlichen Kulturkreisen unterschiedlicher Datums-, Zeit- und Währungsformate, sowie unterschiedliche Maßeinheiten verwendet, die von einer internationalisierten Software unterstützt werden sollten. Text kann zum Beispiel je nach Sprache unterschiedlich lang sein oder die Orientierung (Schreibrichtung) kann sich unterscheiden. Temperaturen können zum Beispiel in Grad Celsius oder in Fahrenheit angegeben werden, Währungen zum Beispiel un Euro oder US Dollar.

Was ist Lokalisierung?

Im nächsten Schritt erfolgt die Lokalisierung (engl. Localization), die auch als l10n abgekürzt wird. Hierunter versteht man im Wesentlichen die Anpassung von Inhalten an ein bestimmtes Nutzungsgebiet (Land, Region, Gruppe). Die Lokalisierung umfasst in erster Linie die Übersetzung der Inhalte in eine andere Sprache. Gegebenenfalls auch die Anpassung von Grafiken, Farben und Formen an lokal herrschende Konventionen.

Das folgende Bild zeigt den Anmeldescreen von Facebook in drei unterschiedlichen Lokalisierungen.

qt localization

Wie werden globale Applikationen erstellt?

In der Regel sind an der Erstellung von globalen Software Applikationen mindestens Softwareentwickler und Übersetzer beteiligt. Bei großen Projekten ist oftmals auch ein Release Manager im Team.

Softwareentwickler sind dafür verantwortlich, dass die Applikation unterschiedliche Sprachen, Formate und Konventionen unterstützt. Weiterhin sind sie dafür verantwortlich, geeignete Dateien für die Übersetzer zu generieren, die die zu übersetzenden Texte und Kontextinformationen enthalten.

Übersetzer arbeiten meist mit speziellen Übersetzungstools, die dann die Dateien verarbeiten können müssen. Aber auch der Einsatz von Programmen wie Microsoft Excel, Apple Numbers oder Google Tabellen ist denkbar.    

Release Manager kümmern sich um die Koordination der Aufgaben und sind für ein funktionierendes Release verantwortlich ist.

Da heutzutage meist iterativ entwickelt wird, sollte der Prozess und die Tools nicht nur das einmalige Erstellen der Übersetzung abdecken, sondern der Vorgang sollte möglichst effizient sein und auch Änderungen an den Übersetzungen ohne großen Aufwand zulassen.

Unterstützt Qt Internationalisierung und Lokalisierung?

Das Qt Framework beinhaltet von Haus aus Werkzeuge und Mechanismen, um sowohl die Internationalisierung als auch die Lokalisierung einer Software effizient umzusetzen. Die Praxis zeigt hierbei, dass es sinnvoll ist, die Themen Internationalisierung und Lokalisierung von Anfang an in die Softwareentwicklung einzuplanen. So können mit überschaubarem Aufwand die Grundlagen für eine spätere Erweiterung und Anpassung der Applikation geschaffen werden. Eine nachträgliche Überarbeitung des Quellcodes ist extrem aufwändig und wird dann oftmals aus Kostengründen auch nicht weiterverfolgt.

Die folgenden Abschnitte beschreiben die Grundlagen, die Sie zur Internationalisierung einer Qt Applikation benötigen. Wenn Sie diesen Best Practices folgen, decken Sie alle wesentlichen Aspekte ab, um Ihre Applikation für unterschiedliche Sprachen und Kulturen fit zu machen.

Internationalisierung und Lokalisierung mit Qt

Qt stellt Werkzeuge sowie eine Methode zur Internationalisierung und Lokalisierung einer Applikation bereit. Der Prozess gliedert sich in fünf allgemeine Teile:

  1. Internationalisierung der Sourcedateien
  2. Erzeugen der Übersetzungsdateien (*.ts) mit dem Tool „lupdate“
  3. Übersetzen der Dateien mit Qt Linguist
  4. Erstellen der Lokalisierungsdateien (*.qm) mit dem Tool „lrelease“
  5. Nutzen der Lokalisierungsdateien in der Applikation

Internationalisierung der Sourcedateien

String Literale

Das Bild liefert einen Überblick über den gesamten Prozess und zeigt die Schritte, die notwendig sind, um Text im User Interface einer Qt Applikation zu internationalisieren und zu lokalisieren.

qt internationalization process

Qt Internationalisierungs- und Lokalisierungsprozess

In der Praxis bereitet der Softwareentwickler die Quelldateien entsprechend vor, er “internationalisiert” den Code. Qt unterstützt die Internationalisierung von QML, C++ und UI Dateien. Danach erstellt er die Übersetzungsdateien (Translation Source, *.ts) mit dem Qt Tool lupdate. Für jede Zielsprache wird eine eigene Übersetzungsdatei erstellt. Der Entwickler oder ein Release Manager sendet diese Dateien dann an den/die Übersetzer, der die Übersetzungen erstellt. Qt stellt für Übersetzer das Tool Linguist zur Verfügung. Ist die Übersetzung abgeschlossen, sendet der/die Übersetzer die geänderten Übersetzungsdateien an den Entwickler zurück. Dieser erzeugt mit dem Qt Tool lrelease binäre Lokalisierungsdateien (*.qm), die dann von der Applikation verwendet werden.

Im ersten Schritt müssen also alle String Literale, die übersetzt werden sollen, in den QML Sourcen „markiert“ werden. Das Qt Framework stellt hierzu mehrere Funktionen bzw. Makros zur Verfügung. Der gängigste Weg ist, die Funktion qsTr() für QML Sourcen und tr() für C++ Sourcen. Wir werden uns im Weiteren auf QML fokussieren. Weitere Informationen zur Internationalisierung von für C++ Sourcen stehen in der Qt Dokumentation. Hier ist die Deklaration der qsTr() Funktion.

string qsTr(sourceText, string disambiguation, int n)

Die Funktion erwartet mindestens das sourceText Argument, das den User Interface Text in der Basissprache repräsentiert. Über disambiguation können identische Strings unterschieden werden. Dies ist erforderlich, wenn der gleiche Text in unterschiedlichen Bedeutungen verwendet wird. Details dazu folgen weiter unten. Mit dem Argument n kann ein numerischer Wert dynamisch in den Text eingefügt werden. Die qsTr() Funktion gibt den übersetzen Text zurück, falls eine Übersetzung vorliegt, im anderen Fall wird sourceText zurück gegeben. Weitere Informationen zu qsTr() gibt es hier.

Das folgende Code Snippet zeigt die grundlegende Verwendung in einem QML Text Element.

Text {
    text: qsTr("Order");
}

Der Code im Bild fügt den Text „Order“ als Basistext in die Übersetzungsdatei ein. Zur Laufzeit wird die entsprechende Übersetzung gemäß des aktuell eingestellten Gebietsschemas von qsTr(„Order“) zurückgegeben, so dass das User Interface die passende Übersetzung anzeigt.

Kontext

In der Praxis kommt es oftmals vor, dass ein Wort in unterschiedlichen Kontexten unterschiedliche Bedeutungen hat. In unserem Beispiel könnte mit „Order“ zum Beispiel „Reihenfolge“ oder „Bestellung“ gemeint sein. Mithilfe strukturierter Kommentare können dem Übersetzer weitere Informationen gegeben werden.

Das folgende Bild zeigt die möglichen Kommentarformen.

Text {
    // Caption of the order selection box 
    //: The order of items, e.g. A-Z and Z-A
    //~ Context Not related to ordering a pizza
    text: qsTr("Order");
}

Wichtig ist, dass die Kommentare direkt vor dem zu übersetzenden Text stehen müssen. Diese Kommentare werden dann in die Übersetzungsdateien (*.ts) übernommen.

Der Text nach //: ist der Hauptkommentar für den Übersetzer. Der Text nach //~ ist optional und es können zusätzliche Informationen für den Übersetzer bereitgestellt werden. Wichtig zu wissen ist, dass das erste Wort nach //~, hier „Context“, nicht zum Text zählt, sondern in ein XML Tag in der .ts Datei übersetzt wird.

Identische Texte

Um dem Übersetzer die Arbeit zu erleichtern, werden gleiche String Literale in der Übersetzungsdatei (*.ts) zusammengefasst, so dass der Text nur einmal übersetzt werden muss. Es gibt jedoch Situationen, in denen das nicht gewünscht ist. Um beim vorherigen Beispiel zu bleiben könnte an unterschiedlichen Stellen in der Software der Text „Order“ vorkommen. Einmal mit der Bedeutung „Reihenfolge“ und einmal mit der Bedeutung „Bestellung“.

Für die Unterscheidung identischer Texte bietet die qsTr() Funktion den zweiten Parameter disambiguation vom Typ String. Hier kann zusätzlicher Text für die Beschreibung des Kontexts hinzugefügt werden. Wird dieser Parameter angegeben, werden die beiden Vorkommnisse von „Order“ nicht zu einem Eintrag in der Übersetzungsdatei zusammengefasst.

Text {
    // Caption of the order selection box 
    //: The order of items, e.g. A-Z and Z-A
    //~ Context Not related to ordering a pizza
    text: qsTr("Order", "Data table on summary page");
}

Parameter

Sollen dynamisch Daten in einen String eingefügt werden, bietet Qt ebenfalls eine solide Lösung. Über die Platzhalter %x (in unserem Fall %1 und %2) können die Parameter in den .arg() Funktionen in den String eingebunden werden. %1 bezieht sich auf den ersten Parameter, %2 auf den zweiten. Die Ausgabe könnte z.b. folgendermaßen aussehen: „Message 2 of 3 received.“. Die Reihenfolge der Platzhalter im Text ist wird hierbei nicht beachtet. %1 bezieht sich immer auf das Argument der ersten arg() Methode, %2 auf die zweite, usw. Die Platzhalter können auch mehrfach im Text verwendet werden (z.B. “Message %1. %1 of %2 received.”).

Text {
    text: qsTr("Message %1 of %2 received.").arg(counter).arg(total)
}

Alternativ kann auch ein lokalisierter Platzhalter %Lx (%L1, %L2, etc.) verwendet werden. In diesem Fall werden Zahlen in ihrem lokalen Format angezeigt. Die Zahl 1234.56 würde z.B. für den amerikanischen Sprachraum mit „1,234.56“ (Komma als Tausendertrennzeichen und Punkt als Dezimaltrennzeichen) angezeigt werden und für den deutschen Sprachraum mit „1.234,56“ (Punkt als Tausendertrennzeichen und Komma als Dezimaltrennzeichen).

Text {
    text: qsTr("%L1").arg(total)
}

Pluralformen

Manche übersetzbaren Strings beinhalten Platzhalter für Zahlen und sollten abhängig von der Zahl unterschiedlich übersetzt werden. In den meisten Sprachen gibt es Singular und Plural Formen, in manchen Sprachen gibt es noch weitere Formen.

Für diesen Fall bietet die Funktion qsTr() das Argument n. Ist dieses Argument Null oder größer Null, wird die Dezimalzahl angezeigt. Zusätzlich wird die Übersetzung abhängig von den Regeln der Zielsprache angepasst.

Text {
    text: qsTr("%n message(s) sent.", “”, n)
}

Für das obige Beispiel würde die deutsche Übersetzung bei n=0 „0 Nachrichten gesendet.“, bei n=1 „1 Nachricht gesendet.“ und bei n>1 z.B. „7 Nachrichten gesendet.“ heißen.

Weitere Informationen hierzu finden Sie unter folgenden Links:

Datums- und Zeitformate

Um Datums- und Zeitformate mit Qt zu internationalisieren, verwenden wir eine Kombination aus Platzhaltern und den .arg() Funktionen, sowie den Formatierungsfunktionen der Date Klasse.

Im folgenden Snippet wird an der Stelle %1 im String das Argument der .arg() Funktion eingefügt. Das Argument Date().toLocaleString(Qt.locale(“de_DE”))) liefert einen String mit der lokalisierten Zeit und dem lokalisierten Datum.

Text {
    text: qsTr("Date %1").arg(Date().toLocaleString(Qt.locale(“de_DE”)))
}

Weitere Informationen finden Sie hier:

Währungsformate

Währungen werden wie Datum und Uhrzeit internationalisiert. Anstatt dem Date Typ wird hierzu der Number Typ verwendet.

Multimediadateien

Auch Audio-, Video- und Bilddateien sollen ggf. internationalisiert werden. Dazu kann über Qt.locale() (https://doc.qt.io/qt-5/qml-qtqml-locale.html) die aktuelle Lokalisierung abgefragt werden. Die „name“ Eigenschaft liefert hier einen String der Form „language_country“, z.B. „de_DE“, wobei der erste Teil dem ISO 639 Sprachcode https://de.wikipedia.org/wiki/Liste_der_ISO-639-1-Codes entspricht und der zweite Teil dem ISO 3166 Ländercode https://de.wikipedia.org/wiki/ISO-3166-1-Kodierliste. Weitere Informationen zu diesen IETF Language tags gibt es hier (englisch).

Das folgende Listing zeigt ein Beispiel, wie unterschiedliche Bilder in Abhängigkeit der Sprache verwendet werden können.

Component.onCompleted: {
    switch (Qt.locale().name.substring(0,2)) {
        case "en":   // English language icon
            languageIcon = "../images/language-icon_en.png";
            break;
        case "de":   // German language icon
            languageIcon = "../images/language-icon_de.png";
            break;
        default:     // Default language icon
            languageIcon = "../images/language-icon_default.png";
    }
}

Keyboard Accelerators

Tastaturkombinationen nach dem Schema „Alt+Buchstabe“ für einen Menüeintrag oder einen Button, werden in QML mit dem Voranstellen eines „&“ gekennzeichnet.

qt keyboard accelerator internationalization

ApplicationWindow {
...

    menuBar: MenuBar {
        Menu {
            title: qsTr("&File")
            Action { text: qsTr("&New...") }
            Action { text: qsTr("&Open...") }
            Action { text: qsTr("&Save") }
        }
    }
}

Für den Menüeintrag „New“ würde man also “&New…” im Source Code schreiben. Das „&“ wird mit in die Übersetzungsdatei übernommen und kann vom Übersetzer ggf. vor einen anderen Buchstaben gesetzt werden. Z.B. wenn der Buchstabe in der Zielsprache nicht vorhanden ist bzw. schon anderweitig belegt ist.

Erzeugen der Übersetzungsquelldateien (.ts Dateien)

Nachdem die Quelldateien internationalisiert wurden, folgt im nächsten Schritt das Erstellen der Übersetzungsdateien (*.ts). Für jede Zielsprache wird hierbei eine separate Datei erzeugt. In der Praxis hat es sich bewährt, ein separates Verzeichnis mit dem Namen “translations”, “languages”, o.Ä. im Projektverzeichnis anzulegen. Weiterhin bietet sich an, auch für die Dateinamen die ISO 639 Sprachcodes und ISO 3166 Ländercodes zu verwenden. Z.B “de-DE.ts” oder “en-US.ts”.

Die Dateien werden mit dem Tool lupdate (MS Windows: lupdate.exe) erzeugt. lupdate kann über die Kommandozeile oder direkt aus Qt Creator aus aufgerufen werden. Weitere Infos zur Benutzung über die Kommandozeile gibt es hier. In der Version 4.11.1 von Qt Creator ist der Eintrag unter Extras > Extern > Linguist > Übersetzungen aktualisieren (lupdate) zu finden.

Beim Erzeugen der Dateien über Qt Creator wird standardmäßig die Projektdatei (*.pro) als Argument für lupdate übergeben. Hierbei ist es wichtig, die Variable TRANSLATIONS entsprechend mit den zu erstellenden Dateien zu setzen, da sonst keine Dateien erzeugt werden. Weiterhin muss der Pfad bzw. das Verzeichnis für die Dateien bereits existieren.

Folgende Snippets zeigen den QML Quelltext (links) und die daraus erzeugte Übersetzungsdatei (rechts).

Text {
        // Caption of the order selection box
        //: The order of items, e.g. A-Z and Z-A
        //~ Context Not related to ordering a pizza
        text: qsTr("Order", "Like A to Z")
    }
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1">
<context>
    <name>main</name>
    <message>
        <location filename="../main.qml" line="45"/>
        <source>Order</source>
        <comment>Like A to Z</comment>
        <extracomment>The order of items, e.g. A-Z and Z-A</extracomment>
        <translation type="unfinished"></translation>
        <extra-Context>Not related to ordering a pizza</extra-Context>
    </message>
</context>
</TS>

lupdate erstellt pro Sprache eine einzige Übersetzungsdatei für die komplette Applikation. Sowohl aus QML Source Dateien als auch aus C++ Quellcode werden die “markierten” Strings extrahiert. Ebenso kann auch aus QML und C++ auf die Übersetzungen zugegriffen werden.

Übersetzen der Dateien

Für die Übersetzung in die Zielsprachen stellt das Qt Framework die hauseigene Software Linguist zur Verfügung. Der Übersetzer öffnet die Übersetzungsdateien (*.ts) mit Linguist und übersetzt die einzelnen Wörter bzw. Phrasen. Die Änderungen (Übersetzungen) werden hierbei direkt in die .ts Dateien geschrieben. Nach erfolgter Übersetzung werden aus diesen (geänderten) Übersetzungdateien (*.ts) die Lokalisierungsdateien (*.qm) erzeugt.

Erstellen der Lokalisierungsdateien (*.qm)

Die Lokalisierungsdateien (*.qm) werden aus den Übersetzungsdateien (*.ts) über das Qt Tool lrelease (MS Windos: lrelease.exe) erzeugt. lrelease kann über die Kommandozeile oder direkt aus Qt Creator aus aufgerufen werden. Weitere Infos zur Benutzung über die Kommandozeile gibt es hier. In der Version 4.11.1 von Qt Creator ist der Eintrag unter Extras > Extern > Linguist > Übersetzungen freigeben (lrelease) zu finden. Aus jeder .ts Datei wird hierbei eine gleichnamige .qm Datei erzeugt. Das .qm Dateiformat ist ein kompaktes Binärformat, das von der lokalisierten Applikation verwendet wird.

Einbinden der Übersetzungen in die Applikation

Das Einbinden der Lokalisierungsdateien (*.qm) in eine Applikation erfolgt über die QTranslator Klasse. Die QTranslator Klasse kapselt im Wesentlichen eine Lokalisierungsdatei und stellt Methoden für deren Verarbeitung bereit. In der Regel wird man nicht direkt mit der QTranslator Klasse arbeiten, sondern sie wird vielmehr vom Qt Framework im Hintergrund verwendet. Über die Methode installTranslator() wird der Translator schließlich dem Applikationsobjekt bekannt gemacht.

Es kann mehr als ein Translator installiert werden. Qt wird zunächst versuchen den zuletzt installierten Translator für die Übersetzung zu verwenden. Falls ein String nicht in der Übersetzung vorhanden ist, versucht Qt schrittweise die installierten Translator in umgekehrter Installationsreihenfolge zu verwenden. Sollte keiner der installierten Translator eine passende Übersetzung haben, wird der String im Source Code verwendet.

Das folgende Snippet zeigt ein Beispiel, bei dem zwei Translator (deDeTranslator und enUsTranslator) eingebunden werden.

int main(int argc, char *argv[])
{
    ...

    QGuiApplication app(argc, argv);

    QTranslator deDeTranslator;
    deDeTranslator.load(":/translations/de-de.qm");
    app.installTranslator(&deDeTranslator);

    QTranslator enUsTranslator;
    qDebug() <<  enUsTranslator.load(":/translations/en-us.qm");
    app.installTranslator(&enUsTranslator);

    ...

    return app.exec();
}

Dynamische Änderung der Lokalisierung

Eine häufige Anforderung ist das dynamische ändern der Sprache zur Laufzeit der Applikation. Hierfür sind einige zusätzliche Dinge zu beachten, die in diesem Artikel näher Beschrieben sind.

Praxistipps

Im Folgenden ein paar nützliche Praxistipps, mit denen Sie Frustrationen bei der Internationalisierung und Lokalisierung Ihrer Qt Applikationen vermeiden:

  • Internationalisierung von Anfang an in die Softwareentwicklung einplanen
  • Rechtzeitig vor einem Release einen Termin für einen “String Freeze” festlegen, nachdem keine Änderungen mehr an den User Interface Texten vorgenommen werden dürfen.
  • Einplanen von ausreichend Zeit für die Übersetzung. Eine hochwertige Übersetzung kann je nach Projekt mehrere Wochen dauern.
  • Wenn möglich, Übersetzer mit Branchenkenntnis einsetzen, so dass Fachbegriffe im jeweiligen Jargon verwendet werden.
  • Konventionen einhalten. Z. B. bei gängigen Menüeinträgen wie “Datei”, “Bearbeiten”, etc.
  • Verwenden einfacher, eindeutiger und klarer Ausdrücke.
  • Multimedia Ressourcen wenn möglich universell gestalten.
  • Unbedingt unterschiedliche Textlängen im Layout beachten, damit Text nicht “abgeschnitten” wird
  • Source Code im Unicode Format speichern
  • Verwendung von QString für alle im User Interface sichtbaren Strings
  • Lokalisierungsdateien wenn möglich als Qt Ressourcen in die Applikation hinein compilieren.

Häufige Fehler und Probleme

  • Aneinanderreihung (Verkettung) von Strings
  • Vergessen der Lokalisierung von Datum, Währungen, etc.
  • Vergessen von Übersetzungskommentaren für nicht offensichtliche Strings
  • Vergessen eines “disambiguation” Strings bei einem gleichen String in unterschiedlichen Rollen
  • Anwenden von tr() auf Strings, die sich zur Laufzeit ändern
  • Falsche Encoding Format Einstellung im Editor
  • Verwenden von Vergleichen ohne die Berücksichtigung der Lokalisierung

Fragen & Antworten

Qt unterstützt beide Schreibrichtungen. Links-nach-rechts und rechts-nach links.
Ja, Qt unterstützt auch chinesische Schriftzeichen.

Über den Autor

Dominik Prause

Dominik ist passionierter Designer und Ingenieur und sucht ständig nach besseren Lösungen für die Kunden von Inspirent. Er hat langjährige Erfahrung im Design und der Realisierung von erfolgreichen High Tech Geräten für Industrie, Forschung und Entwicklung.