Einführung |  String-Tabellen |  Schritt 1 - Sprach-Datei erzeugen |  Schritt 2 - Sprachumschaltung |  FAQ - leer

---

Es gibt verschiedene Möglichkeiten, mehrsprachige Anwendungen mit Delphi zu erstellen. Einige Delphi-Versionen besitzen dazu spezielle Tools (Translation Suites u.a.). Grundsätzlich stehen folgende Möglichkeiten zur Verfügung:

• Erstellen von Ressourcen-Dlls die z. B. Formulare in mehreren Sprachen beinhalten
• Verwenden von String-Tabellen
• Verwenden von separaten Dateien, die die übersetzten Texte beinhalten
• Verwendung von String-Konstanten im Programm
• Getrennte Programmversionen für jede Sprache

Methode	Besonderheiten	Vorteile	Nachteile
Ressourcen-Dlls	Es erfolgt eine Trennung von Formularen und der zugehörigen Logik. Die Formulare werden separat übersetzt.	Anpassungen an die Größe der Komponenten und das Umschalten der Sprache im laufenden Programm ist möglich. Es gibt eine Unterstützung durch Delphi.	Nach Änderungen ist die Übersetzung des Programms (der Dll's) notwendig.
String-Tabellen	String-Tabellen werden in Textform erstellt und als Ressource-Datei (*.rc) in ein Delphi-Projekt eingebunden.	Über spezielle Tools (Ressource Workshop) können die Einträge bearbeitet werden, ohne das das Programm neu übersetzt werden muss	Die Änderung ist nur durch Personen möglich, die solch ein Tool besitzen.
Separate Dateien	Separate Sprach-Dateien können unterschiedlich aufgebaut sein, z.B. als Ini-Datei mit Abschnitten in denen Name-Wert-Paare eingefügt werden oder als einfache Textdateien.	Diese Dateien liegen separat zum Programm vor und können durch die Endanwender bearbeitet werden. Auf diese Weise können Programme schnell in eine neue Sprache übersetzt werden. Die Sprachumschaltung kann mit oder ohne Neustart des Programms erfolgen.	Durch die Möglichkeit der Änderung der Dateien durch die Anwender kann nicht verhindert werden, dass fehlerhafte/unsinnige Übersetzungen durchgeführt werden.
String-Konstanten	Über Konstanten oder String-Arrays werden Zeichenketten für mehrere Sprachen definiert.	Es sind keine speziellen Kenntnisse notwendig.	Der Zugriff auf die Konstanten und Zuweisung der Werte an die Komponenten sowie die Wartung der Konstanten ist sehr umständlich.
Getrennte Übersetzung für jede Sprache	Für jede Sprache wird eine eigene Programmversion erstellt.	Das Programm kann optimal für eine Sprache konfiguriert werden.	Installationen, Übersetzungen usw. sind für jede Sprachversion getrennt notwendig. Es ist gegebenenfalls mehr Verwaltungsaufwand notwendig.

Allgemeine Betrachtungen

Worauf ist bei einer Übersetzung zu achten:

• Sie müssen alle Textausgaben übersetzen
• Beachten Sie unterschiedliche Datum-, Zeit- und Währungsformatierungen, z. B. 22/4/2003 oder 22.4.2003
• Achten Sie darauf, dass die übersetzten Texte auf die Komponenten "passen"
• Übersetzen Sie auch vordefinierte Listeninhalte (z. B. Versandarten (Post, Nachnahme, ...))
• Wollen/können Sie die Sprachumschaltung zur Laufzeit vornehmen
• Übersetzen Sie alle Formulare und überlegen Sie, wann und wie die Übersetzung erfolgen soll
• Wollen Sie auch die Hilfe, die Lizenztexte und die Readme übersetzen
• Wie bilden Sie die Komponenten und deren Eigenschaften auf die Übersetzung ab
• Es gibt auch Komponenten die nicht übersetzt werden müssen
• Denken Sie an alle zu übersetzenden Eigenschaften (Caption, Items, Filter (OpenDialog), Title(OpenDialog), evt. Text, Hint usw.)

Einführung |  String-Tabellen |  Schritt 1 - Sprach-Datei erzeugen |  Schritt 2 - Sprachumschaltung |  FAQ - leer

---

Download Beispiel - Example1.zip

Für die Erstellung einer mehrsprachigen Anwendung über String-Tabellen ist die folgende Vorgehensweise möglich (es gibt verschiedene Möglichkeiten der Erstellung einer String-Tabelle):

• Erstellen der String-Tabelle
• Erstellung der Anwendung
• Vorüberlegung, wie eine Zuordnung der Strings zu den Eigenschaften einer Komponente erfolgen kann. Beachten Sie, dass Komponenten mehrere sprachspezifische Eigenschaften wie Caption, Hint, Items besitzen können
• Definieren Sie Offsets (konstante Zahlen, die zu einer anderen hinzu addiert werden) für die verschiedenen Sprachversionen. Lassen Sie dazu genügend Spielraum für Erweiterungen (genügend Abstände zwischen den Offsets).
• Binden Sie die String-Tabelle in die Anwendung ein
• Stellen Sie eine Methode zum Laden der Strings zur Verfügung
• Erstellen Sie eine Methode, die ein Formular für eine bestimmte Sprache initialisiert. Übergeben Sie der Methode eine Konstante (Offset) für die gewünschte Sprache.

Erstellen des Beispiel-Programms

1. Erstellen Sie in Delphi eine neue Anwendung.
2. Fügen Sie 2 Button-Komponenten ein.
3. Benennen Sie die Komponenten folgendermaßen

Komponente	Eigenschaft	Wert
Formular	Name	frmMain
	Caption	SprachWandler
Button	Name	btnGerman
	Caption	Deutsch
Button	Name	btnEnglish
	Caption	Englisch

4. Speichern Sie die Dateien unter untMain.pas (Formular) und StringTable.dpr (Projekt) ab.
5. Erstellen Sie eine neue Text-Datei mit dem Namen LanFile.rc und binden Sie diese in das Projekt ein. Dadurch wird sie automatisch übersetzt (in eine *.res-Datei) und in die Anwendung eingebunden. Sie dürfen in diesem Fall die *.res-Datei nicht nocheinmal über {$R LanFile.res} einbinden.
6. Alternativ binden Sie die *.rc-Datei nicht in das Projekt ein. Übersetzen Sie die Datei LanFile.rc über das Kommando brcc32 LanFile.rc in eine *.res-Datei und binden Sie diese über {$R LanFile.res} in das Projekt ein.

Erstellen der String-Tabelle

Fügen Sie den folgenden Text in die Datei LanFile.rc ein:

STRINGTABLE
BEGIN
  1, "Sprachwandler"
  2, "Deutsch"
  3, "Englisch"
  1001, "LanguageChanger"
  1002, "German"
  1003, "English"
END

Über STRINGTABLE BEGIN und END wird der Inhalt der String-Tabelle eingeschlossen. Die Einträge der String-Tabelle haben die Form: Bezeichner, Wert. Die Werte mit dem Index 1-3 stellen die deutschen Übersetzungen dar, die Werte mit dem Index 1001-1003 die englischen mit einem Offset von 1000. Wenn eine String-Tabelle in eine *.exe- oder *.dll-Datei eingebunden wird, befindet sie sich in einem sogenannten Ressourcenbereich. Dieser kann mit bestimmten Tools direkt in der *.exe-Datei bearbeitet werden.

Zugriff auf die Werte der String-Tabelle

Definieren Sie je eine Konstante für die Offsets der Übersetzungen in der String-Tabelle. Der Funktion GetStringFromRessource übergeben Sie die ID in der String-Tabelle und den Offset. Sie liefert den String aus der Tabelle zurück. Liefert die Funktion LoadString einen Wert größer 0 konnte der String gefunden werden. Um das Ganze effizienter zu machen, können Sie die Speicherbereitstellung/-freigabe auslagern (z. B. in die Ereignisse FormCreate / FormDestroy).

const
  GERMAN = 0;      // Offset deutsche Version
  ENGLISH = 1000;  // Offset englische Version

function GetStringFromRessource(ID, Offset: Integer): string;
var
  p: PChar;
begin
  p := StrAlloc(256);
  try
  if LoadString(hInstance, ID + Offset, p, 255) <> 0 then
    Result := p
  else
    Result := '';
  finally
    StrDispose(p);
  end;
end;

Erstellung einer Sprachumschaltungsmethode

Erstellen Sie eine Methode zum Umschalten der Sprache. Dieser wird der Offset der einzustellenden Sprache übergeben. Die Initialisierung der Komponenten ist in diesem Beispiel recht umständlich gelöst, da für jede Eigenschaft einer Komponente ein eigener Aufruf notwendig ist.

procedure TfrmMain.InitForm(Offset: Integer);
begin
  frmMain.Caption := GetStringFromRessource(1, Offset);
  btnGerman.Caption := GetStringFromRessource(2, Offset);
  btnEnglish.Caption := GetStringFromRessource(3, Offset);
end;

Eine andere Möglichkeit, wie Sie auch in der zweiten Variante genauer beschrieben wird ist die Iteration über alle Formulare und deren Komponenten innerhalb einer einzigen Schleife. Die Komponenten werden über Ihren Typ identifiziert. Der String in der String-Tabelle wird über den Wert der Eigenschaft Tag der Komponente gefunden.

// Die Elemente der Eigenschaft Components einer Anwendung sind Formulare
var
  i, j: Integer;
  c: TComponent;
begin
  // dies geht nur für automatisch erstellten Formulare
  for i := 0 to Application.ComponentCount - 1 do
  begin
    // Iteration über alle Komponenten  eines Formulars
    for j := 0 to Application.Components[i].ComponentCount - 1 do
    begin
      c := Application.Components[i].Components[j];
      if c is TButton then
        (c as TButton).Caption := GetStringFromRessource((c as TButton).Tag, Offset);
        ...
      ...
    end;
  end;
end;

Aufruf der Methode

Beim Klicken auf den Button DEUTSCH, wird die folgende Ereignisbehandlung ausgeführt:

procedure TfrmMain.btnGermanClick(Sender: TObject);
begin
  InitForm(GERMAN);
end;

Einführung |  String-Tabellen |  Schritt 1 - Sprach-Datei erzeugen |  Schritt 2 - Sprachumschaltung |  FAQ - leer

---

Download Beispiel - Example2.zip

Es wird im folgenden die eine Übersetzungsvariante vorgestellt, die mit separaten Sprach-Dateien arbeitet. Diese können vom Endanwender bearbeitet werden, so dass einfach Anpassungen oder Übersetzungen in eine neue Sprache möglich sind. Die Dateien werden innerhalb des Programms über ein Menü oder eine Auswahlbox zur Auswahl der Sprache angeboten.

Pro Sprache wird eine Datei verwendet. Diese enthält Einträge der Form Name=Wert, wobei sich der Name aus dem Namen einer Komponente und einer Eigenschaft zusammensetzen kann. Der Wert ist der Text der entsrechenden Eigenschaft.

..\Anwendungsverzeichnis	Verzeichnis des Hauptprogramms
..\Anwendungsverzeichnis\Sprache	Verzeichnis der Sprachdateien

Text der z. B. in Meldungsfenstern angezeigt wird, ist in einem Array von Strings in der Anwendung untergebracht. Diese werden durchnummeriert und mit aussagekräftigen Konstanten versehen.

Die Dateien besitzen eine spezielle Namensgebung und befinden sich an einer definierten Position. Die Dateien werden mit dem Namen der Sprache in der jeweiligen Landessprache benannt und erhalten die Endung *.lng (oder eine andere), z. B. Deutsch.lng, English.lng.

Die Umstellung eines Programms auf diese mehrsprachige Variante erfolgt in den folgenden Schritten:

1. Vergeben Sie aussagekräftige Namen für die Komponenten, die einen sprachabhängigen Teil beinhalten (für alle anderen macht dies natürlich auch Sinn).
2. Verlagern Sie alle Formulare in die automatische Erstellung bzw. führen Sie die folgenden Aufgaben z. T. einzeln für die jeweiligen Formulare durch.
3. Erstellen Sie eine separate Unit und verlagern Sie alle Zeichenketten und sprachabhängigen Teile in diese Unit.
4. Installieren Sie die Komponente TDFInitLng und fügen Sie diese im Hauptformular (und allen nicht dynamisch erstellten Formularen) ein. Über diese Komponente können Sie die Sprachdatei zum Großteil automatisch erstellen. Es geht natürlich auch manuell.
5. Rufen Sie die entsprechenden Methoden der Komponente auf, um die Sprachdatei zu erstellen.
6. Aufräumarbeiten

Schritt 1

Benennen Sie die Komponenten mit aussagekräftigen Namen. Diese Namen befinden sich später auch in der Sprach-Datei. Dem Übersetzer sollten Sie genug Informationen liefern, um welchen Programmteil es sich handelt. Verwenden Sie für jede Komponente ein spezielles Kürzel, um zu kennzeichnen, dass diese nicht übersetzt, bzw. beim Schreiben der Sprachdatei nicht berücksichtigt werden soll. Ein solches Kürzel könnte z. B. DT für 'Dont Translate' sein. Sinn macht dieses z. B. bei Separator-Menüpunkten - miSepDT.

Schritt 2

• Öffnen Sie den Menüpunkt PROJEKT - OPTIONEN.
• Öffnen Sie das Register FORMULARE.
• Fügen Sie alle Formulare (falls möglich, beachten Sie eventuelle Abhängigkeiten für das Erzeugen eines Formulats) in die Liste der automatisch erstellten Formulare ein. 

Schritt 3

Erstellen Sie eine neue Unit.
Erstellen Sie ein Array von Strings (bessere Ideen werden gern angenommen) und fügen Sie in dieses Array die sprachabhängigen Teile ein. Definieren Sie Konstanten, die den Index der Zeichenkette im Array als Wert besitzen.

var StrLst: array[1..3] of string = ('Sie müssen einen Listeneintrag markieren',
                                     'Willkommen im Kurs',
                                     'Information');
const
  SELECTLISTENTRY = 1;
  WELCOMEMSG      = 2;
  MSGBXINFO       = 3;

Binden Sie diese Unit in alle Formulare ein, die Zeichenketten daraus benötigen. Greifen Sie auf die Zeichenketten über die folgende Anweisung zu:

XXX := StrLst[MSGBXINFO];

Schritt 4

Fügen Sie die Komponente DFInitLng in das Hauptformular ein. Diese hat zwei wichtige Prozeduren:

WriteComponentProperties(LgnWriteMode:     TLgnWriteMode);	Schreibt die Namen, Eigenschaften und deren Werte in eine Datei. Der Modus legt fest, ob die Datei neu erstellt oder die Daten angefügt werden.
WriteInternalStrings(var InternalStrings:     array of string; Offset: Integer;     LgnWriteMode: TLgnWriteMode);	über diese Methode schreiben Sie das Array von Strings in die Sprachdatei. Als erstes übergeben Sie den Namen des Arrays, dann den Offset mit dem diese durchnummeriert werden sollen und den Modus (in der Regel DFLngAppend - anfügen).

Auf diese Weise schreiben Sie alle relevanten Daten in die Sprachdatei. Da Sie die Methoden evt. erweitern müssen (z. B. wenn Sie eigene Komponenten einsetzen), hier eine kurze Erläuterung der Funktionsweise - der Quelltext ist zum Teil gekürzt :

procedure TDFInitLng.WriteComponentProperties(LgnWriteMode: TLgnWriteMode);
var
  FormsIdx, j, k: Integer;
  FormName: string;
  C: TComponent;
  C2: TComponent;
  ItemCount: Integer;
  ItemString: string;
begin
  ...
  // iterieren über alle Komponenten der Anwendung - in der Regel die Formulare
  // aus diesem Grund sollen die Formulare auch in die automatische Erstellung
  // aufgenommen werden, damit sie hier geparst werden können
  for FormsIdx := 0 to Application.ComponentCount - 1 do
  begin
    // prüfen, ob es sich wirklich um ein Formular handelt
    if Application.Components[FormsIdx] is TForm then
    begin
      // für den einfacheren Zugriff ...
      C2 := Application.Components[FormsIdx];
      FormName := C2.Name;
      // der Formularname wird als erster Eintrag eines neuen Abschnitts eingefügt
      // [frmMain]
      // frmMain=CaptionText
      ini.WriteString(FormName, FormName, (C2 as TForm).Caption);
      // jetzt wird über alle Komponenten des Formulars iteriert
      for j := 0 to Application.Components[FormsIdx].ComponentCount - 1 do
      begin
        // für den einfacheren Zugriff ...
        C := Application.Components[FormsIdx].Components[j];
        // Klassennamen sind Case-Sensitive, achten Sie auf die korrekte Schreibweise
        // der folgende Abschnitt muss für jede Komponente einfügt werden
        // ist die Komponente vom Typ TButton, dann ...
        if C.ClassName = 'TButton' then
        begin
          // schreibe Wert der Eigenschaft Caption
          ini.WriteString(FormName, C.Name, (C as TButton).Caption);
          // Um mehrere Eigenschaften einer Komponente zu erfassen, setzt sich der
          // Eintrag in der Sprachdatei aus dem Komponentennamen und dem
          // Eigenschaftsnamen zusammen
          if (c as TButton).Hint <> '' then
            ini.WriteString(FormName, C.Name + 'Hint', (C as TButton).Hint);
         // nächster Durchlauf
         continue;
      end;
      ...
      // Sollen alle Komponentenklassen in die Sprachdatei geschrieben werden, die
      // nicht verarbeitet wurden, setzen Sie die Eigenschaft WriteLog von 
      // DFInitLng auf true
      if WriteLog then
        ini.WriteString(FormName, C.ClassName, 'LOG: Component not parsed yet');
      ...

Das Auswerten der Komponenteneigenschaften geht sicherlich auch einfacher. Der Vorteil dieser Variante ist, dass Sie die Ausgabe der Eigenschaften jeder Komponente individuell anpassen können. Routinen, die einfach auf den Typ einer Eigenschaft prüfen (if Komponente hat Eigenschaft Caption) müssen für jeden Typ aufgerufen werden.

Schritt 5

Fügen Sie im Ereignis OnShow des Hauptformulars z. B. den folgenden Quellcode ein. Im Ereignis OnCreate hat er noch keinen Nutzen, da in diesem Fall nur das Hauptformular, aber noch nicht die anderen Formulare erstellt sind. Können Sie einige Formulare nicht automatisch erstellen, müssen Sie diese Anweisungen auch in diesen Formularen ausführen.

with DFInitLng1 do
begin
  FileName      := ExtractFilePath(ParamStr(0)) + 'Deutsch.lng'; // Dateiname
  ItemSeperator := ';';
  // Separator für Items in Listen
  MessageHeader := 'OtherStrings';  // überschrift des Abschnitts für die Strings
  WriteLog      := True;
  // Log für nicht geparste Komponenten schreiben
  WriteComponentProperties(DFLngCreate); // Komponenteneigenschaften schreiben
  WriteInternalStrings(StrLst, 6000, DFLngAppend); // Strings anhängen
end;

Schritt 6

1. Entfernen Sie die betreffenden Formulare wieder aus der automatischen Erstellung.
2. Entfernen Sie den Code aus der Routine OnShow der Formulare zum Schreiben der Sprach-Datei.
3. Entfernen Sie die Komponente DFInitLng aus den Formularen.

Sie sind jetzt vorbereitet, die Sprachdatei in andere Sprachen zu übersetzen und die Übersetzung in das Programm zu integrieren.

Aufbau der Sprachdatei

• [] - kennzeichnet einen Abschnitt, der alle Komponenten eines Formulars beinhaltet. Er hat den Namen des Formulars.
• btnLanguage - kennzeichnet eine Komponente mit der Standardeigenschaft Caption
• TMainMenu=LOG: Component not parsed yet ==> für diese Komponente wurden keine sprachspezifischen Werte ausgewertet
• miFileDT=- - kennzeichnet eine Komponente, die nicht übersetzt werden soll (DT - Kürzel)
• Einträge einer Listbox hätten den folgenden Aufbau: lbMainItems=Item1;Item2;Item3
• Die Zeichenketten des Arrays werden in einem eigenen Abschnitt [OtherStrings] untergebracht. In diesem Fall wurde mit dem Offset 6000 die Nummerierung begonnen.
  

[frmMain]
frmMain=Standardsprachversion
btnViewListEntry=Zeige Listeneintrag
lbMainItems=
btnLanguage=Sprache einstellen
TMainMenu=LOG: Component not parsed yet
miFile=&Datei
miFileSelectLanguage=Sprache einstellen
miFileDT=-
miFileExit=Beenden
miHelp=&Hilfe
miHelpInfo=Info ...
TDFInitLng=LOG: Component not parsed yet

[frmOptions]
frmOptions=Sprache auswählen
lblSelectLanguage=Wählen Sie eine Sprache aus ...
cbLanguageDTItems=
btnLanguage=Schließen

[OtherStrings]
6000=Sie müssen einen Listeneintrag markieren
6001=Willkommen im Kurs
6002=Information

Einführung |  String-Tabellen |  Schritt 1 - Sprach-Datei erzeugen |  Schritt 2 - Sprachumschaltung |  FAQ - leer

---

Download Beispiel - Example3.zip

Zum Einbinden der Sprach-dateien und Integration der Sprachumschaltung sind folgende Schritte notwendig:

• Dateien übersetzen
  
• Vorbereiten der Sprachumschaltung über ein Menü oder eine List/ComboBox
• Vorbereiten zum Laden/Speichern der aktuellen Sprache (Registry, Ini-Datei)
• Umschaltung der Sprache im Programm zur Laufzeit/beim Programmstart

Dateien übersetzen

Erstellen Sie ein Verzeichnis, in das die Sprachdateien kopiert werden. Sie können z. B. ein Unterverzeichnis ..\Sprache innerhalb Ihres Anwendungsverzeichnisses erstellen. Kopieren Sie die Datei Deutsch.lng in dieses Verzeichnis. Bearbeiten Sie die Sprachdatei gegebenenfalls:

• Entfernen Sie Einträge, die keinen Text enthalten (lbMainItems=).
• Benennen Sie Komponenten anhand der gemachten Konventionen um (Button1).
• Entfernen Sie nicht zu übersetzende Komponenten (Menü-Separator - miFileDT=-).
• Fügen Sie Leerzeilen zur besseren übersicht zwischen die Abschnitte ein.
• Entfernen Sie Komponenten die nicht geparst wurden bzw. überlegen Sie, ob diese sprachabhängige Eigenschaften besitzen (TDFInitLng=LOG: Component not parsed yet).

[frmMain] frmMain=Standardsprachversion btnViewListEntry=Zeige Listeneintrag lbMainItems= btnLanguage=Sprache einstellen Button1=Sprache einstellen TMainMenu=LOG: Component not parsed yet miFile=&Datei miFileSelectLanguage=Sprache einstellen miFileDT=- miFileExit=Beenden miHelp=&Hilfe miHelpInfo=Info ... TDFInitLng=LOG: Component not parsed yet [frmOptions] frmOptions=Sprache auswählen lblSelectLanguage=Wählen Sie eine Sprache aus ... cbLanguageDTItems= btnLanguage=Schließen [OtherStrings] 6000=Sie müssen einen Listeneintrag markieren 6001=Willkommen im Kurs 6002=Information

[frmMain] frmMain=Standardsprachversion btnViewListEntry=Zeige Listeneintrag btnLanguage=Sprache einstellen btnLanguage=Sprache einstellen miFile=&Datei miFileSelectLanguage=Sprache einstellen miFileExit=Beenden miHelp=&Hilfe miHelpInfo=Info ... [frmOptions] frmOptions=Sprache auswählen lblSelectLanguage=Wählen Sie eine Sprache aus ... btnLanguage=Schließen [OtherStrings] 6000=Sie müssen einen Listeneintrag markieren 6001=Willkommen im Kurs 6002=Information

Kopieren Sie die deutsche Ausgangsdatei, z. B. nach English.lng und übersetzen Sie diese. Führen Sie die Übersetzung für alle benötigten Sprachen durch. Der Dateiname sollte dabei den Namen der Sprache in der Landessprache besitzen.

Vorbereiten der Sprachumschaltung über ein Menü oder eine List/ComboBox

Für die Umschaltung der Sprache können Sie verschiedene Komponenten einsetzen. Beim Start des Programms werden alle Dateien des Sprachdateiverzeichnisses z. B. als Untermenüpunkt in einem Menüpunkt eingefügt oder als Einträge in eine List- oder ComboBox. Beim Klicken auf einem Eintrag der Listen oder Auswahl des jeweiligen Menüpunktes wird die Sprachumschaltung durchgeführt.

Fügen Sie die Komponente TDFUseLng in das Formular für die Sprachumschaltung ein (befindet sich in der ZIP-Datei des Beispiels). Beim Start des Programms führen Sie den folgenden Code aus, z. B. im Ereignis OnCreate des Formulars:

Sprachauswahl über ein Menü...

var
  MainPath: string;
  mi: TMenuItem;
  vSL: TStringList;
  Idx: Integer;
begin
  // Anwendungsverzeichnis bestimmen
  MainPath := ExtractFilePath(Application.ExeName);
  if MainPath[Length(MainPath)] = '\' then
    Delete(MainPath, Length(MainPath), 1);

  // Verzeichnis der Sprach-Dateien einstellen
  Lng.LanguageFilesDirectory := MainPath + '\Sprache';

  vSL := TStringList.Create;
  try
    // Spachdateien ermitteln 
    Lng.GetLanguages(vSL);
    vSL.Sort;
    // jeweils einen Menüpunkt pro Sprache erzeugen 
    // der Text entspricht dem Dateinamen ohne Endung 
    for Idx := 0 to vSL.Count - 1 do
    begin
      mi := TMenuItem.Create(self);
      // Der Menüpunkt benötigt einen Namen, damit die Sprachumschaltung funktioniert. 
      // Es wird je über alle Komponenten iteriert und dabei der Name abgefragt. 
      mi.Name    := 'XXXXX' + IntToStr(Idx);
      mi.Caption := vSL[Idx];
      mi.OnClick := OnLangChange;
      miFileSelectLanguage.Add(mi);
    end;

    // mind. 1 Menüpunkt eingefügt, dann Menüpunkt Sprache aktivieren 
    if vSL.Count > 0 then
      miFileSelectLanguage.Enabled := true;
  finally
    vSL.Free;
  end;

In der Formularklasse fügen Sie im private-Bereich die folgende Prozedur ein (betätigen Sie danach Strg+C), um den Prozedurrumpf zu erzeugen.

procedure OnLangChange(Sender: TObject);

Setzen Sie die Eigenschaft Enabled des Menüpunkts, unter dem die Sprachen eingegliedert werden auf false. Es kann ja sein, das keine Sprachdateien vorhanden sind.

Um die Sprachauswahl über eine ComboBox oder Listbox durchzuführen, verwenden Sie den folgenden Code (für eine ComboBox müssen Sie die Eigenschaften Style auf csDropdownList setzen und zur Laufzeit einen Eintrag auswählen - ansonsten ist nichts gewählt):

vSL := TStringList.Create;
try
  Lng.GetLanguages(vSL);
  vSL.Sort;
  lbMain.Items.Assign(vSL);
finally
  vSL.Free;
end;

Im Ereignis OnClick bzw. OnChange können Sie dann die Sprachumschaltung implementieren.

procedure TDFUseLng.GetLanguages(values: TStrings);
var
  SrcRec: TSearchRec;
  found: boolean;
begin
  found := false;
  values.Clear;
  if DirectoryExists(FLanguageFilesDirectory) then
  begin
    if FindFirst(FLanguageFilesDirectory + '\*.lng', faAnyFile, SrcRec) = 0 then
    repeat
      found := true;
      values.Add(Copy(SrcRec.Name, 1, Length(SrcRec.Name) - 4));
    until FindNext(SrcRec) <> 0;

    if found then
      FindClose(SrcRec);
  end;
end;

Vorbereiten Laden/Speichern der aktuellen Sprache (Registry, Ini-Datei)

Im Ereignis OnCreate oder OnShow können Sie die aktuell eingestellte Sprache ermitteln. Ist noch keine Sprache eingetragen, wird die Defaultsprache verwendet. Im allgemeinen kann man natürlich über ein Installationsprogramm schon eine Sprache vorgeben. Es wird wieder die Komponente TDFUseLng verwendet (mit der Objektvariablen Lng).

Lan := Lng.GetActiveLanguage(HKEY_CURRENT_USER, '\Software\FirmenName\Programmname\', 
                             'LanFile');
if Lan <> '' then
begin
//  später zum Initialisieren des Formulars und der Strings der Anwendung
//  lng.InitForm(landir + '\' + lan, self);
//  lng.FillMsgArray(landir + '\' + lan, Msgs, 7000);
end;

function TDFUseLng.GetActiveLanguage(RootKey: dword; Key, value: string): string;
var
  vReg: TRegistry;
begin
  Result := '';
  vReg := TRegistry.Create;
  try
    vReg.RootKey := RootKey;

    if vReg.KeyExists(Key) then
      if vReg.OpenKey(Key, false) then
      begin
        if vReg.ValueExists(value) then
          Result := vReg.ReadString(value);
        vReg.CloseKey();
      end;
  finally
    vReg.Free;
  end;
end;

Umschaltung der Sprache im Programm zur Laufzeit/beim Programmstart

Je nach Einfachheit können Sie die Sprachumschaltung zwar während der Programmausführung erlauben, aber erst bei einem Neustart durchführen. Eventuell müssen auch andere Programmteile "übersetzt" werden, wie z. B. Dll's die Ausgaben durchführen o.a. Wird die Sprache nur beim Programmstart berücksichtigt, reicht es:

• die Sprache beim Programmstart auszulesen
• die Formulare beim Erstellen im Ereignis OnCreate einmalig zu "übersetzen"

Der Unterschied zum Übersetzen zur Laufzeit ist, dass:

• Sie alle während der Sprachauswahl geöffneten Formulare parallel übersetzen und das gesamte Programm mit neuen Strings initialisieren müssen. Dies ist in der Regel kein Problem, wenn die Sprachauswahl über einen Menüpunkt im Hauptprogramm erfolgt bzw. über ein Dialogfenster OPTIONEN (in diesem Fall muss beim Schliessen des Dialogfensters auch das Hauptformular übersetzt werden)

Lan: string; // aktuelle Sprache (Dateiname)
LanDir: string; // Sprache-Dateiverzeichnis 

// Ereignis OnShow
Lan := Lng.GetActiveLanguage(HKEY_CURRENT_USER, '\Software\Frischa\Example3\', 'LanFile');
LanDir := MainPath + '\Sprache';

Um die Sprache bei Auswahl eines Menüpunktes umzuschalten:

• !! Eigenschaften AutoHotKeys und AutoLineReduction der Menükomponente auf false setzen, ansonsten erhalten die Menüpunkt andere Namen, z. B. wird aus (Sender as TMenuItem).Caption := 'English' der Name &English, welcher dann zur Sprachauswahl nicht abgefragt werden kann (ausser man entfernt manuell alle &-Zeichen aus dem Menü-String)

procedure TfrmMain.OnLangChange(Sender: TObject);
begin
  if (Sender as TMenuItem).Caption + '.lng' <> lan then
  begin
    lan := (Sender as TMenuItem).Caption + '.lng';
    lng.InitForm(landir + '\' + lan, self);
    lng.FillMsgArray(landir + '\' + lan, StrLst, 6000);
    lng.SetActiveLanguage(HKEY_CURRENT_USER, '\Software\Frischa\DFCRC\', 
                          'LanFile', lan);
  end;
end;

Ereignis OnClick der ListBox

if lbMain.ItemIndex <> -1 then
  if lbMain.Items[lbMain.ItemIndex] + '.lng' <> lan then
  begin
    Lan := lbMain.Items[lbMain.ItemIndex] + '.lng';
    Lng.InitForm(Landir + '\' + Lan, self);
    Lng.FillMsgArray(landir + '\' + lan, StrLst, 6000);
    Lng.SetActiveLanguage(HKEY_CURRENT_USER, '\Software\Frischa\Example3\', 
                          'LanFile', lan);
  end;

Bei Programmstart wird jetzt die aktuelle Sprache ermmittelt und das Hauptformular initialisiert. Diese Initialisierung müssen Sie bei allen anderen Formularen durchführen (ausser diese werden alle automatisch erzeugt - was aber tunlichst zu vermeiden ist).

LanDir := MainPath + '\Sprache';
Lng.LanguageFilesDirectory := MainPath + '\Sprache';

Lan := Lng.GetActiveLanguage(HKEY_CURRENT_USER, '\Software\Frischa\Example3\', 'LanFile');
if Lan <> '' then
begin
  lng.InitForm(landir + '\' + lan, self);
  lng.FillMsgArray(landir + '\' + lan, StrLst, 6000);
end;

Fertig.

Einführung | String-Tabellen | Schritt 1 - Sprach-Datei erzeugen | Schritt 2 - Sprachumschaltung | FAQ - leer

---

-