Development/Tutorials/Localization/i18n (de): Difference between revisions

From KDE TechBase
(More translation)
No edit summary
 
(6 intermediate revisions by 4 users not shown)
Line 1: Line 1:
{{Template:I18n/Language Navigation Bar|Development/Tutorials/Localization/i18n}}
 


{{TutorialBrowser (de)|
{{TutorialBrowser (de)|
Line 32: Line 32:
KDE Entwicklung findet primär in Englisch statt, da dies eine breite Entwickler- und Übersetzerschaft erreicht. Englisch ist jedoch nicht die Muttersprache der meisten Menschen auf der Welt. Tatsächlich sprechen weniger als 8% der Menschheit Englisch und weniger als 5% sprechen es als Muttersprache. Auch im Internet benutzen nur 35% der Menschen die online sind Englisch als primäre Sprache und je mehr Teile der Welt an das Internet angeschlossen werden, desto geringer wird dieser Anteil werden. Zusätzlich benutzen die meisten sprachen, alleine 9 der 10 häufigsten, nicht-ASCII Zeichen in ihrer geschriebenen Form. Daher ist es einfach zu erkennen, warum es notwendig ist, Software zu lokalisieren.  
KDE Entwicklung findet primär in Englisch statt, da dies eine breite Entwickler- und Übersetzerschaft erreicht. Englisch ist jedoch nicht die Muttersprache der meisten Menschen auf der Welt. Tatsächlich sprechen weniger als 8% der Menschheit Englisch und weniger als 5% sprechen es als Muttersprache. Auch im Internet benutzen nur 35% der Menschen die online sind Englisch als primäre Sprache und je mehr Teile der Welt an das Internet angeschlossen werden, desto geringer wird dieser Anteil werden. Zusätzlich benutzen die meisten sprachen, alleine 9 der 10 häufigsten, nicht-ASCII Zeichen in ihrer geschriebenen Form. Daher ist es einfach zu erkennen, warum es notwendig ist, Software zu lokalisieren.  


Als internationales Projekt das den gesamten Globul umspannt, ist diese Lokalisation ein wichtiges Gut der KDE Kultur. Tatsächlich entwickeln viele KDE Entwickler ihre Applikationen in Englisch benutzen jedoch ihren KDE-Desktop in der jeweils lokalisierten Version.
Als internationales Projekt das den gesamten Globus umspannt, ist diese Lokalisation ein wichtiges Gut der KDE Kultur. Tatsächlich entwickeln viele KDE Entwickler ihre Applikationen in Englisch, benutzen jedoch ihren KDE-Desktop in der jeweils lokalisierten Version.


== Übersetzbaren Code mit i18n() ==
== Übersetzbaren Code mit i18n() ==
Um sicherzustellen, dass Ihre Applikation für eine Lokalisation vorbereitet ist, müssen Sie einigen wenigen einfachen Regeln folgen. Alle für Benutzer sichtbaren Zeichenketten Ihrer Applikation sollten übersetzt werden, bevor Sie auf dem Bildschirm des Benutzers dargestellt werden, ausgenommen davon sind Debug-Ausgaben, Konfigurationsdaten und andere ähnliche Textdaten.


To ensure your application is ready to be localized you have to follow a few simple rules. All user-visible strings in your application should be translated before they are displayed on the user's screen, exceptions to this being debugging messages, configuration keys and similar types of text data.
KDE stellt als Teil von <tt>libkdecore</tt> die Klasse {{Class|KLocale}} zur Verfügung, um die technischen Aspekte der Lokalisierung zu erledigen. KLocale macht es Entwicklern so einfach wie möglich, ihren Code i18n fähig zu machen, dennoch bleiben einige Dinge, die Sie als Entwickler beachten müssen, damit die Applikation in anderen Sprachen und Ländern eingesetzt werden kann.
 
KDE provides the <tt>KLocale</tt> class as part of <tt>libkdecore</tt> to facilitate the technical details of localization. KLocale makes it as easy as possible for developers to make their code i18n aware, but there are some things you need to be aware of so that applications are usable in other languages and countries.


Access to a global <tt>KLocale</tt> object is provided via <tt>KGlobal::locale()</tt>. This <tt>KLocale</tt> object is created automatically by <tt>KInstance</tt> and takes care of all user i18n related settings. It is deleted automatically on application exit.
Zugriff auf das globale <tt>KLocale</tt> Objekt wird über <tt>KGlobal::locale()</tt> zur Verfügung gestellt. Dieses <tt>Klocale</tt> Objekt wird automatisch von {{Class|KInstance}} erzeugt und kümmert sich um alle i18n betreffenden Einstellungen. Beim Verlassen der Applikation wird das Objekt automatisch gelöscht.  


Translations are made possible by the <tt>QString i18n(const char*)</tt> method, defined in <tt>klocalizedstring.h</tt>, which you must wrap all strings that should be displayed in. The QString returned by <tt>i18n()</tt> is the translated (if necessary) string. This makes creating translatable widgets as simple as in this example:
Übersetzungen werden von der i18n(const char*) Methode von {{Qt|QString}} ermöglicht, definiert in <tt>klocalizedstring.h</tt>. Darin müssen alle Zeichenketten, die dargestellt werden, eingebettet werden. Der von <tt>i18n()</tt> zurückgegebene QString ist die (wenn nötig) übersetze Zeichenkette. Dadurch werden übersetzbare Widgets sehr einfach möglich, wie das nachfolgende Beispiel zeigt:


<code cppqt>
<syntaxhighlight lang="cpp-qt">
#include <klocalizedstring.h>
#include <klocalizedstring.h>
[...]
[...]
QPushButton* myButton = new QPushButton(i18n("Translate this!"));</code>
QPushButton* myButton = new QPushButton(i18n("Translate this!"));</syntaxhighlight>


QString's native Unicode support ensures that all translations are represented correctly. All string handling done by your application should therefore use QString.
Die native Unicode-Unterstützung von QString stellt sicher, das alle Übersetzungen richtig dargestellt werden. Alle Zeichenkettenbehandlungen Ihrer Applikation sollten daher QString benutzen.


{{tip|If the string to be translated contains any non-UTF8 characters, use the utf8() method to get a char*.}}
{{tip|Wenn die Zeichenkette, die übersetzt werden soll, irgendwelche nicht-UTF8 Zeichen enthält, benutzen Sie die Methode utf8() um ein char* zu erhalten.}}


=== ki18n ===
=== ki18n ===
Die <tt>i18n()</tt> Methode benötigt ein existierendes {{Class|KInstance}} (z.B. ein {{Class|KApplication}}) Objekt. Für Zeichenketten die vor der Erzeugung erstellt werden muss eine andere Methode zur Verfügung gestellt werden: <tt>ki18n</tt>. Diese erlaubt es, Zeichenketten zur späteren Übersetzung zu markieren. ki18n() gibt ein {{Class|KLocalizedString}} zurück, welches letztlich in ein {{Qt|QString}} konvertiert wird (also schließlich übersetzt wird), nachdem KInstance erzeugt wurde. Dabei wird dessen toString() Methode benutzt.


The <tt>i18n()</tt> method requires that a <tt>KInstance</tt> (e.g. <tt>KApplication</tt>) has been created. For any strings that are created prior  to this there is another method provided: <tt>ki18n()</tt>. This allows one to mark strings that should be translated later as such. The ki18n() will return a <tt>KLocalizedString</tt>, which can be finalized into a QString (i.e. translated for real) after the KInstance has been created, using its toString() method.
ki18n() wird typischerweise in Zeichenketten benutzt, die an {{Class|KAboutData}} übergeben werden, da dieses von {{Class|KApplication}} erzeugt wird. Außerhalb dieser Sonderfälle kann man immer ohne Bedenken i18n() benutzen, wenn man sicher ist, dass dieser Code ausgeführt nachdem KApplication oder eine andere {{Class|KInstance}} konstruiert wurde.
 
ki18n() is typically used for strings given to KAboutData, because it is constructed before the KApplication and you can use i18n() only after the construction of the KApplication. Other than these special cases, it is always safe to use i18n() if you are sure that the code will be executed after construction of KApplication or some other KInstance.


=== Kontext hinzufügen ===
=== Kontext hinzufügen ===
Es gibt eine erweiterte Version von <tt>i18n()</tt>, <tt>i18nc()</tt>, die zwei
<tt>const char*</tt> Argumente übernimmt. Das erste Argument ist eine zusätzliche Beschreibung des Kontext, in dem die zweite Zeichenkette übersetzt wird. Die erste Zeichenkette wird dabei benutzt, um zur Laufzeit die zum Kontext passende Übersetzung finden und wird den Übersetzer angezeigt, um diesen zu helfen, die Bedeutung der Zeichenkette zu verstehen.


There is an extended version of <tt>i18n()</tt>, <tt>i18nc()</tt> which takes two <tt>const char*</tt> arguments. The first argument is an additional contextual description of the second string which will be translated. The first  string is used to find the proper corresponding translation at run-time and is shown to translators to help them understand the meaning of the string.  
Benutzen Sie <tt>i18nc()</tt> immer dann, wenn der Sinn des Textes mehrdeutig sein kann ohne die Angabe eines Kontext. Stellen Sie sich zum Beispiel das Kontextmenü eines Dateimanagers vor, in dem ein Eintrag namens "View" existiert, die einen Betrachter für die momentan ausgewählte Datei startet. In diesem Kontext ist "View" ein Verb. In der gleichen Applikation könnte jetzt aber auch ein Menüeintrag namens "View" existieren und in diesem Kontext ein Nomen sein. In der englisches Version dieser Applikation würde jetzt alles in Ordnung aussehen, doch in den meisten anderen Spreachen wären diese beiden "View" Zeichenketten nicht gleich.  


Use <tt>i18nc()</tt> whenever the purpose of the text might be ambiguous without further context. For example, consider a context menu in a file manager with an entry called "View" which opens a viewer for the currently selected file. In this context "View" is a verb. However, the same application also may have a menu called "View" in the menubar. In that context "View" is a noun. In the English version of the application everything looks fine, but in most other languages one of the two "View" strings will be incorrect.
Zusätzlich benötigen Übersetzer bei ihrer Arbeit manchmal zusätzliche Hilfe zu verstehen, worauf sich der aktuelle Text gerade bezieht.  


Additionally, translators sometimes need extra help in understanding what the text is actually referring to during the translation process.
Im obigen Beispiel des Dateimanagers könnte man daher schreiben:
 
In the file manager example above, one might therefore write:
    
    
<code cppqt>contextMenu->addAction(i18nc("verb, to view something", "View"));
<syntaxhighlight lang="cpp-qt">contextMenu->addAction(i18nc("verb, to view something", "View"));
viewMenu->addAction(i18nc("noun, the view", "View"));</code>
viewMenu->addAction(i18nc("noun, the view", "View"));</syntaxhighlight>


Now the two strings will be properly translatable, both by the human translators and at runtime by KLocale.
Jetzt wären diese beiden Zeichenketten angemessen zu übersetzen, sowohl für den menschlichen Übersetzung als auch zur Laufzeit für KLocale.  


Use this form of i18n whenever the string to translate is short or the meaning is hard to discern when the context is not exactly known. For example:
Benutzen Sie diese Form von i18n immer dann, wenn die Zeichenkette, die übersetzt werden soll, kurz ist oder die Bedeutung schwer zu entscheiden ist, wenn der Kontext nicht bekannt ist. Zum Beispiel:


<code cppqt>QString up = i18nc("Go one directory up in the hierarchy", "Up");
<syntaxhighlight lang="cpp-qt">QString up = i18nc("Go one directory up in the hierarchy", "Up");
QString relation = i18nc("A person's name and their familial relationship to you.", "%1 is your %2", name, relationship);</code>
QString relation = i18nc("A person's name and their familial relationship to you.", "%1 is your %2", name, relationship);</syntaxhighlight>


{{note (de)|There is also a ki18nc("context","text") method for providing context to strings which are constructed before the KInstance. It returns a KLocalizedString, so use the toString() method afterwards to convert it into a QString.}}
{{note (de)|Es gibt auch eine ki18nc("context","text") Methode, die Kontext zu Zeichenketten hinzufügt, die vor {{Class|KInstance}} erzeugt werden (siehe oben). Es liefert ein {{Class|KLocalizedString}} zurück, damit die Methode toString() hinterher daraus einen QString erzeugen kann.}}


Contexts can also be added when building forms in Qt Designer. Each widget label, including tooltips and whatsthis texts, has a "comment" attribute, which will serve the same purpose as first argument to <tt>i18nc()</tt> call.
Kontext kann auch in Formularen, die mit dem Qt Designer erzeugt werden, hinzugefügt werden. Jedes Widget Label, einschließlich tooltips und whatsthis Texte haben ein "comment" Attribut, welches den gleichen Zweck wie das erste Argument von <tt>i18nc()</tt> hat.  


=== Standard Kontext für häufige Ausdrücke ===
=== Standard Kontext für häufige Ausdrücke ===


Below is a chart showing some common words and phrases in English and the context that must be used with them to ensure proper translation of them in other languages.
Es folgt eine Tabelle, die einige häufige Worte und Satzfragmente im Englischen und den entsprechend zu benutzenden Kontext, der benutzt werden muß, um die entsprechende Übersetzung in andere Sprachen zu bestimmen, auflistet.  
 


{|
{|
|+ Standard Contexts
|+ Standard Kontexte
|-
|-
! Phrase !! Context !! i18nc Call !! Example
! Satzfragment !! Kontext !! i18nc Call !! Beispiel
|-
|-
| Busy || Refering to a person || <tt>i18nc("A person is busy", "Busy")</tt>
| Busy || Refering to a person || <tt>i18nc("A person is busy", "Busy")</tt>
Line 140: Line 139:


=== Plural ===
=== Plural ===
Plural wird von Sprache zu Sprache unterschiedlich behandelt. Viele Sprachen haben einen unterschiedlichen Plural für 2, 10, 20, 100 usw. Wennn die Zeichenkette, die übersetzt werden soll sich auf mehr als ein Item beziehen kann, müssen Sie eine dritte Form von <tt>i18n</tt> benutzen, nämlich <tt>i18np()</tt>. Die Funktion übernimmt die Singular- und Pluralversion in Englisch als erste beide Argumebnte, gefolgt von beliebigen Argumenten, die ersetzt werden sollen. Davon muß jedoch mindestens eines eine Ganzzahl sein. Beispiel:


Plurals are handled differently from language to language. Many languages have different plurals for 2, 10, 20, 100, etc. When the string you want translated refers to more than one item, you must use the third form of <tt>i18n</tt>, the <tt>i18np()</tt>. It takes the singular and plural English forms as its first two arguments, followed by any substitution arguments as usual, but at least one of which should be integer-valued. For example:
<syntaxhighlight lang="cpp-qt">msgStr = i18np("1 image in album %2", "%1 images in album %2", numImages, albumName);
msgStr = i18np("Delete Group", "Delete Groups", numGroups);</syntaxhighlight>


<code cppqt>msgStr = i18np("1 image in album %2", "%1 images in album %2", numImages, albumName);</code>
<tt>i18np()</tt> wird enstrechend der in der Sprache des Benutzers notwenidigen Fälle erweitert. Im Englischen gibt es nur diese beiden Formen, während in anderen Sprachen mehrere existieren können, abhängig vom ersten Ganzzahlargument.


<tt>i18np()</tt> gets expanded to as many cases as required by the user's language. In English, this is just two forms while in other languages it may be more, depending on the value of the first integer-valued argument.
Beachten Sie, dass diese Form auch dann benutzt werden sollte, wenn die Zeichenkeitte sich immer auf mehrere Items bezieht, da manche Sprachen auch in anderen Fällen Singular (typischerweise bei 21, 32, etc.) benutzen. Dieser Code:


Note that this form should be used even if the string always refers to more than one item as some languages use a singular form even when referring to a multiple (typically for 21, 31, etc.). This code:
<syntaxhighlight lang="cpp-qt">i18n("%1 files were deleted", numFilesDeleted);</syntaxhighlight>


<code cppqt>i18n("%1 files were deleted", numFilesDeleted);</code>
ist daher falsch und sollte lauten:


is therefore incorrect and should instead be:
<syntaxhighlight lang="cpp-qt">i18np("1 file was deleted",  
 
<code cppqt>i18np("1 file was deleted",  
     "%1 files were deleted",
     "%1 files were deleted",
     numFilesDeleted);</code>
     numFilesDeleted);</syntaxhighlight>


To provide context as well as pluralization, use <tt>i18ncp</tt> as in this example:
Um neben Pluralangaben auch einen Kontext zu übergeben, benutzen Sie <tt>i18ncp</tt> wie in diesem Beispiel:


<code cppqt>i18ncp("Personal file", "1 file", "%1 files", numFiles);</code>
<syntaxhighlight lang="cpp-qt">i18ncp("Personal file", "1 file", "%1 files", numFiles);</syntaxhighlight>


== Datum und Zahlen formatieren ==
== Datum und Zahlen formatieren ==


When displaying a number to the user, your program must take care of the decimal separator, thousand separator and currency symbol (if any) being used. These symbols differ from region to region. In English speaking countries a dot (.) is used to separate the fractional part of a number, while in some European countries a comma (,) is used instead. Below is a short summary of functions that will help you format the numbers correctly, taking the local conventions into account for you.
When dem Benutzer Zahlen angezeigt werden, muss Ihr Programm die richtigen Dezimaltrennzeichen, Tausendertrennzeichen und Währungssymbole (falls überhaupt) darstellen. Diese Symbole unterschieden sich von Region zu Region. In englischsprachigen Ländern wird ein Punkt (.) benutzt um den gebrochenen Teil einer Zahl anzuzeigen (z.B. 12.5), während einige europäische Länder ein Komma (,) benutzen (z.B. 12,5). Es folgt eine Tabelle, die die Funktionen zusammenfasst, die Ihnen dabei hilft, diese lokalen Konventionen korrekt zu behandeln.  


{|
{|
|+ Functions to Format Numbers
|+ Funktionen um Zahlen zu formatieren
|-
|-
! Formats&nbsp;a.. !! From&nbsp;a.. !! Function&nbsp;Prototype
! Formatiert&nbsp;ein(e).. !! Von&nbsp;einem.. !! Funktions&nbsp;Prototyp
|-
|-
| Number || String || <pre>QString formatNumber( const QString & numStr )</pre>
| Zahl || String || <pre>QString formatNumber( const QString & numStr )</pre>
|-
|-
| Number || Integer,&nbsp;double || <pre>formatNumber( double num,  
| Zahl || Integer,&nbsp;double || <pre>formatNumber( double num,  
               int precision = -1 )</pre>
               int precision = -1 )</pre>
|-
|-
| Money || String || <pre>formatMoney( const QString & numStr )</pre>
| Währung || String || <pre>formatMoney( const QString & numStr )</pre>
|-
|-
| Money || Number || <pre>formatMoney( double num,  
| Währung || Zahl || <pre>formatMoney( double num,  
             const QString & currency,
             const QString & currency,
             int digits = -1 )</pre>
             int digits = -1 )</pre>
|-
|-
| Date || String || <pre>formatDate( const QDate & pDate,
| Datum || String || <pre>formatDate( const QDate & pDate,
             bool shortFormat=false )</pre>
             bool shortFormat=false )</pre>
|-
|-
| Time || QTime || <pre>formatTime( const QTime & pTime,  
| Uhrzeit || QTime || <pre>formatTime( const QTime & pTime,  
             bool includeSecs=false)</pre>
             bool includeSecs=false)</pre>
|-
|-
| Date&nbsp;and&nbsp;time || QDateTime || <pre>formatDateTime( const QDateTime &pDateTime,
| Datum&nbsp;und&nbsp;Uhrzeit || QDateTime || <pre>formatDateTime( const QDateTime &pDateTime,
                 bool shortFormat = true,
                 bool shortFormat = true,
                 bool includeSecs = false )</pre>
                 bool includeSecs = false )</pre>
|}   
|}   
 
Similar functions exist to read information provided by the user at runtime in their localized format, e.g. readNumber() or readMoney().
Ähnliche Funktionen existieren um Informationen zu lesen, die der Benutzer zur Laufzeit in seinem lokalisierten Format eingibt, z.B. readNumber() oder readMoney().


== Kalender ==
== Kalender ==


Applikationen zu entwickeln, die sich mit Datum und Zeit beschäftigen, zum Beispiel Kalender, ist ein sehr komplexes Gebiet. Nicht nur Zeichenketten die ein Datum oder eine Uhrzeit beinhalten müssen lokal angepasst werden, man muss auch andere Aspekte bedenken, wie zum Beispiel:
Applikationen zu entwickeln, die sich mit Datum und Zeit beschäftigen, zum Beispiel Kalender, ist ein sehr komplexes Gebiet. Nicht nur Zeichenketten die ein Datum oder eine Uhrzeit beinhalten müssen lokal angepasst werden, man muss auch andere Aspekte bedenken, wie zum Beispiel:
* Welcher Dag in der Woche der erste ist (cf int weekStartDay())
* Welcher Tag in der Woche der erste ist (cf int weekStartDay())
* Wieviele Monate in einem Jahr sind
* Wieviele Monate in einem Jahr sind
* "Ära"-basierte Kalender
* "Ära"-basierte Kalender
Line 207: Line 206:
|+ Kalenderdaten Funktionen
|+ Kalenderdaten Funktionen
|-                 
|-                 
! Formats&nbsp;a.. !! From&nbsp;a.. !! Function Prototype
! Formatiert&nbsp;ein(e).. !! von&nbsp;einem.. !! Funktions Prototyp
|-
|-
| Date || QDate || <pre>formatDate( const QDate & pDate,
| Datum || QDate || <pre>formatDate( const QDate & pDate,
             bool shortFormat=false )</pre>
             bool shortFormat=false )</pre>
|-
|-
| Time || QTime || <pre>formatTime( const QTime & pTime,
| Uhrzeit || QTime || <pre>formatTime( const QTime & pTime,
             bool includeSecs=false )</pre>
             bool includeSecs=false )</pre>
|-
|-
| Date&nbsp;and&nbsp;time || QDateTime || <pre>formatDateTime( const QDateTime &pDateTime,
| Datum&nbsp;und&nbsp;Uhrzeit || QDateTime || <pre>formatDateTime( const QDateTime &pDateTime,
                 bool shortFormat=true,
                 bool shortFormat=true,
                 bool includeSecs=false )</pre>
                 bool includeSecs=false )</pre>

Latest revision as of 15:39, 14 July 2012


Beim Applikationen schreiben an die Lokalisation denken
Anleitungsserie   Lokalisation
Voriges Kapitel   Introduction to Unicode ist empfohlen wenn auch nicht notwendig
Nächstes Kapitel   Häufige Fehler vermeiden
Weiterführende Texte   n/a
Navigation   Deutsche Startseite

Zusammenfassung

Eine breite Schar an Benutzern und Entwicklern zu erreichen erfordert, dass Ihre Software übersetzt werden kann und sich auch anderweitig an sprachliche und kulturelle Gegebenheiten desjenigen anpassen kann, der Ihre Applikation benutzt. Das ist die Aufgabe von Lokalisation und diese Anleitung leitet Sie durch die grundlegenden Schritte, Ihre Applikation lokalisierungsfähig zu machen.

Was ist Internationalisation and Lokalisation?

Internationalisation, oder i18n ('i', gefolgt von 18 Buchstaben und dann ein 'n'), bezeichnet den Prozess, Ihre Applikation so zu schreiben, dass sie in jeder beliebigen Sprache und Kultur laufen kann. Dabei müssen folgende Dinge berücksichtigt werden:

  • Textmitteilungen, die dem Benutzer mitgeteilt werden
  • Dateneingabe vom Benutzer, Dateien und anderen Quellen
  • Das Format von Datum, Zahlen, Währungen, etc.

Lokalisation, oder l10n ('l' gefolgt von 10 Zeichen und dann ein 'n') ist der Prozess, eine internationalisierte Applikation an bestimmte lokale Gegebenheiten anzupassen.

Im allgemeinen internationalisieren Programmierer ihre Applikationen und Übersetzerteams lokalisieren sie.

Warum ist das wichtig?

KDE Entwicklung findet primär in Englisch statt, da dies eine breite Entwickler- und Übersetzerschaft erreicht. Englisch ist jedoch nicht die Muttersprache der meisten Menschen auf der Welt. Tatsächlich sprechen weniger als 8% der Menschheit Englisch und weniger als 5% sprechen es als Muttersprache. Auch im Internet benutzen nur 35% der Menschen die online sind Englisch als primäre Sprache und je mehr Teile der Welt an das Internet angeschlossen werden, desto geringer wird dieser Anteil werden. Zusätzlich benutzen die meisten sprachen, alleine 9 der 10 häufigsten, nicht-ASCII Zeichen in ihrer geschriebenen Form. Daher ist es einfach zu erkennen, warum es notwendig ist, Software zu lokalisieren.

Als internationales Projekt das den gesamten Globus umspannt, ist diese Lokalisation ein wichtiges Gut der KDE Kultur. Tatsächlich entwickeln viele KDE Entwickler ihre Applikationen in Englisch, benutzen jedoch ihren KDE-Desktop in der jeweils lokalisierten Version.

Übersetzbaren Code mit i18n()

Um sicherzustellen, dass Ihre Applikation für eine Lokalisation vorbereitet ist, müssen Sie einigen wenigen einfachen Regeln folgen. Alle für Benutzer sichtbaren Zeichenketten Ihrer Applikation sollten übersetzt werden, bevor Sie auf dem Bildschirm des Benutzers dargestellt werden, ausgenommen davon sind Debug-Ausgaben, Konfigurationsdaten und andere ähnliche Textdaten.

KDE stellt als Teil von libkdecore die Klasse KLocale zur Verfügung, um die technischen Aspekte der Lokalisierung zu erledigen. KLocale macht es Entwicklern so einfach wie möglich, ihren Code i18n fähig zu machen, dennoch bleiben einige Dinge, die Sie als Entwickler beachten müssen, damit die Applikation in anderen Sprachen und Ländern eingesetzt werden kann.

Zugriff auf das globale KLocale Objekt wird über KGlobal::locale() zur Verfügung gestellt. Dieses Klocale Objekt wird automatisch von KInstance erzeugt und kümmert sich um alle i18n betreffenden Einstellungen. Beim Verlassen der Applikation wird das Objekt automatisch gelöscht.

Übersetzungen werden von der i18n(const char*) Methode von QString ermöglicht, definiert in klocalizedstring.h. Darin müssen alle Zeichenketten, die dargestellt werden, eingebettet werden. Der von i18n() zurückgegebene QString ist die (wenn nötig) übersetze Zeichenkette. Dadurch werden übersetzbare Widgets sehr einfach möglich, wie das nachfolgende Beispiel zeigt:

#include <klocalizedstring.h>
[...]
QPushButton* myButton = new QPushButton(i18n("Translate this!"));

Die native Unicode-Unterstützung von QString stellt sicher, das alle Übersetzungen richtig dargestellt werden. Alle Zeichenkettenbehandlungen Ihrer Applikation sollten daher QString benutzen.

Tip
Wenn die Zeichenkette, die übersetzt werden soll, irgendwelche nicht-UTF8 Zeichen enthält, benutzen Sie die Methode utf8() um ein char* zu erhalten.


ki18n

Die i18n() Methode benötigt ein existierendes KInstance (z.B. ein KApplication) Objekt. Für Zeichenketten die vor der Erzeugung erstellt werden muss eine andere Methode zur Verfügung gestellt werden: ki18n. Diese erlaubt es, Zeichenketten zur späteren Übersetzung zu markieren. ki18n() gibt ein KLocalizedString zurück, welches letztlich in ein QString konvertiert wird (also schließlich übersetzt wird), nachdem KInstance erzeugt wurde. Dabei wird dessen toString() Methode benutzt.

ki18n() wird typischerweise in Zeichenketten benutzt, die an KAboutData übergeben werden, da dieses von KApplication erzeugt wird. Außerhalb dieser Sonderfälle kann man immer ohne Bedenken i18n() benutzen, wenn man sicher ist, dass dieser Code ausgeführt nachdem KApplication oder eine andere KInstance konstruiert wurde.

Kontext hinzufügen

Es gibt eine erweiterte Version von i18n(), i18nc(), die zwei const char* Argumente übernimmt. Das erste Argument ist eine zusätzliche Beschreibung des Kontext, in dem die zweite Zeichenkette übersetzt wird. Die erste Zeichenkette wird dabei benutzt, um zur Laufzeit die zum Kontext passende Übersetzung finden und wird den Übersetzer angezeigt, um diesen zu helfen, die Bedeutung der Zeichenkette zu verstehen.

Benutzen Sie i18nc() immer dann, wenn der Sinn des Textes mehrdeutig sein kann ohne die Angabe eines Kontext. Stellen Sie sich zum Beispiel das Kontextmenü eines Dateimanagers vor, in dem ein Eintrag namens "View" existiert, die einen Betrachter für die momentan ausgewählte Datei startet. In diesem Kontext ist "View" ein Verb. In der gleichen Applikation könnte jetzt aber auch ein Menüeintrag namens "View" existieren und in diesem Kontext ein Nomen sein. In der englisches Version dieser Applikation würde jetzt alles in Ordnung aussehen, doch in den meisten anderen Spreachen wären diese beiden "View" Zeichenketten nicht gleich.

Zusätzlich benötigen Übersetzer bei ihrer Arbeit manchmal zusätzliche Hilfe zu verstehen, worauf sich der aktuelle Text gerade bezieht.

Im obigen Beispiel des Dateimanagers könnte man daher schreiben:

contextMenu->addAction(i18nc("verb, to view something", "View"));
viewMenu->addAction(i18nc("noun, the view", "View"));

Jetzt wären diese beiden Zeichenketten angemessen zu übersetzen, sowohl für den menschlichen Übersetzung als auch zur Laufzeit für KLocale.

Benutzen Sie diese Form von i18n immer dann, wenn die Zeichenkette, die übersetzt werden soll, kurz ist oder die Bedeutung schwer zu entscheiden ist, wenn der Kontext nicht bekannt ist. Zum Beispiel:

QString up = i18nc("Go one directory up in the hierarchy", "Up");
QString relation = i18nc("A person's name and their familial relationship to you.", "%1 is your %2", name, relationship);
noframe
noframe
Es gibt auch eine ki18nc("context","text") Methode, die Kontext zu Zeichenketten hinzufügt, die vor KInstance erzeugt werden (siehe oben). Es liefert ein KLocalizedString zurück, damit die Methode toString() hinterher daraus einen QString erzeugen kann.
Anmerkung


Kontext kann auch in Formularen, die mit dem Qt Designer erzeugt werden, hinzugefügt werden. Jedes Widget Label, einschließlich tooltips und whatsthis Texte haben ein "comment" Attribut, welches den gleichen Zweck wie das erste Argument von i18nc() hat.

Standard Kontext für häufige Ausdrücke

Es folgt eine Tabelle, die einige häufige Worte und Satzfragmente im Englischen und den entsprechend zu benutzenden Kontext, der benutzt werden muß, um die entsprechende Übersetzung in andere Sprachen zu bestimmen, auflistet.


Standard Kontexte
Satzfragment Kontext i18nc Call Beispiel
Busy Refering to a person i18nc("A person is busy", "Busy")
Busy Refering to a thing i18nc("A thing is busy", "Busy")
Color Color mode, as opposed to Grayscale i18nc("Color mode", "Color")
Creator Refering to a person i18nc("A person who creates", "Creator")
Creator Refering to software i18nc("Software", "Creator")
Display Refering to hardware i18nc("Hardware display", "Display")
Editor Refering to a person i18nc("A person who edits", "Editor")
Editor Refering to software i18nc("Software", "Editor")
Line Refering to drawing i18nc("Draw a line", "Line")
Line Refering to text i18nc("Line of text", "Line")
Name Refering to a name of thing i18nc("A thing's name", "Name") In theme change dialog: i18nc("Theme name", "Name")
Name Refering to first name and last name of person i18nc("Person's first and last name", "Name") In KAddessbook contact edit dialog: i18nc("Person's first and last name", "Name")
No Answer to a question i18nc("Answer to a question", "No")
No Availability of a thing i18nc("Availability", "No")
(Re)load (Re)load a document, medium etc. i18nc("(Re)load a document", "(Re)load")
(Re)load (Re)start a program, daemon etc. i18nc("(Re)start a program", "(Re)load")
Title Refering to a person i18nc("A person's title", "Title")
Title Refering to a thing i18nc("A thing's title", "Title")
Volume Refering to sound i18nc("Sound volume", "Volume")
Volume Refering to a filesystem i18nc("Filesystem volume", "Volume")
Volume Refering to books i18nc("Book volume", "Volume")
Yes Answer to a question i18nc("Answer to a question", "Yes")
Yes Availability of a thing i18nc("Availability", "Yes")

Plural

Plural wird von Sprache zu Sprache unterschiedlich behandelt. Viele Sprachen haben einen unterschiedlichen Plural für 2, 10, 20, 100 usw. Wennn die Zeichenkette, die übersetzt werden soll sich auf mehr als ein Item beziehen kann, müssen Sie eine dritte Form von i18n benutzen, nämlich i18np(). Die Funktion übernimmt die Singular- und Pluralversion in Englisch als erste beide Argumebnte, gefolgt von beliebigen Argumenten, die ersetzt werden sollen. Davon muß jedoch mindestens eines eine Ganzzahl sein. Beispiel:

msgStr = i18np("1 image in album %2", "%1 images in album %2", numImages, albumName);
msgStr = i18np("Delete Group", "Delete Groups", numGroups);

i18np() wird enstrechend der in der Sprache des Benutzers notwenidigen Fälle erweitert. Im Englischen gibt es nur diese beiden Formen, während in anderen Sprachen mehrere existieren können, abhängig vom ersten Ganzzahlargument.

Beachten Sie, dass diese Form auch dann benutzt werden sollte, wenn die Zeichenkeitte sich immer auf mehrere Items bezieht, da manche Sprachen auch in anderen Fällen Singular (typischerweise bei 21, 32, etc.) benutzen. Dieser Code:

i18n("%1 files were deleted", numFilesDeleted);

ist daher falsch und sollte lauten:

i18np("1 file was deleted", 
     "%1 files were deleted",
     numFilesDeleted);

Um neben Pluralangaben auch einen Kontext zu übergeben, benutzen Sie i18ncp wie in diesem Beispiel:

i18ncp("Personal file", "1 file", "%1 files", numFiles);

Datum und Zahlen formatieren

When dem Benutzer Zahlen angezeigt werden, muss Ihr Programm die richtigen Dezimaltrennzeichen, Tausendertrennzeichen und Währungssymbole (falls überhaupt) darstellen. Diese Symbole unterschieden sich von Region zu Region. In englischsprachigen Ländern wird ein Punkt (.) benutzt um den gebrochenen Teil einer Zahl anzuzeigen (z.B. 12.5), während einige europäische Länder ein Komma (,) benutzen (z.B. 12,5). Es folgt eine Tabelle, die die Funktionen zusammenfasst, die Ihnen dabei hilft, diese lokalen Konventionen korrekt zu behandeln.

Funktionen um Zahlen zu formatieren
Formatiert ein(e).. Von einem.. Funktions Prototyp
Zahl String
QString formatNumber( const QString & numStr )
Zahl Integer, double
formatNumber( double num, 
              int precision = -1 )
Währung String
formatMoney( const QString & numStr )
Währung Zahl
formatMoney( double num, 
             const QString & currency,
             int digits = -1 )
Datum String
formatDate( const QDate & pDate,
            bool shortFormat=false )
Uhrzeit QTime
formatTime( const QTime & pTime, 
            bool includeSecs=false)
Datum und Uhrzeit QDateTime
formatDateTime( const QDateTime &pDateTime,
                bool shortFormat = true,
                bool includeSecs = false )

Ähnliche Funktionen existieren um Informationen zu lesen, die der Benutzer zur Laufzeit in seinem lokalisierten Format eingibt, z.B. readNumber() oder readMoney().

Kalender

Applikationen zu entwickeln, die sich mit Datum und Zeit beschäftigen, zum Beispiel Kalender, ist ein sehr komplexes Gebiet. Nicht nur Zeichenketten die ein Datum oder eine Uhrzeit beinhalten müssen lokal angepasst werden, man muss auch andere Aspekte bedenken, wie zum Beispiel:

  • Welcher Tag in der Woche der erste ist (cf int weekStartDay())
  • Wieviele Monate in einem Jahr sind
  • "Ära"-basierte Kalender
  • Ob ein 24-Stunden Zeitformat benutzt wird (cf bool use12Clock())

KLocale stellt neben anderen diese Methoden zur verfügung:

Kalenderdaten Funktionen
Formatiert ein(e).. von einem.. Funktions Prototyp
Datum QDate
formatDate( const QDate & pDate,
            bool shortFormat=false )
Uhrzeit QTime
formatTime( const QTime & pTime,
            bool includeSecs=false )
Datum und Uhrzeit QDateTime
formatDateTime( const QDateTime &pDateTime,
                bool shortFormat=true,
                bool includeSecs=false )
noframe
noframe

Dieser Abschnitt muss verbessert werden: Bitte hilf mit, verwirrende Abschnitte zu bereinigen und Abschnitte zu reparieren die ein todo beinhalten


Mehr Informationen für verschiedene Kalendersysteme geben
Warnung



Häufige Fallen vermeiden

Es gibt eine Reihe von häufigen Problemen die es unmöglich machen, eine Applikation angemessen zu lokalisieren. Im nächsten Kapitel Häufige Fehler in der Lokalisation vermeiden lernen Sie mehr darüber und wie man solche Fehler vermeidet.

noframe
noframe
Dank geht an Lukáš Tinkl, Matthias Kiefer und Gary Cramblitt für die Originalversion dieser Anleitung.
Anmerkung