Development/Tutorials/Localization/i18n (de)

Development/Tutorials/Localization/i18n

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 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.

Ü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 so 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() Methoden 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

There is an extended version of i18n(), i18nc() which takes two const char* 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.

Use i18nc() 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.

Additionally, translators sometimes need extra help in understanding what the text is actually referring to during the translation process.

In the file manager example above, one might therefore write:

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

Now the two strings will be properly translatable, both by the human translators and at runtime by 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:

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

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.

Anmerkung

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 i18nc() call.

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.

Standard Contexts
Phrase	Context	i18nc Call	Example
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

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 i18n, the i18np(). 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:

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

i18np() 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.

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:

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

is therefore incorrect and should instead be:

i18np("1 file was deleted",

    "%1 files were deleted",
    numFilesDeleted);

To provide context as well as pluralization, use i18ncp as in this example:

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

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.

Functions to Format Numbers
Formats a..	From a..	Function Prototype
Number	String	QString formatNumber( const QString & numStr )
Number	Integer, double	formatNumber( double num, int precision = -1 )
Money	String	formatMoney( const QString & numStr )
Money	Number	formatMoney( double num, const QString & currency, int digits = -1 )
Date	String	formatDate( const QDate & pDate, bool shortFormat=false )
Time	QTime	formatTime( const QTime & pTime, bool includeSecs=false)
Date and time	QDateTime	formatDateTime( const QDateTime &pDateTime, bool shortFormat = true, bool includeSecs = false )

Similar functions exist to read information provided by the user at runtime in their localized format, e.g. readNumber() or 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 Dag 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

Formats a..

From a..

Function Prototype

Date

QDate

formatDate( const QDate & pDate,
            bool shortFormat=false )

Time

QTime

formatTime( const QTime & pTime,
            bool includeSecs=false )

Date and time

QDateTime

formatDateTime( const QDateTime &pDateTime,
                bool shortFormat=true,
                bool includeSecs=false )

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

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

Anmerkung