LangMan 2.0. Balíček lokalizačních komponent pro Delphi MANUAL. Edice Personal, Professional, Premium a Ultimate. Copyright Ing

LangMan 2.0 Balíček lokalizačních komponent pro Delphi Edice Personal, Professional, Premium a Ultimate

MANUAL

MN-LANGMAN-08

Copyright © 2013 - Ing. Tomáš Halabala

LangMan 2.0

OBSAH 1 Všeobecné informace......................................................................................................7 1.1 Proč používat komponenty LangMan.....................................................................8 1.2 Podporované verze Delphi......................................................................................8 1.3 Instalace komponent LangMan...............................................................................8 1.3.1 Než začnete..................................................................................................................8 1.3.2 Příprava ke kompilaci..................................................................................................9 1.3.3 Kompilace zdrojových souborů...............................................................................11 1.3.4 Instalace..................................................................................................................... 13 1.3.5 Přidání cesty k souborům LangMan........................................................................14

2 Komponenty balíčku LangMan 2.0...............................................................................16 2.1 T(Uni)LangManEngine(X).......................................................................................16 2.2 T(Uni)LangManClient(X).........................................................................................17 2.2.1 Co se bude překládat................................................................................................17

2.3 T(Uni)ResourcesTranslator(X) (pouze v edici Ultimate).....................................18 2.3.1 Jak to funguje............................................................................................................ 19 2.3.2 Výběr překládaných resourcestrings......................................................................19

2.4 Lexikony..................................................................................................................21 2.4.1 T(Uni)DesignedLexicon(X)........................................................................................21 2.4.2 T(Uni)ProgrammableLexicon(X)...............................................................................21 2.4.3 T(Uni)InlineLexicon(X) (pouze v edici Ultimate)......................................................22 2.4.4 Další funkce lexikonů................................................................................................22

2.5 T(Uni)LangCombo(X)..............................................................................................22 2.6 TLangFlagsCombo.................................................................................................22 2.7 T(Uni)LangFlag(X)...................................................................................................22 2.8 T(Uni)ValuedLabel(X)..............................................................................................23 2.9 TLangManRichEdit.................................................................................................23 3 Editor jazyků...................................................................................................................24 3.1 Okno editoru...........................................................................................................24 3.1.1 Import a export.......................................................................................................... 25 3.1.2 Editace / překlad........................................................................................................26 3.1.3 Vyhledávání............................................................................................................... 28 3.1.4 Copyright panel......................................................................................................... 28

4 Třídy balíčku komponent LangMan.............................................................................29 4.1 TLangManEngine(X) = class ( TLangManCore )..................................................29 TUniLangManEngine = class ( TLangManEngine )....................................................29 4.1.1 Metody tříd T(Uni)LangManEngine(X)......................................................................29 4.1.1.1 Function Translate ( ISOorLangName: String ): TLanguage;...............................29 4.1.1.2 Procedure AssignLanguagesList( TargetList: TStrings );......................................29 4.1.1.3 Function GetLanguageFile( ISOorLangName: String ): TFileName;....................29 4.1.1.4 Function GetLanguageFile( LanguageIndex: Integer ): TFileName;.....................29 4.1.1.5 Function GetISOCode( LanguageName: String ): String;.....................................29 4.1.1.6 Function GetISOCode(LanguageIndex: Integer): String;.....................................29 4.1.1.7 Function LangExists(ISOorLangName: String): Boolean;....................................30 4.1.1.8 Function FlagImage(ISOorLangName: String):TMemoryStream;.........................30 4.1.1.9 Function FlagImage(LanguageIndex: Integer):TMemoryStream;.........................30 4.1.1.10 Function EditorCanBeShown: Boolean;.............................................................30 4.1.1.11 Procedure ShowLangEditor;..............................................................................30 4.1.1.12 Procedure ShowLangCreator;............................................................................30 HW & SW Development

www.regulace.org

2/67

LangMan 2.0 4.1.1.13 Procedure RefreshLangControl( LangManGUIControl: TComponent );.............30 4.1.1.14 Function ImportFromFile( FileName: String; ToCurrentLanguage: Boolean ): Integer; (pouze edice Premium a Ultimate).......................................................................31 4.1.1.15 Procedure ExportToFile( FileName: String ); (pouze edice Ultimate).................31 4.1.2 Vlastnosti tříd T(Uni)LangManEngine(X).................................................................32 4.1.2.1 Property CurrentLanguage: String.......................................................................32 4.1.2.2 Property CurrentLanguageISO: String.................................................................32 4.1.2.3 Property DesignLangISOCode: String.................................................................32 4.1.2.4 Property DesignLanguageName: TLanguage......................................................32 4.1.2.5 Property DefaultLanguage: String........................................................................32 4.1.2.6 Property LangSubdirectory: String.......................................................................32 4.1.2.7 Property LangFileExtension: String......................................................................33 4.1.2.8 Property LangFileSignature: String......................................................................33 4.1.2.9 Property LangCreatorVisible: boolean.................................................................33 4.1.2.10 Property LangEditorVisible: boolean..................................................................33 4.1.2.11 Property TranslateLangMan: boolean................................................................33 4.1.2.12 Property LanguageMenu: TMenuItem................................................................34 4.1.2.13 Property LangMenuFlags: boolean....................................................................34 4.1.2.14 Property DesignLangFlag: TPicture (TBitmap ve FMX verzi).............................34 4.1.2.15 Property LangResources: TStringList................................................................34 4.1.2.16 Property LangFileEncoding: TLFEncoding.........................................................34 4.1.2.17 Property LangResourcesAllowEdit: boolean......................................................34 4.1.2.18 Property HideCopyright: boolean (pouze placené edice Professional, Premium a Ultimate)........................................................................................................................... 34 4.1.3 Vlastnosti třídy TUniLangManEngine (pouze v edicích Premium a Ultimate)......35 4.1.3.1 Property CookieEnable: Boolean.........................................................................35 4.1.3.2 Property CookieLifeDays: Double........................................................................35 4.1.3.3 Property CookieName: String..............................................................................35 4.1.4 Vlastnosti třídy TLangManEngineX.........................................................................35 4.1.4.1 Property StyleBook: TStyleBook..........................................................................35 4.1.5 Události tříd T(Uni)LangManEngine(X)....................................................................36 4.1.5.1 OnChangeLangQuery: TContinueQuery..............................................................36 4.1.5.2 OnChangeLanguage: TNotifyEvent.....................................................................36 4.1.5.3 OnBeforeEdit: TNotifyEvent.................................................................................36 4.1.5.4 OnAfterEdit: TNotifyEvent....................................................................................36

4.2 TLangManComponent = class ( TComponent )...................................................37 4.2.1 Vlastnosti třídy TLangManComponent....................................................................37 4.2.1.1 Property LangManEngine: TLangManCore..........................................................37 4.2.1.2 Property GlobalLexicon: Boolean (pouze v edici Ultimate)...................................37 4.2.2 Události třídy TLangManComponent.......................................................................37 4.2.2.1 OnChangeLanguage: TNotifyEvent.....................................................................37

4.3 TLangManClient(X) = class ( TLangManCPC )....................................................38 TUniLangManClient = class ( TLangManClient )........................................................38 4.3.1 Metody tříd T(Uni)LangManClient(X).......................................................................38 4.3.1.1 Function AddComponent (Component: TComponent; Name: string; Translate: boolean): Boolean;............................................................................................................ 38 4.3.1.2 Procedure RecreateTransStruct;..........................................................................38 4.3.1.3 Procedure TranslateComponent(Component: TComponent; Name: string = '');...39 4.3.1.4 Procedure Translate;............................................................................................39 4.3.1.5 Procedure TranslateAs(FormName: String);........................................................39 4.3.2 Vlastnosti tříd T(Uni)LangManClient(X)...................................................................40 4.3.2.1 Property InitAfterCreateForm: boolean................................................................40 4.3.2.2 Property TransAdditions: TAdditionSet.................................................................40 4.3.2.3 Property TransStringProp....................................................................................40 HW & SW Development

www.regulace.org

3/67

LangMan 2.0 4.3.2.4 Property TransTStringsProp.................................................................................40 4.3.2.5 Property TransStructuredProp.............................................................................40 4.3.2.6 Property TransOtherProp.....................................................................................40 4.3.3 Vlastnosti třídy TLangManClientX...........................................................................40 4.3.3.1 Property TransXtraOptions: TFMXClientOptionsSet............................................40

4.4 TLMList = class ( TLangManComponent )...........................................................41 4.4.1 Metody třídy TLMList................................................................................................41 4.4.1.1 Function IsDefined(Index: Integer): boolean;.......................................................41 4.4.1.2 Function IsDefined(LocStr: String): boolean;.......................................................41 4.4.1.3 Function GetLocStr(Index: Integer): String;..........................................................41

4.5 TResourcesTranslator(X) = class ( TCustomResourcesTranslator ) TUniResourcesTranslator = class ( TResourcesTranslator )....................................41 4.5.1 Metody tříd T(Uni)ResourcesTranslator(X)..............................................................41 4.5.1.1 Procedure RegisterResourceString(const Resource: String; InDesignLanguage: String = ' ');....................................................................................................................... 41 4.5.2 Vlastnosti tříd T(Uni)ResourcesTranslator(X).........................................................42 4.5.2.1 Property OriginalLanguage: String.......................................................................42 4.5.2.2 Property RegisteredStrings: Integer; (read-only)..................................................42

4.6 TLexicon = class ( TLMList )..................................................................................43 4.6.1 Metody třídy TLexicon..............................................................................................43 4.6.1.1 Function CompleteString(const Str: string): string;...............................................43 4.6.2 Vlastnosti třídy TLexicon..........................................................................................43 4.6.2.1 Property Link [Index: Integer]: string; (read-only).................................................43

4.7 TDesignedLexicon(X) = class ( TCustomDesignedLexicon ) TUniDesignedLexicon = class ( TDesignedLexicon )................................................44 4.7.1 Metody tříd T(Uni)DesignedLexicon(X)....................................................................44 4.7.1.1 Function CreateItem( Text: string ): Integer;.........................................................44 4.7.2 Vlastnosti tříd T(Uni)DesignedLexicon(X)...............................................................44 4.7.2.1 Property Item [Index: Integer]: string; (read-only).................................................44 4.7.2.2 Property Items : TStringList..................................................................................44

4.8 TProgrammableLexicon(X) = class ( TCustomProgrammableLexicon ) TUniProgrammableLexicon = class( TProgrammableLexicon )...............................45 4.8.1 Metody tříd T(Uni)ProgrammableLexicon(X)...........................................................45 4.8.1.1 Procedure DefineItem(ItemNr: Word; Text: string);...............................................45 4.8.2 Vlastnosti tříd T(Uni)ProgrammableLexicon(X)......................................................45 4.8.2.1 Property Item [Index: Integer]: string; (read-only).................................................45 4.8.3 Události tříd T(Uni)ProgrammableLexicon(X).........................................................45 4.8.3.1 OnInitialization: TNotifyEvent...............................................................................45

4.9 TInlineLexicon(X) = class ( TCustomInlineLexicon )..........................................46 TUniInlineLexicon = class ( TInlineLexicon )..............................................................46 4.9.1 Vlastnosti tříd T(Uni)InlineLexicon(X)......................................................................46 4.9.1.1 Property Item [Index: Integer]: string; (read-only).................................................46 4.9.1.2 Property Loc [LocalizableString: String]: string; (read-only).................................46 4.9.1.3 Property SLink [LocalizableString: String]: string; (read-only)..............................46

4.10 TLangCombo(X) = class ( TCustomComboBox )..............................................47 TUniLangCombo = class ( TUniCustomComboBox )................................................47 4.10.1 Vlastnosti tříd T(Uni)LangCombo(X)......................................................................47 4.10.1.1 Property LangManEngine: T(Uni)LangManEngine(X)........................................47 4.10.2 Vlastnosti třídy T(Uni)LangCombo........................................................................47 4.10.2.1 Property StyleCombo: TLangComboStyle.........................................................47 4.10.3 Události tříd T(Uni)LangCombo(X).........................................................................47 4.10.3.1 OnChangeLanguage: TNotifyEvent...................................................................47

4.11 TLangFlagsCombo = class ( TCustomComboBoxEx ).....................................48 HW & SW Development

www.regulace.org

4/67

LangMan 2.0 4.11.1 Vlastnosti třídy TLangFlagsCombo.......................................................................48 4.11.1.1 property LangManEngine: TLangManEngine.....................................................48 4.11.2 Události třídy TLangFlagsCombo..........................................................................48 4.11.2.1 OnChangeLanguage: TNotifyEvent....................................................................48

4.12 TLangFlag(X) = class ( TImage ).........................................................................49 TUniLangFlag = class ( TUniImage )............................................................................49 4.12.1 Vlastnosti tříd T(Uni)LangFlag(X)...........................................................................49 4.12.1.1 Property LangManEngine: T(Uni)LangManEngine(X)........................................49

4.13 TValuedLabel = class ( TCustomLabel ).............................................................50 TUniValuedLabel = class ( TUniLabel )........................................................................50 TValuedLabelX = class ( TLabel ).................................................................................50 4.13.1 Vlastnosti tříd T(Uni)ValuedLabel(X)......................................................................50 4.13.1.1 Property Value: TCaption...................................................................................50 4.13.1.2 Property ValueName: TCaption..........................................................................50 4.13.1.3 Property ValueSeparator : string........................................................................50 4.13.1.4 Property ValueSpaces : byte..............................................................................50

4.14 TLangManStrings = class ( TStringList )...........................................................51 4.14.1 Konstruktor třídy TLangManStrings......................................................................51 4.14.1.1 Constructor Create(ControlledStrings: TStrings; Lexicon: TLexicon);................51 4.14.2 Metody třídy TLangManStrings..............................................................................51 4.14.2.1 Procedure Translate;..........................................................................................51

4.15 TLangManRichEdit = class ( TCustomRichEdit )..............................................52 4.15.1 Metody třídy TLangManRichEdit............................................................................52 4.15.1.1 Procedure AssignStyles(LMStringStyles: TLMStringStyles);..............................52 4.15.1.2 Procedure ClearStyles;......................................................................................52 4.15.1.3 Function GetStyles: TLMStringStyles;................................................................52 4.15.1.4 Function StylesCount: Integer;...........................................................................52 4.15.1.5 Function SetStyle(Style: TFontStyles; Size: Integer = 0; Color: TColor = clDefault; FontName: TFontName = ''; Charset: TFontCharset = DEFAULT_CHARSET; Pitch: TFontPitch = fpDefault; StyleIndex: ShortInt = -1): Integer;.....................................53 4.15.1.6 Function Format(const Text: String; StyleIndex: ShortInt): String;......................53 4.15.1.7 Procedure Write(const Text: String; StyleIndex: ShortInt = -1);..........................53 4.15.1.8 Procedure WriteLn(const Text: String; StyleIndex: ShortInt = -1);......................53 4.15.1.9 Procedure NextLine;..........................................................................................53 4.15.1.10 Procedure Clear;..............................................................................................53 4.15.1.11 Function LinesCount: Integer;..........................................................................54 4.15.1.12 Function ReadLineText(LineIndex: Integer): String;.........................................54 4.15.1.13 Function ReadLineFText(LineIndex: Integer): String;.......................................54 4.15.1.14 Procedure DeleteLine(LineIndex: Integer);......................................................54 4.15.1.15 Procedure RewriteLine(LineIndex: Integer; const Text: String; StyleIndex: ShortInt = -1);.................................................................................................................... 54 4.15.1.16 Procedure InsertLine(LineIndex: Integer; const Text: String; StyleIndex: ShortInt = -1);................................................................................................................................. 54 4.15.1.17 Procedure Translate;........................................................................................54 4.15.1.18 Procedure LoadFromFile(const SourceFile: TFileName; Encoding: TEncoding); ......................................................................................................................................... 54 4.15.1.19 Procedure LoadFromStream(SourceStream: TStream; Encoding: TEncoding); ......................................................................................................................................... 55 4.15.1.20 Procedure SaveRichTextToFile(const DestinationFile: TFileName; Encoding: TEncoding);...................................................................................................................... 55 4.15.1.21 Procedure SaveRichTextToStream(DestinationStream: TStream; Encoding: TEncoding);...................................................................................................................... 55 4.15.1.22 Procedure SaveEncodedFormToFile(const DestinationFile: TFileName; Encoding: TEncoding);.....................................................................................................55 HW & SW Development

www.regulace.org

5/67

LangMan 2.0 4.15.1.23 Procedure SaveEncodedFormToStream(DestinationStream: TStream; Encoding: TEncoding);.....................................................................................................55 4.15.2 Vlastnosti třídy TLangManRichEdit.......................................................................55 4.15.2.1 Property AssignedLexicon: TLexicon.................................................................55 4.15.2.2 Property AutoFont: Boolean...............................................................................56 4.15.2.3 Property Link [Index: Integer]: string; (read-only)...............................................56 4.15.2.4 Property SLink [LocalizableString: String]: string; (read-only) (podporováno pouze v edici Ultimate).....................................................................................................56

5 Jazykové soubory v resources....................................................................................57 6 Dynamické generování textů........................................................................................58 7 Tipy a triky......................................................................................................................60 7.1 Rychlá editace položek DesignedLexiconu.........................................................60 7.2 Vkládání zvláštních znaků.....................................................................................60 7.3 Integrace LangMana na formulář za běhu programu.........................................60 7.4 Nevhodná výchozí konfigurace projektů.............................................................61 7.5 Component Name Editor.......................................................................................61 7.6 Po upgradu vždy znovu zkompilovat...................................................................62 8 Porovnání možností všech edic LangMan..................................................................63 9 Omezení dle platforem..................................................................................................65

HW & SW Development

www.regulace.org

6/67

LangMan 2.0

1

Všeobecné informace Komponenty LangMan slouží pro velice jednoduchou tvorbu multijazyčných aplikací v Delphi. Tyto komponenty vás doslova zprostí od všech starostí s programováním překladů, přepínání jazyků a zachovává plnou přehlednost ve zdrojovém kódu. Na rozdíl od jiných konkurenčních řešení je LangMan naprosto unikátním a neocenitelným pomocníkem. Podporovány jsou všechny dostupné platformy a kompilátory od Delphi 2007 až po dnešní Delphi XE5. S LangManem lze vytvářet mobilní, desktopové i webové aplikace postavené na frameworku FireMonkey, VCL nebo uniGUI. Svou aplikaci tvoříte v libovolném základním jazyce bez ohledu na nutnost budoucího překladu do dalších jazyků. Pouze u řetězců používaných za běhu programu je nutné se odvolávat na lexikony, jež jsou součástí této sady komponent. U aplikací čistě pro Windows dokáže LangMan v edici Ultimate lokalizovat za běhu aplikace také řetězce resourcestrings. Při návrhu formulářů je také dobré dbát na proměnnou délku řetězců. Všechno ostatní je plně automatické, proto také LangMan při tvorbě multijazyčných aplikací ušetří obrovskou spoustu času. Komponenty LangMan velmi snadno začleníte i do hotového nebo rozpracovaného projektu. Pomocí komponenty T(Uni)ResourcesTranslator(X)1 lze velmi jednoduše lokalizovat libovolné řetězcové zdroje (resourcestrings) a díky funkci importu2 jazykových dat lze rovněž ve velmi krátkém čase převést projekt lokalizovaný pomocí jiných nástrojů na projekt lokalizovaný pomocí komponent LangMan. Například lze bez jakýchkoli úprav přímo načíst data uložená komponentou TLang z knihovny FireMonkey. Klíčová komponenta T(Uni)LangManEngine(X) je vybavena vlastním editorem jazyků, který lze spustit jak v cílové aplikaci, tak při návrhu v Delphi3. Jazykové soubory lze distribuovat jednak současně s aplikací, ale hlavně i samostatně, tak lze jednoduše upravit nebo přidat nový jazyk v cílové aplikaci u uživatele. Další výhodou LangManu je schopnost jazyky dědit a to bez omezení hloubky. Lze dědit jazyk z jazyka a ten z jiného jazyka a tak dále. Má to tu výhodu, že při opomenutí přeložení nějaké komponenty může například slovenská verze vycházet z české či naopak, nebo americká z britské, rakouská z německé apod. Zároveň to dovoluje překládat některé jazyky pouze částečně, čímž lze zase ušetřit spoustu času. LangMan sám automaticky vytvoří funkční odkazy ve zvoleném menu pro výběr jazyka. Nebo lze pro uživatelskou volbu jazyka do aplikace vložit vizuální komponentu TLangCombo(X) případně TLangFlagsCombo nebo u webových aplikací TUniLangCombo4. To vše je absolutně bez práce a bez složitého nastavování. Jednotlivým jazykům lze přiřadit i grafický symbol či vlajku, která se automaticky zobrazí v menu s výběrem jazyka nebo v

1 2 3 4

Pouze v edici LangMan Ultimate Funkce pro import jazykových dat jsou dostupné pouze v edicích Premium a Ultimate Design-time editor jazyků je k dispozici pouze v edicích Premium a Ultimate TUniLangCombo obsahují pouze edice Premium a Ultimate

HW & SW Development

www.regulace.org

7/67

LangMan 2.0 komponentě T(Uni)LangFlag(X).

1.1

1.2

Proč používat komponenty LangMan •

Naprosto jednoduché používání

•

Minimální časové nároky při implementaci ve vlastní aplikaci

•

Nízké pořizovací i udržovací náklady

•

Výborná technická podpora a rychlé řešení případných potíží

•

Součástí všech edic jsou všechny zdrojové kódy dané edice

•

Podpora platforem Windows 32-bit, 64-bit, OSX, iOS, Android

•

Po zakoupení nové licence nebo upgradu máte všechny budoucí verze příslušné edice automaticky zdarma nejméně po dobu tří let.

•

Díky run-time editoru jazyků se mohou i uživatelé vaší aplikace podílet na tvorbě lokalizací.

Podporované verze Delphi Komponenty LangMan mohou být instalovány a používány v následujících verzích Delphi (RAD Studia): •

2007 (pouze ANSI kódování řetězců a bez FMX komponent)

•

2009, 2010, XE (bez FMX komponent)

•

XE2, XE3 (bez automatického LanguageMenu u FMX enginu)

•

XE4, XE5

Před zakoupením licence doporučujeme stáhnout si nejprve bezplatný LangMan Personal, nainstalovat ho a vyzkoušet.

1.3

Instalace komponent LangMan

1.3.1

Než začnete 1) Pokud instalujete komponenty LangMan na současném počítači poprvé, musíte si nejdříve vytvořit/určit někde na disku složku, kam rozbalíte obsah dodaného ZIP archivu. Tuto složku vytvořte nejlépe vedle složek ostatních komponent, které jste už dříve instalovali nebo jednoduše na místo, které si snadno zapamatujete a kde soubory nebudou překážet, protože je tam budete muset od okamžiku nainstalování nechat po celou dobu jejich používání. 2) Pokud již máte v Delphi nějakou z předchozích verzí komponent LangMan nainstalovanou, doporučuji nejdříve všechny balíčky z nabídky Install Packages odebrat.

HW & SW Development

www.regulace.org

8/67

LangMan 2.0

Obzvláště to platí při upgradu na vyšší edici a při změně hlavního čísla verze, například při skoku z verze 1.x na 2.x apod.

ZIP archiv s novou verzí komponent můžete rozbalit do stejné složky, kde byla předchozí verze. Jednoduše přepíšete původní soubory.

1.3.2

Příprava ke kompilaci Po tom, co jste si přečetli licenční ujednání a stáhli si ZIP archiv komponent LangMan, jej rozbalte do předem určené složky. Pro tuto ukázkovou instalaci bylo vybráno následující umístění: D:\Delphi\Components\LangMan

Nyní musíte upravit soubor LM_Config.inc, který najdete mezi ostatními rozbalenými soubory. V uvedeném souboru najdete několik definic, které aktivují různé funkce/komponenty LangManu. Zapoznámkováním určitého řádku s definicí příslušnou funkci deaktivujete a naopak. HW & SW Development

www.regulace.org

9/67

LangMan 2.0 Zvláště důležité je zapoznámkovat definice povolující překlad těch sad komponent, které v Delphi nemáte nainstalovány, protože pak by nebylo možné komponenty LangMan vůbec přeložit.

Například když víte, že nemáte instalovány komponenty TeeChart, vložte před příslušnou definici „TEECHART“ dvojité lomítko „// “, nebo naopak, pokud máte nainstalovány a chcete mít možnost lokalizovat například komponenty uniGUI, odpoznámkujte definici „LM_UNIGUI“. Provedené úpravy v souboru LM_Config.inc nezapomeňte uložit. Nyní spusťte Delphi (RAD Studio), případně zavřete aktuálně otevřený projekt a v menu File klikněte na Open Project. Otevřte soubor dle následujících kritérií: •

Delphi_XE2345_LangMan.groupproj

HW & SW Development

www.regulace.org

(v Delphi XE2 – XE5) 10/67

LangMan 2.0 •

Delphi_2009~XE2_LangMan.groupproj (v Delphi 2009 – XE2)

•

Delphi_2007up_LangMan_VCLonly.dpk (v Delphi 2007 – XE5) - pro instalaci pouze VCL kompatibilních komponent

•

Delphi_2007up_LangMan_VCLuni.dpk (v Delphi 2007 – XE5) - pro instalaci LangMan komponent pro VCL a uniGUI (pouze v edicích Premuim a Ultimate)

•

Delphi_2007_LangMan_Ultimate.dpk (v Delphi 2007) (LangMan Ultimate pro Delphi 2007)

Případná hlášení o konverzi balíčku nebo odebrání referencí na chybějící soubory odsouhlaste.

1.3.3

Kompilace zdrojových souborů Následující postup se mírně liší podle verze Delphi a edice komponent LangMan. V Delphi XE2 a novějších vybíráte ještě před kompilací cílovou platformu (majitelé starších verzí tuto možnost nemají):

Začněte výběrem platformy 32-bit Windows (Win32). Po instalaci můžete zvolit libovolnou další platformu a přeložit pro ni komponenty LangMan. Poznámka: Aby byly komponenty dostupné pro požadovanou platformu, musí být přeloženy a nainstalovány i pro platformu Win32. Nyní zkompilujte celou projektovou skupinu. 1) Pokud jste v předchozím kroku otevírali soubor s koncovkou .groupproj klikněte pravým tlačítkem myši na název projektové skupiny v Project Manageru a zvolte Build All.

HW & SW Development

www.regulace.org

11/67

LangMan 2.0

2) Pokud jste v předchozím kroku otevírali soubor s koncovkou .dpk nebo .dproj klikněte pravým tlačítkem myši na název otevřeného balíčku v Project Manageru a zvolte Build.

Proběhne kompilace a sestavení knihoven. V průběhu překladu by nemělo dojít k žádným závažným chybám. Pokud bude hlášena nějaká chybějící jednotka nebo knihovna, možná jste v souboru LM_Config.inc zapomněli nějakou funkci zakázat, proto se zkuste k tomuto kroku vrátit. Pokud se vám jeví hlášení jako neoprávněné, ověřte si, zda je příslušná jednotka nebo knihovna zkompilována i pro zvolenou platformu. Pokud se ale zobrazí hlášení o potřebném importu chybějících knihoven podobné jako na obrázku níže, pravděpodobně nepostupujete úplně přesně podle tohoto návodu. Nevadí, buďto navrhované změny odsouhlaste a zkuste balík přeložit znovu a když to nepůjde, ukončete Delphi, rozbalte znovu stažený ZIP archiv do stejné složky a opakujte postup od začátku.

HW & SW Development

www.regulace.org

12/67

LangMan 2.0

Stejně tak pokud ve výpisu chybových hlášení najdete varování typu: W1033 Unit 'xxx' implicitly imported into package 'yyy'

odinstalujte všechny balíčky LangMan dle popisu v kapitole 1.3.1, pokud jsou nainstalovány, rozbalte znovu ZIP archiv a postup opakujte. K uvedeným chybám může dojít například pokud byl soubor balíčku nebo projektu změněn. Neotevírejte proto nastavení z nabídky Project / Options... ani nepřidávejte či neodebírejte soubory projektu a podobně. Jestliže vám ani po opakovaném pokusu nejde LangMan přeložit, neváhejte kontaktovat autora komponent.

1.3.4

Instalace Po úspěšném přeložení zdrojových kódů pro platformu 32-bit Windows (Win32) vzniknou knihovny s koncovkou .bpl. Jejich umístění pro vás není až tak důležité. Nyní je musíte ještě nainstalovat pro použití v Delphi. V Project Manageru klikněte pravým tlačítkem myši na první balíček a zvolte Install. Pokud se ve skupině nachází více balíčků (máte otevřený soubor .groupproj), nainstalujte stejným způsobem postupně všechny balíčky. Pro ostatní platformy už tento krok instalace neprovádíte. Jestliže jsou komponenty nainstalovány pro platformu Win32, pro další platformy už stačí zdrojové kódy jen přeložit. Mějte ale na paměti, že aby bylo možné komponenty LangMan přeložit pro požadovanou platformu, musí být pro tuto platformu přeloženy i knihovny, na kterých jsou komponenty LangMan závislé.

HW & SW Development

www.regulace.org

13/67

LangMan 2.0

1.3.5

Přidání cesty k souborům LangMan Pro úspěšné dokončení prvotní instalace ještě musíte přidat cestu k souborům komponent v nastavení Library path. V hlavním menu klikněte na Tools / Options... V okně Options najděte položku Library, která se skrývá pod Delphi Options a klikněte na tlačítko označené třemi tečkami za políčkem Library path:

Do editačního pole vložte nebo vepište cestu ke zdrojovým souborům komponent LangMan a klikněte na tlačítko Add.

HW & SW Development

www.regulace.org

14/67

LangMan 2.0

Potvrďte a uložte nastavení tlačítkem OK. Nyní je instalace dokončena.

HW & SW Development

www.regulace.org

15/67

LangMan 2.0

2

Komponenty balíčku LangMan 2.0 Celou sadu komponent LangMan lze rozdělit na: 1) Nevizuální komponenty sloužící přímo pro lokalizace programovaných v Delphi do různých světových jazyků. Patří sem:

aplikací

T(Uni)LangManEngine(X), T(Uni)LangManClient(X), T(Uni)ResourcesTranslator(X)*, T(Uni)DesignedLexicon(X), T(Uni)ProgrammableLexicon(X) a T(Uni)InlineLexicon(X)* 2) Vizuální komponenty pro signalizaci zvoleného jazyka, výběr jazyka a případně i spouštění editoru jazyků: T(Uni)LangCombo(X), TLangFlagsCombo a T(Uni)LangFlag(X) 3) Bonusové vizuální komponenty užitečné pro tvorbu multijazyčných aplikací: T(Uni)ValuedLabel(X) a TLangManRichEdit 4) Do poslední skupiny patří ještě třída TLangManStrings, která není komponentou a může být použita pro generování lokalizovatelného textu v TMemo apod. nebo v jakémkoli objektu, který je potomkem třídy TStrings. Písmenem „X“ jsou označeny komponenty kompatibilní s FireMonkey. Komponenty, které jsou určené pro webové aplikace uniGUI nesou označení „Uni“. Komponenty s „X“ a „Uni“ najdete pouze v edicích Premium a Ultimate. Funkce a význam komponent s a bez „X“ případně „Uni“ je stejný. Liší se pouze v podporovaném frameworku a v drobnostech souvisejících s příslušným frameworkem. V tomto dokumentu je tedy text popisující jednotlivé komponenty a jejich funkce často společný pro všechny tři komponenty, lišící se pouze cílovým frameworkem.

2.1

T(Uni)LangManEngine(X) T(Uni)LangManEngine(X) (dále jen engine) je klíčovou komponentou celé sady. Zprostředkovává překlad, přepínání jazyků, spravuje jazykové soubory a obsahuje potřebný editor jazyků. Tuto komponentu potřebují ke své funkci všechny ostatní jazykové komponenty kromě komponent T(Uni)ValuedLabel(X) a TLangManRichEdit. Ve většině případů je jeden jazyk společný pro všechny části programu, takže je zapotřebí umístit jeden engine na některý formulář nebo lépe do datového modulu TDataModule, který bude přístupný (viditelný) pro všechny ostatní formuláře. Potřebujete-li ve svém programu jazykově oddělit dvě a více částí, například chcete-li mít možnost odděleně volit jazyk programu a odděleně jazyk tiskového výstupu, můžete použít tolik enginů kolik je zapotřebí. Jednotlivé enginy se jen musí lišit rozdílným nastavením alespoň jedné z následujících vlastností: LangFileSignature, LangFileExtension, LangSubdirectory. Tyto vlastnosti určují základní parametry jazykových souborů, které budou náležet danému jazykovému enginu.

*

Komponenty T(Uni)InlineLexicon(X) a T(Uni)ResourcesTranslator(X) jsou obsaženy pouze v edici Ultimate

HW & SW Development

www.regulace.org

16/67

LangMan 2.0 Vestavěný editor může být spuštěn za běhu programu, takže i koncový uživatel, pokud je mu to dovoleno, může přidávat, případně upravovat jazyky. U edic Premium a Ultimate lze editor používat i při návrhu aplikace v IDE. Zpřístupněn je prostřednictvím místních nabídek komponent T(Uni)LangManEngine(X), T(Uni)LangManClient(X), T(Uni)ResourcesTranslator(X) a všech lexikonů.

Samotná komponenta T(Uni)LangManEngine(X) nedokáže z projektu vyčíst řetězce, které mají být lokalizovány. K tomu slouží následující komponenty.

2.2

T(Uni)LangManClient(X) Tato komponenta, dále jen klient, slouží pro zavedení formuláře, na který je umístěna, do překladu vybraným enginem. Kromě toho umožňuje zvolit, které vlastnosti mají být na formuláři a jeho komponentách překládány. Pokud je žádoucí překládat některé vlastnosti jedním enginem a ostatní jiným enginem, lze k tomuto účelu umístit na jeden formulář více klientů a každému přiřadit jiný engine.

2.2.1

Co se bude překládat Úkolem komponenty T(Uni)LangManClient(X) je vytvořit jakýsi seznam komponent a jejich textových vlastností a předat jej enginu. Tento seznam je vytvořen automaticky v okamžiku sestavení formuláře nebo zavoláním metody RecreateTransStruct. Dále v textu se dočtete i o možnosti přidávat jednotlivé položky dodatečně pomocí metody AddComponent. Položky zmíněného seznamu se budou vyskytovat v editoru jazyků a bude možné je lokalizovat. Programátor má několik možností jak ovlivnit, které komponenty a vlastnosti budou do tohoto seznamu přidány: 1) Nastavením vlastností: TransStringProp, TransTStringsProp, TransStructuredProp, TransOtherProp, TransAdditions a TransXtraOptions (FMX), pomocí nichž určujete, které vlastnosti mohou být v rozsahu celého formuláře překládány. Přičemž hodnota false zcela zamezuje překlad příslušné

HW & SW Development

www.regulace.org

17/67

LangMan 2.0 vlastnosti a hodnota true znamená, že příslušná vlastnost (např. Text „(f)pnText“), případně celá komponenta (např. TChart „(f)cnTChart“), může být přeložena, pokud splňuje předpoklady uvedené v následujících bodech. 2) Vlastnost musí obsahovat znaky s číselnou hodnotou větší nebo rovno znaku „A“. Jinak řečeno, ignorovány jsou číslice a některé speciální znaky. 3) Vlastnost musí obsahovat řetězec odlišný od vlastnosti Name. Tato podmínka není kontrolována v některých výjimečných případech zejména u složitějších datových typů. 4) U komponent s nastavenou Action má přednost vlastnost načtená z příslušné akce, takže například Caption (Text) z TMenuItem nebude vložen do seznamu, pokud jej překrývá Caption (Text) z přiřazené akce. 5) Komponenta musí být podporována. Pokud není standardně podporována, lze jednoduše přidat funkcionalitu pro překlad vlastních a nestandardních komponent třetích stran pomocí jednotky LMVCLAdditions a LMFMXAdditions. Postup je popsán přímo v hlavičce těchto jednotek. Většinou ale stačí, že je neznámá komponenta vytvořena z nějaké standardní komponenty, v tom případě bude fungovat překlad všech zděděných vlastností od podporované komponenty. 6) U komponent vycházejících z třídy TStyledControl, což platí pro většinu vizuálních komponent knihovny FireMonkey, musí být vlastnost AutoTranslate nastavena na hodnotu true. V opačném případě se příslušná komponenta překládat nebude. 7) VCL komponenty i spousta komponent FireMonkey žádnou vlastnost podobnou výše zmíněné AutoTranslate nemají, proto je zde ještě možnost omezit překládání libovolných komponent pomocí vlastnosti Tag. Když rozvinete nabídku vlastnosti Tag, nabídne se vám jedna nebo více možností pro individuální blokování překladu dané komponenty. „Do not translate“ (-799) – komponenta se nebude překládat „Do not translate Text“ (-797) – nebude se překládat vlastnost Text „Translate Text only“ (-790) – povoleno pouze přeložení vlastnosti Text „Translate Hint only“ (-789) – povoleno pouze přeložení vlastnosti Hint „Do not translate Hint“ (-798) – zákaz překládání vlastnosti Hint „> Reset <“ – Tag se vynuluje a je možno jej použít pro libovolné účely.

2.3

T(Uni)ResourcesTranslator(X) (pouze v edici Ultimate) Komponenta T(Uni)ResourcesTranslator(X) slouží pro lokalizace řetězcových zdrojů „resourcestrings“, které byly k aplikaci přilinkovány. Tyto konstantní řetězce lze v Delphi definovat několika způsoby. Nejčastěji pomocí klíčového slova resourcestring přímo ve zdrojovém kódu jednotky .pas, nebo pomocí bloku STRINGTABLE BEGIN index, "řetězec" END

HW & SW Development

www.regulace.org

18/67

LangMan 2.0

v souboru .rc, který pak přidáte do svého projektu. Pro „konstantní“ řetězce, používané v kódu a které je potřeba lokalizovat je optimálnější použít některý z lexikonů dodávaných společně s LangManem. Avšak celá řada resourcestrings, například pro výjimky, různá chybová hlášení nebo i pro tlačítka dialogových oken (MessageDlg, ShowMessage), je definována přímo ve standardních jednotkách Delphi. Dokonce i pár standardních vizuálních komponent, například TRibbon pro prvky v Menu nebo TGesturePreview pro zobrazení legendy „StartPoint(s)“, používá resourcestrings. Takže chcete-li mít ve své aplikaci lokalizováno opravdu všechno nebo z jakéhokoli důvodu používáte resourcestrings, budete k lokalizaci těchto řetězců potřebovat tuto komponentu.

2.3.1

Jak to funguje Zkušenější programátor ví, že data uložená v resources (u Windows aplikací přímo v exe souboru) moc k přepisování vhodné nejsou. LangMan na to jde tedy trochu jinak. Rutiny, které slouží k přístupu k řetězcům v resources, nahradí po spuštění aplikace vlastním kódem a při každém čtení nějakého řetězce z resources vrátí vždy lokalizovanou podobu podle zvoleného jazyka. Bohužel je zatím tato procedura napsaná pouze pro Windows aplikace. Tedy pro cílové platformy 32-bit Windows a 64-bit Windows. Použití komponenty TResourcesTranslatorX u aplikací přeložených pro jiné platformy sice žádnou chybu nezpůsobí, ale resourcestrings zde lokalizované nebudou.

2.3.2

Výběr překládaných resourcestrings Po přidání komponenty T(Uni)ResourcesTranslator(X) do vaší aplikace musíte vybrat, které řetězce mají být lokalizovány (nabídnuty v editoru jazyků k přeložení). V Delphi je jich tisíce, ale žádná aplikace není tak komplexní, že by používala úplně všechny, většinou ani zdaleka ne, některé dokonce nejsou použity vůbec. Proto je vhodné vybrat pouze ty, které mohou být ve vaší aplikaci použity nebo pouze ty, které chcete lokalizovat. Přitom je dobré vědět kde je který řetězec v kódu použit, protože v některých případech může mít změna za běhu programu negativní vliv na dobrou funkci programu. Resourcestrings, které chcete pomocí ResourcesTranslatoru lokalizovat, zaregistrujete pomocí specializovaného editoru (registrátoru) (viz Obr. 2.1), který zobrazíte kliknutím na editační tlačítko u vlastnosti RegisteredStrings nebo poklepáním na ikoně komponenty, případně z místní nabídky komponenty – položka Translated resources. V levé části okna editoru se nachází stromový seznam skupin (jednotek), ze kterých je možné registrovat resourcestrings pro lokalizace. All Registered - Zobrazí se všechny registrované řetězce Unsorted -

HW & SW Development

Řetězce nezařazené do žádné skupiny. Sem můžete jednoduše přidávat individuální resourcestrings, například když nechcete kvůli jedné položce vytvářet samostatnou skupinu. Tuto skupinu lze přejmenovat. www.regulace.org

19/67

LangMan 2.0 Imported -

Sem se vkládají pomocí tlačítka Import Resources ručně přidané skupiny (jednotky). Editor si z nich automaticky načte definované položky. Pokud v takové jednotce nezaregistrujete žádnou položku, bude po uzavření editoru opět automaticky odebrána.

Standard -

Seznam standardních jednotek Delphi obsahujících resourcestrings v jazyce, který je nastaven vlastností OriginalLanguage. Některé jednotky byly z této knihovny záměrně vyloučeny, protože jsou určeny pro návrh a neprojevují se za běhu aplikace. Patří mezi ně zejména jednotky pro Databinding, DUnit, ToolsAPI a Property Editors. Standardní podporované jazyky ze strany Delphi jsou: en – angličtina, de – němčina, fr – francouzština a ja – japonština. Pokud je nastaven jiný jazyk a nejsou zaregistrovány žádné standardní řetězce, skupina Standard bude prázdná.

Obr. 2.1: Registrátor resourcestrings pro komponentu T(Uni)ResourcesTranslator(X) Požadované řetězce zaregistrujete jednoduše vybráním a kliknutím na tlačítko Register, Register All, kliknutím na název položky nebo přepsáním řetězce. Protože aplikace vždy nevyvíjíte ve stejném jazyce v jakém jsou definovány již existující resourcestrings, je nutné s pomocí tohoto editoru zároveň provést lokalizaci do jazyka návrhu. Tímto jazykem je jazyk, který jste si zvolili pro vývoj aplikace a nastavili ve vlastnosti DesignLanguageName příslušného enginu. Pokud aplikaci vyvíjíte v angličtině a řetězce v resources HW & SW Development

www.regulace.org

20/67

LangMan 2.0 jsou také v angličtině, pak je stačí pouze zaregistrovat. Pomocí tlačítka Add můžete do zvolené skupiny ručně přidat vlastní položku. Pro lokalizace je vždy klíčovým parametrem originální podoba řetězce, tak jak je v programu definovaný. Názvy položek slouží pouze pro lepší orientaci a pro možnost vyhledávání. Položky přidané ručně a nevázané na známý řetězec z importované nebo standardní jednotky lze upravit kliknutím na název položky nebo tlačítko Modify. Tlačítko Put here slouží k přesunutí položky registrované v jiné skupině do aktuálně zvolené skupiny. Takové položky jsou označené modře. Abyste si ušetřili práci při vývoji dalších aplikací je možné zaregistrovat řetězce hromadně pomocí tlačítka Register from File. Pro hromadnou registraci lze použít soubor vyexportovaný pomocí tlačítka Export z jiného T(Uni)ResourcesTranslator(X) nebo i obyčejný jazykový soubor případně export jazyka. Samozřejmou podmínkou je, aby zdrojový soubor pro hromadnou registraci obsahoval lokalizované položky registrace ve stejném jazyce jako je jazyk návrhu aktuálního projektu.

2.4

Lexikony Kromě automatického překládání statických komponent, umístěných na formulářích, jsou v programech často zapotřebí řetězce pro různá dynamicky vytvářená dialogová okna, hlášení apod. K těmto účelům slouží lexikony, ve kterých lze potřebné řetězce nadefinovat. Ty jsou poté automaticky překládány, takže při čtení konkrétního záznamu je tento čten vždy už v příslušném jazyce.

2.4.1

T(Uni)DesignedLexicon(X) Řetězce v T(Uni)DesignedLexicon(X) se definují pomocí editoru přímo v object inspektoru. Jednotlivé řetězce mají přiděleny pořadové nezáporné indexy, pomocí nichž lze v programu získat vždy lokalizovanou podobu daného řetězce. Editor funguje podobně jako editor objektů TStrings, kde první řádek začíná indexem 0 a pokračuje 1, 2, atd. s tím rozdílem, že při odstranění jakéhokoli řádku (řetězce) nedojde k přečíslování následujících záznamů. Kdykoli později lze neobsazený index opět obnovit stisknutím klávesy Insert na příslušném řádku editoru.

2.4.2

T(Uni)ProgrammableLexicon(X) Položky programovatelného lexikonu mohou být na rozdíl od DesignedLexiconu definovány až ve zdrojovém kódu programu například v metodě události OnInitialization. Tento lexikon najde své uplatnění v případech, kdy jsou jazykové řetězce známy až při běhu programu. Podmínkou při pořizování překladu je, aby se v lexikonu před editací jazyka nacházely všechny položky, které mají být automaticky překládány, jinak nebude možné provést jejich lokalizaci do jiných jazyků. Z toho také vyplývá skutečnost, že položky tohoto lexikonu nebudou viditelné v editoru jazyků,

HW & SW Development

www.regulace.org

21/67

LangMan 2.0 spuštěného při návrhu aplikace z prostředí Delphi.

2.4.3

T(Uni)InlineLexicon(X) (pouze v edici Ultimate) Položky tohoto lexikonu definujete doslova inline přímo v kódu programu pomocí vlastnosti Loc['text'] nebo u odkazu pomocí vlastnosti SLink['text']. Inline lexikon se od předchozích liší tím, že nepoužívá indexy, ale přímo samotné řetězce zapsané ve výchozím jazyku návrhu. Položky tohoto lexikonu ale NEmusíte před editací jazyka inicializovat (jako je tomu u ProgrammableLexiconu), protože se do překladače zavedou samy už při kompilaci aplikace. Nespornou výhodou tohoto lexikonu je samozřejmě to, že se nemusíte vázat na nějaké indexy a neustále si pamatovat který řetězec máte pod kterým indexem, ale vlastně jen použijete řetězec přímo v kódu programu a nic dál neřešíte. Jedinou podmínkou je pouze nutnost použít v hranatých závorkách vlastností Loc a SLink přímo nepojmenovaný konstantní řetězec v uvozovkách. Nelze předávat proměnnou ani nepřímo definovanou konstantu. V těchto případech by byla nutná inicializace takových záznamů ještě před editací jazyka.

2.4.4

Další funkce lexikonů Další funkcí lexikonů je překládání dynamicky generovaných obsáhlejších textů. Do těchto textů lze při dynamickém vytváření obsahu vkládat namísto jednotlivých řetězců pouze odkazy na řetězce lexikonu. K tomu slouží vlastnosti Link a SLink* lexikonu. Pomocí metody CompleteString, lze kdykoliv text obsahující tyto odkazy převést do aktuálně zvoleného jazyka. Této funkce využívá také komponenta pro formátovaný text TLangManRichEdit.

2.5

T(Uni)LangCombo(X) Jedná se o ComboBox, který je po přiřazení k enginu automaticky naplněn existujícími jazyky. Volbou jazyka dojde k přeložení všech klientů a lexikonů. V případě, že je v jazykovém enginu povoleno vytváření či editace jazyků, je nabídka rozšířena i o tyto volby (platí pouze pro TLangCombo a TUniLangCombo ve VCL módu).

2.6

TLangFlagsCombo TLangFlagsCombo je vylepšený ComboBox, jehož položky jsou doplněny o ikony jazyků a případných voleb pro vytvoření a editaci jazyků uživatelem. Kromě těchto ikon je funkce i vzhled shodný s TLangCombo. Poznámka: Pod FireMonkey lze odpovídající komponentu snadno vytvořit sloučením komponent TLangComboX a TLangFlagX.

2.7

T(Uni)LangFlag(X) Komponenta TLangFlag(X) je potomkem třídy TImage (TUniLangFlag potomkem TUniImage) a lze ji spárovat s příslušným jazykovým enginem.

*

Podporováno pouze v edici Ultimate

HW & SW Development

www.regulace.org

22/67

LangMan 2.0 Vlastnost Picture (nebo Bitmap a MultiResBitmap u TLangFlagX) je pak automaticky nastavována na obrázek vlajky/ikony aktuálně zvoleného jazyka.

2.8

T(Uni)ValuedLabel(X) T(Uni)ValuedLabel(X) je doplňková komponenta podobná standardnímu TLabel (TUniLabel). Místo vlastnosti Caption (Text) má vlastnosti ValueName, ValueSeparator, ValueSpaces a Value. Tyto jsou ve výsledném zobrazení pospojovány přičemž ValueSpaces udává počet mezer za ValueSeparator. Trik spočívá v tom, že LangMan u této komponenty překládá, kromě Hint u VCL verze, pouze vlastnost ValueName. V programu potom stačí zapisovat pouze hodnotu „Value“. Využití je z tohoto popisu asi jasné.

2.9

TLangManRichEdit Komponenta TLangManRichEdit je nejnovější vizuální komponentou balíčku. Je potomkem třídy TCustomRichEdit a byla vyvinuta pro generování různých výpisů, logů, protokolů apod. s využitím různých stylů písma. Jedná se o obdobu třídy TLangManStrings (viz kapitoly 4.14 a 6 tohoto manuálu). Oproti TLangManStrings ale tato komponenta nabízí možnost vytvářet hezčí a přehlednější dokumenty, přičemž je možné dynamicky měnit jazyk obsaženého textu. Zásadní rozdíl oproti komponentě TRichEdit spočívá v nemožnosti úprav textu uživatelem prostřednictvím klávesnice. TLangManRichEdit má vlastnost ReadOnly skrytou a na pevno nastavenou na hodnotu true. Není přítomna ani vlastnost Lines a veškeré zapisování a úpravy textu mají být prováděny pouze pomocí příslušných metod třídy TLangManRichEdit. Výhodou této komponenty je, že si u ní můžete přednastavit sadu stylů (parametrů fontu) pro celý dokument a při zapisování jednotlivých řetězců a údajů už jen odkazujete na styl, který má být pro vypsání příslušného řetězce použit. Samozřejmostí je i možnost následného uložení výsledného dokumentu ve formátu RTF.

HW & SW Development

www.regulace.org

23/67

LangMan 2.0

3

Editor jazyků Součástí sady komponent LangMan je editor jazyků, který může být spuštěn za běhu aplikace pomocí metod ShowLangEditor a ShowLangCreator komponenty T(Uni)LangManEngine(X) nebo přímo z automaticky vytvořené nabídky jazyků jako podmenu objektu TMenuItem, přiřazeného vlastnosti LanguageMenu, a nebo z nabídek vizuálních komponent TLangCombo, TLangFlagsCombo a TUniLangCombo, pokud je viditelnost položek editoru v nabídkách povolena pomocí vlastností LangCreatorVisible a LangEditorVisible. Komponenta TLangComboX (pod FireMonkey) tuto možnost nemá a ve webové aplikaci uniGUI lze editor za běhu spustit pouze ve VCL módu. U edic Premium a Ultimate lze navíc editor spustit i v době návrhu aplikace přímo v IDE Delphi. Důležitou informací je, že v editoru jazyků se nachází vždy pouze ty položky, které jsou v paměti. Takže například zde nenajdete formuláře, které nebyly vytvořeny do paměti.

3.1

Okno editoru Editor byl navržen tak, aby jeho používání bylo maximálně intuitivní, takže asi není nutné jej úplně dopodrobna popisovat. Zaměříme se spíše na důležité prvky editoru a na popis vlastností, které nejsou úplně jasné. Spustíte-li editor příkazem pro přidání nového jazyka, budete muset nejdříve vybrat zdrojový jazyk (pokud je jich v aplikaci více než jeden) a pak zadat název nového jazyka (1) a dvoupísmenný ISO kód (2), dle mezinárodní normy ISO 639-1.

Po kliknutí na tlačítko (3) budete vyzváni k zadání názvu souboru jazyka a následně bude tento jazyk vytvořen. Do editoru se načtou položky pro překlad ve zvoleném zdrojovém jazyce a můžete začít překládat. Pokud spustíte editor za účelem úpravy jazyka a zároveň lze editovat více než jeden jazyk, musíte nejdříve zvolit, který chcete otevřít (4). (5) je ikona jazyka. Tuto ikonu (vlajku) můžete změnit kliknutím levým tlačítkem myši. Pokud byste chtěli ikonu pouze smazat, stačí na ni kliknout pravým tlačítkem myši a následně potvrdit své rozhodnutí kliknutím na tlačítko YES v zobrazeném dialogu. HW & SW Development

www.regulace.org

24/67

LangMan 2.0 TIP: Nacházíte-li se ve VCL verzi editoru, můžete u většiny prvků využít jednoduchou bublinovou nápovědu (Hint). Zobrazí se, když na ovládacím prvku zastavíte kurzorem myši.

Tlačítkem (6) můžete editor se současným uložením všech změn kdykoli ukončit. Chcete-li odejít bez uložení změn, musíte editor zavřít křížkem v pravém horním rohu (nebo pomocí klávesové zkratky - ve Windows je to Alt+F4) a potvrdit uzavření bez uložení změn.

3.1.1

Import a export U edic Premium a Ultimate je navíc k dispozici tlačítko pro import dat (7). Importovat lze: ● Data stejného jazyka exportované LangManem z libovolné aplikace ● Jazykový soubor stejného jazyka uložený stejnou aplikací (například při převodu z jedné instalace do druhé) ● Data uložené komponentou TLang z palety Standard knihovny FireMonkey. Vhodné při přechodu od komponenty TLang na LangMan. ● Obecný textový soubor – co řádek to položka ve formátu: originál=překlad kde originál je příslušný řetězec v jazyce návrhu. Pozor! Neplést jazyk návrhu se zdrojovým jazykem daného jazyka. Jazyk návrhu je jazyk, ve

HW & SW Development

www.regulace.org

25/67

LangMan 2.0 kterém je aplikace naprogramována. Ze souboru se importují vždy pouze existující a dosud nepřeložené položky zvoleného jazyka a importuje se také ikona/vlajka, pokud není žádná přiřazena. Tlačítko pro export dat (8) je dostupné pouze v edici Ultimate. Při exportu je vytvořen speciální soubor, který lze importovat v jakékoli jiné aplikaci s LangManem. Tato funkce šetří čas tím, že nemusíte znovu překládat opakující se položky. Podmínkou pro přenos jazykových dat mezi různými aplikacemi je jednotný jazyk návrhu.

3.1.2

Editace / překlad V horní části editoru jsou zobrazeny základní informace ke každé překládané položce. Popis zdrojového jazyka (9) a znění položky ve zdrojovém jazyce (10). Ikona (11) blíže charakterizuje zdrojový řetězec. Tabulka 1 popisuje co která ikona/barva symbolizuje. LangMan obsahuje jak VCL editor pro T(Uni)LangManEngine, tak FireMonkey verzi pro TLangManEngineX. Z důvodů mnoha odlišností mezi těmito knihovnami (VCL vs. FireMonkey) se problematicky dosahuje plné jednotnosti obou editorů. Citelný rozdíl je zejména v grafickém vyjádření stavů řetězců, popsaných v Tabulce 1. Zatímco editor pro FireMonkey zobrazuje stavy pomocí ikon, editor pro VCL využívá pouze barevné okýnka. VCL editor zase ale na rozdíl od FireMonkey (FMX) zobrazuje bublinovou nápovědu (Hint) popisující stav řetězce v textové podobě. Tabulka 1: Přehled grafických symbolů charakterizujících položky jazyka Vyjádření FMX

VCL

Popis

■

Vnitřní (originální) jazyk návrhu aplikace.

■

Položka načtena ze zdrojového jazyka.

■

Globální položka ze zdrojového jazyka.

■

Položka přeložená lokálně.

■

Položka přeložená globálně.

■

Prázdný řetězec – neplatný překlad.

■

Prázdný globální řetězec – doplňte překlad.

■

Zrušení lokálního překladu v daném jazyce. Použije se znění dle zdrojového jazyka nebo globální překlad.

■

Odstranění globálního překladu – platí napříč celou aplikací pro všechny položky, které využívají stejný globální překlad.

HW & SW Development

www.regulace.org

Edice LangMan Personal Professional Ultimate Premium

26/67

LangMan 2.0 Vyjádření FMX

VCL

Popis

■

Ponechat zdrojový překlad – položka zůstane nepřeložená, ale bude považována za přeloženou.

■

Obnovený překlad – po navrácení již dříve přeloženého objektu na formulář.

■

Chyba – neplatný překlad

Edice LangMan Personal Professional Ultimate Premium

Dalším rozdílem je způsob přepínání stavu položek. Pokud například nějaká vlastnost komponenty na formuláři nemá být v daném jazyce překládána, můžete ji přepnout do stavu „Ponechat zdrojový překlad“ viz Tabulka 1. Ve VCL editoru tak učiníte kliknutím na popis vlastnosti/položky (13,14) nebo stiskem kombinace kláves Ctrl+Šipka vlevo nachází-li se textový kurzor na příslušném překladu (15), zatímco ve FireMonkey editoru kliknutím na stavovou ikonu (14), příslušné vlastnosti/položky (13).

V edici Ultimate, která podporuje globální lexikon, můžete ještě přepínat položky mezi lokálním překladem a překladem umístěným v globálním lexikonu. Standardně jsou všechny překlady (15) lokálního charakteru, což znamená, že jsou spojeny s daným objektem. Pokud se v aplikaci například nachází několik tlačítek OK, každé může být v jednom jazyce přeloženo jinak. Pokud ale nechcete dělat rozdíly v překladu několika stejných řetězců, můžete překlad uložit do globálního lexikonu. U další stejné položky pak stačí přepnout na globální lexikon čímž se překlad sjednotí. HW & SW Development

www.regulace.org

27/67

LangMan 2.0 DŮLEŽITÉ: Je velmi dobré si uvědomit, že podstatným rozdílem mezi lokálním a globálním překladem je ta skutečnost, že zatímco lokální překlad je vázán adresou v podobě Objekt.Vlastnost.Položka (např. ComboBox1.Items.Strings[1]), globální překlad je vázán originálním tvarem řetězce (např. „Exit“). Takže globální překlad je dobrou volbou nejen u opakujících se výrazů, ale také u překladu číslovaných položek jedné vlastnosti, kde by jejich přeuspořádání vedlo k nutnosti následně upravit pořadí těchto položek i u překladů ve všech jazycích! Každý T(Uni)LangManEngine(X) z edice Ultimate v sobě zahrnuje společný globální lexikon do kterého mohou být napojeny (viz vlastnost GlobalLexicon 4.2.1.2) ostatní jazykové komponenty LangManu. V editoru se u komponent s napojením na globální lexikon zobrazuje ikona (17). Není-li nastavena vlastnost GlobalLexicon na hodnotu true mohou být položky přeloženy vždy pouze lokálně. V aktuální stránce editoru (12) jsou vždy zobrazeny pouze položky právě zvolené skupiny (jazykové komponenty) (16) a pokud je touto komponentou T(Uni)LangManClient(X) nebo T(Uni)ResourcesTranslator(X) je výběr omezen ještě na podobjekty (18) vybrané komponenty. U lexikonů se na jednu stránku vypisují všechny položky daného lexikonu. Tlačítka Zpět (19) a Další (20), lze použít pro skok na předchozí nebo následující objekt. Pro rychlé vyhledání nepřeložených položek lze při kliknutí na některé z těchto tlačítek držet klávesu Shift, což povede k přeskočení všech kompletně přeložených objektů v daném směru.

3.1.3

Vyhledávání Pro vyhledávání řetězců na aktuální stránce editoru můžete použít vyhledávací pole (21) s tlačítkem (22). Vyhledávání začíná vždy od aktuálně vybraného řádku tabulky. Po dosažení posledního řádku pokračuje vyhledávání znovu od začátku. S funkcí vyhledávání je spojeno několik klávesových zkratek: Přesun kurzoru do vyhledávacího pole: Ctrl+F Start vyhledávání: Enter ve vyhledávacím poli F3 kdekoli Klik levým tlačítkem myši na tlačítko s lupou Standardně se prohledávají pouze řetězce překladu (15). Chcete-li hledat i v řetězcích ve zdrojovém jazyku (10), podržte při vyhledávání stisknutou klávesu Ctrl. Pokud se zdrojový jazyk liší od jazyka návrhu aplikace, můžete s přidržením klávesy Shift hledat i v originálním jazyce návrhu.

3.1.4

Copyright panel Nastavením vlastnosti enginu HideCopyright na hodnotu true můžete u editoru, spuštěného za běhu aplikace, skrýt panel (23). Tato možnost není přístupná u edice LangMan Personal.

HW & SW Development

www.regulace.org

28/67

LangMan 2.0

4

Třídy balíčku komponent LangMan

4.1

TLangManEngine(X) = class ( TLangManCore ) TUniLangManEngine = class ( TLangManEngine ) Unit: LangManComp(X/Uni); Základní stavební kámen, dále jen engine. Zprostředkovává překlad, přepínání jazyků a spravuje jazykové soubory.

4.1.1

Metody tříd T(Uni)LangManEngine(X)

4.1.1.1

Function Translate ( ISOorLangName: String ): TLanguage; Funkce přeloží všechny připojené komponenty do požadovaného jazyka. Předávaný parametr je typu string a určuje požadovaný jazyk buďto názvem nebo ISO kódem. Proběhne-li v pořádku překlad, je volána událost OnChangeLanguage. Funkce vrací název aktuálního jazyka po přeložení.

4.1.1.2

Procedure AssignLanguagesList( TargetList: TStrings ); Tato procedura nahrazuje funkci GetLanguagesList z předchozích verzí komponent LangMan. AssignLanguagesList přiřadí seznam načtených jazyků seznamu v parametru TargetList. Jednotlivé položky tohoto seznamu jsou platnými jazyky a lze je použít jako parametr funkce Translate.

4.1.1.3

Function GetLanguageFile( ISOorLangName: String ): TFileName; Funkce vrací plnou cestu k jazykovému souboru požadovaného jazyka, zadaného jeho názvem nebo ISO kódem.

4.1.1.4

Function GetLanguageFile( LanguageIndex: Integer ): TFileName; Funkce vrací plnou cestu k jazykovému souboru požadovaného jazyka, zadaného pořadovým číslem (indexem) v seznamu všech jazyků, který lze získat pomocí metody AssignLanguagesList.

4.1.1.5

Function GetISOCode( LanguageName: String ): String; Vrací ISO kód podle názvu jazyka.

4.1.1.6

Function GetISOCode(LanguageIndex: Integer): String; Vrací ISO kód jazyka, zadaného pořadovým číslem (indexem) v seznamu všech jazyků, který lze získat pomocí metody AssignLanguagesList.

HW & SW Development

www.regulace.org

29/67

LangMan 2.0

4.1.1.7

Function LangExists(ISOorLangName: String): Boolean; Vrací true pokud jsou k dispozici data pro jazyk zadaný ISO kódem nebo názvem.

4.1.1.8

Function FlagImage(ISOorLangName: String):TMemoryStream; Tato varianta funkce FlagImage vrací TMemoryStream ikony jazyka, určeného názvem nebo ISO kódem.

4.1.1.9

Function FlagImage(LanguageIndex: Integer):TMemoryStream; Tato varianta funkce FlagImage vrací TMemoryStream ikony požadovaného jazyka, zadaného pořadovým číslem (indexem) v seznamu všech jazyků, který lze získat pomocí metody AssignLanguagesList.

4.1.1.10

Function EditorCanBeShown: Boolean; Funkce vrací true, pokud může být zobrazen editor jazyků. Editor nemůže být zobrazen, pokud není přítomen žádný jazyk pro editaci. V takovém případě je vrácena hodnota false. K jazykům, které nelze editovat patří výchozí jazyk návrhu a jazyky přilinkované k aplikaci (v „resources“), pokud není nastavena vlastnost LangResourcesAllowEdit na hodnotu true.

4.1.1.11

Procedure ShowLangEditor; Tato metoda spouští editor jazyků. Jazyky v něm lze pouze upravovat, nikoliv však přidávat. Podmínkou spuštění editoru je přítomnost alespoň jednoho jazyka pro editaci. Zda je tato podmínka splněna lze zjistit zavoláním funkce EditorCanBeShown. Poznámka: Pokud nastavíte vlastnost LangEditorVisible na hodnotu true bude editor jazyků dostupný také v LanguageMenu, TLangCombo, TLangFlagsCombo a TUniLangCombo ve VCL módu.

4.1.1.12

Procedure ShowLangCreator; Tato procedura spouští editor jazyků v režimu přidání nového jazyka. Poznámka: Pokud nastavíte vlastnost LangCreatorVisible na hodnotu true bude příkaz pro vytvoření nového jazyka dostupný také v LanguageMenu, TLangCombo, TLangFlagsCombo a TUniLangCombo ve VCL módu.

4.1.1.13

Procedure RefreshLangControl( LangManGUIControl: TComponent ); Pomocí této metody lze obnovit obsah vizuální jazykové komponenty jako je např. T(Uni)LangCombo(X), T(Uni)LangFlag(X) nebo TLangFlagsCombo. Komponentu, která má být obnovena, je třeba předat v parametru LangManGUIControl.

HW & SW Development

www.regulace.org

30/67

LangMan 2.0

4.1.1.14

Function ImportFromFile( FileName: String; ToCurrentLanguage: Boolean ): Integer; (pouze edice Premium a Ultimate) Pomocí této funkce lze importovat data včetně ikony ze souboru, určeného parametrem FileName. Může se jednat o jazykový soubor stejné aplikace nebo o soubor LangMan exportu, který lze využít i pro přenos překladů mezi různými aplikacemi. Parametr ToCurrentLanguage určuje, zda mají být (true) data importovány výhradně do právě zvoleného jazyka nebo zda může být v případě potřeby (false) vytvořen nový jazyk (jazykový soubor). Pokud bude nastaven parametr na hodnotu true a jazyk importovaných dat nebude odpovídat zvolenému jazyku, bude vygenerována výjimka EImportExport. Funkce vrací počet skutečně importovaných položek překladu do daného jazyka. Ze souboru se importují pouze překlady těch řetězců, které jsou v aktuální aplikaci použity a zároveň nemají v příslušném jazyce svou lokalizaci. Pokud je nastaven parametr ToCurrentLanguage na false a importovaný soubor obsahuje jazyk, který podle ISO kódu nebo názvu jazyka nesouhlasí s žádným jazykem v příslušném enginu, bude na základě tohoto souboru vytvořen nový jazyk. Takto lze například jednoduše doinstalovat další jazyk v cílové instalaci aplikace. Pokud jazyk importovaného souboru již existuje, budou importovány pouze nepřeložené položky v daném jazyce, případně bude načtena chybějící ikona daného jazyka. Pomocí tlačítka Import v editoru jazyků lze importovat do vybraného jazyka navíc i překlady z lng souboru, uloženého komponentou TLang z knihovny FireMonkey nebo z textového souboru, který obsahuje na jednotlivých řádcích položky překladu v podobě: originál=překlad

kde originál je příslušný řetězec v jazyce návrhu aplikace a překlad je jeho překlad v daném jazyce. Díky této možnosti importu jazyků lze velmi snadno a rychle přejít od jiných lokalizačních nástrojů k používání oblíbených komponent LangMan.

4.1.1.15

Procedure ExportToFile( FileName: String ); (pouze edice Ultimate) Provede export jazyka do souboru FileName. Exportovaný soubor lze použít například pro import v jiném projektu či podobné aplikaci, čímž lze ušetřit čas překladatele, pokud byly některé řetězce už jednou přeloženy. Podmínkou pro přenos jazykových dat mezi různými aplikacemi je shodný výchozí jazyk návrhu. U cílového souboru je vhodné volit koncovku .llx.

HW & SW Development

www.regulace.org

31/67

LangMan 2.0

4.1.2

Vlastnosti tříd T(Uni)LangManEngine(X)

4.1.2.1

Property CurrentLanguage: String Vlastnost CurrentLanguage vrací název aktuálně zvoleného jazyka a nastavuje jazyk.

4.1.2.2

Property CurrentLanguageISO: String Vlastnost CurrentLanguageISO vrací kód ISO aktuálního jazyka a nastavuje jazyk dle ISO kódu.

4.1.2.3

Property DesignLangISOCode: String Určuje ISO kód jazyka, použitého při návrhu aplikace. Komponenty LangMan používají dvoupísmenné kódy dle normy ISO 639-1 k jednoznačnému určení jazyka bez ohledu na jeho konkrétní název. Název návrhového jazyka se nastavuje vlastností DesignLanguageName.

4.1.2.4

Property DesignLanguageName: TLanguage Vlastnost slouží pro nastavení názvu návrhového jazyka. Jde o hlavní jazyk, který je použit při návrhu aplikace. Tento jazyk lze použít kdykoliv jako výchozí jazyk překladu. Při návrhu aplikace je vhodné používat rozšířený světový jazyk, nejlépe angličtinu. ISO kód návrhového jazyka se nastavuje vlastností DesignLangISOCode.

4.1.2.5

Property DefaultLanguage: String Výchozí jazyk, který má být nastaven po spuštění aplikace. V metodě události OnCreate formuláře lze do této vlastnosti zapsat například jazyk operačního systému nebo jazyk, použitý při posledním běhu aplikace. Tento výchozí jazyk se načítá až v okamžiku aktivace aplikace, tedy když už jsou vytvořeny všechny formuláře. Může být přiřazen buďto název jazyka nebo ISO kód.

4.1.2.6

Property LangSubdirectory: String Plná absolutní cesta, relativní cesta nebo pouze název podadresáře pro ukládání jazykových souborů. Windows: Za výchozí adresář je ve Windows považován adresář, v němž se nachází spustitelný soubor aplikace. OSX: Výchozím adresářem je domovská složka aktuálního uživatele. iOS: U mobilních zařízení se systémem iOS je výchozí složkou domovská složka aplikace. Cesta k této složce je závislá na tom, kde se nachází sandbox aplikace, který je definován individuálně pro každou aplikaci. Android: Na platformě Android je výchozím adresářem složka pro data aplikace.

HW & SW Development

www.regulace.org

32/67

LangMan 2.0 Bude-li vlastnost LangSubdirectory rovna prázdnému řetězci, budou jazykové soubory ukládány do výchozího adresáře.

4.1.2.7

Property LangFileExtension: String Koncovka jazykových souborů. Při vícenásobném použití komponenty T(Uni)LangManEngine(X) v jedné aplikaci je nutné nějak odlišit jazykové soubory příslušející této komponentě od ostatních jazykových souborů ostatních enginů. Koncovka jazykových souborů je jednou z vhodných možností odlišení.

4.1.2.8

Property LangFileSignature: String Identifikační řetězec jazykových souborů, příslušejících tomuto enginu. Při vícenásobném použití komponenty T(Uni)LangManEngine(X) v jedné aplikaci je nutné nějak odlišit jazykové soubory příslušející této komponentě od ostatních jazykových souborů ostatních enginů. Identifikační řetězec je ukládán do jazykových souborů a měl by odlišovat jazykové soubory náležející různým enginům, ideálně i různým aplikacím.

4.1.2.9

Property LangCreatorVisible: boolean Tato vlastnost určuje, zda má být v nabídkách pro volbu jazyků viditelná i volba pro vytvoření nového jazyka. U uniGUI aplikací může být spuštěn editor jazyka pouze v jedné instanci ve VCL módu, proto nemá u webových formulářů toto nastavení žádný vliv.

4.1.2.10

Property LangEditorVisible: boolean Tato vlastnost určuje, zda má být v nabídkách pro volbu jazyků viditelná i volba pro úpravu jazyka. Tato volba není viditelná v případě, že v programu není zaveden žádný editovatelný jazyk nebo pokud se jedná o webovou instanci aplikace. Editovatelný není výchozí jazyk návrhu aplikace ani jazyky přilinkované k aplikaci jako resources, pokud není na hodnotu true nastavena vlastnost LangResourcesAllowEdit a to ani když se soubor stejného jazyka nachází ve zvoleném adresáři souborového systému. U uniGUI aplikací může být spuštěn editor jazyka pouze v jedné instanci ve VCL módu, proto nemá u webových formulářů toto nastavení žádný vliv.

4.1.2.11

Property TranslateLangMan: boolean Vlastnost TranslateLangMan povoluje začlenění vnitřních lokalizovatelných řetězců komponent LangMan, zejména pak jazykového editoru, do seznamu překládaných komponent. Do vybraných jazyků, kterými jsou čeština, slovenština a angličtina, je LangMan lokalizován interně.

HW & SW Development

www.regulace.org

33/67

LangMan 2.0

4.1.2.12

Property LanguageMenu: TMenuItem Vlastnost LanguageMenu slouží pro automatické generování jazykového menu. Stačí přiřadit libovolnou komponentu třídy TMenuItem z hlavní nebo místní nabídky.

4.1.2.13

Property LangMenuFlags: boolean Tato vlastnost určuje, zda mají být v menu zobrazeny ikony (vlajky/symboly) jazyků. Toto platí pouze pro menu přidělené vlastností LanguageMenu.

4.1.2.14

Property DesignLangFlag: TPicture (TBitmap ve FMX verzi) Grafický symbol jazyka návrhu. Ideálně vlajka země v níž je daný jazyk národním jazykem.

4.1.2.15

Property LangResources: TStringList Chcete-li mít jazykové soubory součástí aplikace, přidejte je do resources a přiřazené ID názvy těchto zdrojů vložte do tohoto seznamu. Pokud chcete, aby šlo upravovat tyto jazyky i později v run-time editoru aplikace, přiřaďte vlastnosti LangResourcesAllowEdit hodnotu true. Před editací vnitřního jazyka se vytvoří kopie (pokud již neexistuje) v adresáři, určeném vlastností LangSubdirectory.

4.1.2.16

Property LangFileEncoding: TLFEncoding Kódování jazykových souborů. Výchozím nastavením je Unicode. Jestliže požadujete z jakéhokoli důvodu jiný typ kódování jazykových souborů, máte na výběr z následujících možností: type TLFEncoding = (Unicode, BigEndianUnicode, UTF8, ANSI); Poznámka: Tato vlastnost není dostupná v Delphi 2007 a starších, kde je výchozím kódováním ANSI a nelze jej změnit.

4.1.2.17

Property LangResourcesAllowEdit: boolean Nastavením na hodnotu true povolíte úpravy a překrytí vnitřních jazykových souborů aplikace externím jazykovým souborem.

4.1.2.18

Property HideCopyright: boolean (pouze placené edice Professional, Premium a Ultimate) Nastavením na hodnotu true můžete skrýt panel s copyrightem, který se nachází ve spodní části editoru jazyků. Toto nastavení nemá vliv na editor spuštěný v prostředí IDE.

HW & SW Development

www.regulace.org

34/67

LangMan 2.0

4.1.3

Vlastnosti třídy TUniLangManEngine (pouze v edicích Premium a Ultimate)

4.1.3.1

Property CookieEnable: Boolean Povoluje ukládání zvoleného jazyka do cookies prohlížeče u webových aplikací založených na frameworku uniGUI. Ve VCL módu nemá nastavení cookies žádný vliv.

4.1.3.2

Property CookieLifeDays: Double Určuje dobu platnosti cookie zvoleného jazyka. Jednotkou je 1 den, stejně jako u typu TDateTime.

4.1.3.3

Property CookieName: String Název cookie, která bude reprezentovat uživatelův zvolený jazyk.

4.1.4

Vlastnosti třídy TLangManEngineX

4.1.4.1

Property StyleBook: TStyleBook Stylebook pro formulář jazykového editoru.

HW & SW Development

www.regulace.org

35/67

LangMan 2.0

4.1.5

Události tříd T(Uni)LangManEngine(X)

4.1.5.1

OnChangeLangQuery: TContinueQuery Událost volaná před změnou jazyka. Pokud je překlad do zvoleného jazyka nežádoucí, lze překlad zastavit zapsáním hodnoty false do návratového parametru Continue.

4.1.5.2

OnChangeLanguage: TNotifyEvent Událost volaná po změně jazyka.

4.1.5.3

OnBeforeEdit: TNotifyEvent Událost volaná před spuštěním jazykového editoru. Při editaci jazyka je nutné, aby byla v paměti nahrána struktura všech prvků, které mají být komponentou překládány. Mají-li být překládány například dynamicky vytvářené formuláře nebo dynamicky vytvářené komponenty formulářů, je třeba všechny tyto komponenty a formuláře alespoň dočasně v paměti vytvořit, aby mohly být přeloženy. To samé platí pro položky programovatelného lexikonu.

4.1.5.4

OnAfterEdit: TNotifyEvent Po ukončení editoru jazyků je volána událost OnAfterEdit. V této události lze komponenty, které byly vytvořené dynamicky jen kvůli překladu, opět z paměti uvolnit. Při opakovaném vytvoření stejného dynamického formuláře se už automaticky přeloží do aktuálního jazyka. Zatímco po vytvoření dynamické komponenty je nutné zavolat její dodatečné přeložení ručně.

HW & SW Development

www.regulace.org

36/67

LangMan 2.0

4.2

TLangManComponent = class ( TComponent ) Unit: LangManCore; Třída TLangManComponent je základem pro všechny nevizuální jazykové komponenty, jako jsou T(Uni)LangManClient(X), T(Uni)ResourcesTranslator(X), T(Uni)DesignedLexicon(X), T(Uni)ProgrammableLexicon(X) a T(Uni)InlineLexicon(X).

4.2.1

Vlastnosti třídy TLangManComponent

4.2.1.1

Property LangManEngine: TLangManCore Vlastnosti LangManEngine musí být přiřazen T(Uni)LangManEngine(X), který dané jazykové komponentě umožní lokalizaci do zvoleného jazyka.

4.2.1.2

Property GlobalLexicon: Boolean (pouze v edici Ultimate) Nastavením na true povolujete komponentě používat globální lexikon. Tato vlastnost je dostupná pouze v edici Ultimate, u které je do enginu zapracován globální lexikon, který je společný pro všechny komponenty připojené k příslušnému enginu. Do tohoto lexikonu lze umístit libovolné řetězce jak jednotlivých lexikonů aplikace, tak jednotlivých klientů (formulářů) nebo komponent TResourcesTranslator(X) a pak stačí shodné řetězce přeložit pouze jednou. Například všechny tlačítka Cancel, budou mít v jazykovém souboru pouze jeden společný překlad. V editoru jazyků se vkládají položky objektů do globálního lexikonu jednotlivě kliknutím na tlačítko nebo stavovou ikonu v tabulce editoru vlevo vedle překládaného řetězce. Opakovaným kliknutím lze nastavit nazpět standardní lokální překlad dané vlastnosti a u položek formulářů lze také překlad zakázat. Je-li nastavena vlastnost GlobalLexicon na false mohou být všechny překlady pouze lokální a opakující se řetězce je nutno přeložit každý zvlášť.

4.2.2

Události třídy TLangManComponent

4.2.2.1

OnChangeLanguage: TNotifyEvent Událost volaná po změně jazyka.

HW & SW Development

www.regulace.org

37/67

LangMan 2.0

4.3

TLangManClient(X) = class ( TLangManCPC ) TUniLangManClient = class ( TLangManClient ) Unit: LangManComp(X/Uni); Tato komponenta, dále jen klient, slouží pro zavedení formuláře, na který je umístěna, do překladu vybraným enginem. Kromě toho umožňuje zvolit, které vlastnosti mají být na formuláři a jeho komponentách překládány. Výchozí třída: TLangManCPC = class ( TLangManComponent ) Unit: LangManCore; je multiplatformním základem tříd T(Uni)LangManClient(X).

4.3.1

Metody tříd T(Uni)LangManClient(X)

4.3.1.1

Function AddComponent (Component: TComponent; Name: string; Translate: boolean): Boolean; Požadujete-li, aby byly překládány i komponenty formuláře, které jsou vytvářené dynamicky za běhu programu, je nutné každou takovou komponentu dodatečně přidat do seznamu komponent formuláře, který udržuje komponenta T(Uni)LangManClient(X). Podmínkou pro správnou funkci automatických překladů je, aby byl vlastníkem takových komponent formulář. V případě několika stejných dynamických komponent, které mají být i shodně přeloženy, lze použít společné jméno. Potom stačí zaregistrovat komponentu pomocí funkce AddComponent pouze jednou. Při znovuvytvoření stejné komponenty také není zapotřebí ji znovu registrovat, stačí použít stejné jméno jako při předchozí registraci. Podmínkou je, aby byla vždy každá dynamicky vytvářená komponenta, která má být překládána, shodně pojmenována. Funkce AddComponent provádí pojmenování za vás. V parametru Component musí být přidávaná komponenta, v parametru Name je možné předat nové jméno komponenty. Pokud už komponenta má své unikátní jméno přiřazeno ve vlastnosti Component.Name, použijte pro parametr Name prázdný řetězec. Poslední parametr Translate určuje, zda má být po přidání nové komponenty ihned proveden i překlad do aktuálního jazyka. Pro hromadný překlad celého formuláře lze použít metodu Translate. Pro dodatečný překlad jedné komponenty formuláře lze použít metodu TranslateComponent.

4.3.1.2

Procedure RecreateTransStruct; Tato metoda provede znovusestavení seznamu komponent formuláře. Do tohoto seznamu jsou zahrnuty všechny pojmenované komponenty, které v daném okamžiku patří formuláři, takže lze tuto metodu použít pro hromadné zavedení dynamicky vytvářených komponent formuláře do seznamu překládaných komponent. Po zrušení některé komponenty je tato metoda

HW & SW Development

www.regulace.org

38/67

LangMan 2.0 jedinou možností, jak odebrat zrušenou komponentu ze seznamu překládaných komponent. Přítomnost neexistující komponenty v překladovém seznamu má ale vliv pouze na přítomnost této komponenty v editoru jazyků, což je obvykle spíše žádoucí. Pokud je v enginu zrovna načten nějaký jazyk (jiný než jazyk návrhu), provede se navíc automaticky i překlad nových komponent.

4.3.1.3

Procedure TranslateComponent(Component: TComponent; Name: string = ''); Metoda TranslateComponent slouží pro přeložení jedné komponenty do aktuálně zvoleného jazyka. Přitom nezáleží na tom, jaká komponenta je vlastníkem komponenty, předané v parametru Component. Zato pro automatický překlad je bezpodmínečně nutné, aby byl vlastníkem formulář. Podmínkou je, aby měla komponenta v rámci vlastníka své unikátní jméno. Pokud tomu tak není, lze předat nové jméno v parametru Name. V opačném případě ponechejte parametru Name prázdný řetězec.

4.3.1.4

Procedure Translate; Přeloží formulář a všechny jeho pojmenované komponenty. Při změně jazyka proběhne překlad automaticky, avšak po přidání většího počtu dynamicky vytvořených komponent lze tuto metodu použít pro dodatečné hromadné přeložení všech nových pojmenovaných komponent formuláře.

4.3.1.5

Procedure TranslateAs(FormName: String); Nastaví jméno překládaného formuláře. Tuto funkci využijete např. u MDI aplikací nebo otevíráte-li třeba ve své aplikaci více stejných oken pouze s jinými daty apod. Stačí v události OnCreate formuláře zavolat tuto metodu a přidělit tak formuláři vlastní jméno, které bude díky tomu společné pro všechny instance formuláře a LangMan je bude překládat stejně. Řetězec FormName tak bude zastupovat originální jméno formuláře jako komponenty, které jinak musí být v rámci aplikace unikátní. Poznámka: V edici Personal není tato metoda dostupná!

HW & SW Development

www.regulace.org

39/67

LangMan 2.0

4.3.2

Vlastnosti tříd T(Uni)LangManClient(X)

4.3.2.1

Property InitAfterCreateForm: boolean Tato vlastnost určuje zda má dojít k sestavení seznamu automaticky překládaných komponent formuláře až po volání metody události OnCreate formuláře true, nebo ještě předtím false.

4.3.2.2

Property TransAdditions: TAdditionSet Množina názvů uživatelských doplňků, které mají být překládány.

4.3.2.3

Property TransStringProp Množina názvů vlastností typu string, které mají být překládány.

4.3.2.4

Property TransTStringsProp Množina názvů vlastností typu TStrings, které mají být překládány.

4.3.2.5

Property TransStructuredProp Množina názvů vlastností jiných typů, obvykle složitějších struktur, které mají být překládány.

4.3.2.6

Property TransOtherProp Množina názvů vlastností jiných typů, které mají být překládány. V některých případech se může jednat o názvy celých tříd.

4.3.3

Vlastnosti třídy TLangManClientX

4.3.3.1

Property TransXtraOptions: TFMXClientOptionsSet Množina upřesňujících předvoleb.

HW & SW Development

www.regulace.org

40/67

LangMan 2.0

4.4

TLMList = class ( TLangManComponent ) Unit: LangManCore; Třída implementující základní funkcionalitu pro jazykové komponenty pracující se seznamem řetězců. Jejími potomky jsou třídy TLexicon a T(Uni)ResourcesTranslator(X).

4.4.1

Metody třídy TLMList

4.4.1.1

Function IsDefined(Index: Integer): boolean; Funkce IsDefined vrací true, pokud je Index položky platný / obsazený nějakým nenulovým řetězcem.

4.4.1.2

Function IsDefined(LocStr: String): boolean; Tato alternativa funkce IsDefined vrací true, pokud se v seznamu nachází řetězec LocStr. Funkce pracuje pouze s jazykem návrhu, nelze se pomocí ní dotazovat na existenci řetězce lokalizovaného do jiného jazyka.

4.4.1.3

Function GetLocStr(Index: Integer): String; GetLocStr vrací položku seznamu z pozice Index v původním jazyce návrhu.

4.5

TResourcesTranslator(X) = class ( TCustomResourcesTranslator ) TUniResourcesTranslator = class ( TResourcesTranslator ) Unit: LangManComp(X/Uni); Komponenta T(Uni)ResourcesTranslator(X) slouží pro lokalizace řetězcových zdrojů „resourcestrings“, které byly k aplikaci přilinkovány. TCustomResourcesTranslator = class ( TLMList ) Unit: LangManCore;

4.5.1

Metody tříd T(Uni)ResourcesTranslator(X)

4.5.1.1

Procedure RegisterResourceString(const Resource: String; InDesignLanguage: String = ' '); Pomocí této metody lze zaregistrovat k lokalizaci libovolný řetězec z resources. V parametru Resource je nutné předat obsah příslušného zdroje, NE jeho jméno nebo identifikátor. Ve druhém parametru může být předána lokalizovaná podoba v jazyce návrhu aplikace, pokud se liší od jazyka, ve kterém je řetězec definován. Tím se okamžitě po zavolání této metody změní skutečný obsah řetězce Resource do podoby InDesignLanguage, pokud nebyl předán prázdný řetězec. Komponentu

HW & SW Development

www.regulace.org

41/67

LangMan 2.0 T(Uni)ResourcesTranslator(X) lze tedy použít i pro jednoduché přepsání libovolného řetězce v resources. Tato metoda nijak nekontroluje zda daný zdroj opravdu existuje a funguje i bez napojení komponenty na jazykový engine.

4.5.2

Vlastnosti tříd T(Uni)ResourcesTranslator(X)

4.5.2.1

Property OriginalLanguage: String Této vlastnosti je nutné přiřadit ISO kód nebo název jazyka, ve kterém jsou v programu definovány resourcestrings, registrované k lokalizacím prostřednictvím této komponenty. V případě, že jsou v programu definovány resourcestrings v různých jazycích, je nutné je registrovat vždy odděleně v samostatných komponentách T(Uni)ResourcesTranslator(X). Je to z toho důvodu, aby byly ve správných jazycích použity správné varianty všech registrovaných řetězců. Ve vlastním zájmu nezapomeňte správně nastavit tuto vlastnost. Knihovny standardních řetězců Delphi jsou definovány pouze pro tyto jazyky: en – angličtina, de – němčina, fr – francouzština a ja – japonština.

4.5.2.2

Property RegisteredStrings: Integer; (read-only) Tato vlastnost vrací celkový počet zaregistrovaných řetězců. Za běhu programu je pouze pro čtení, ale při návrhu v IDE lze přes ni také otevřít editor (registrátor) pro resourcestrings popsaný v kapitole 2.3.2. Poznámka: Nezobrazuje-li se tlačítko pro editaci, zkontrolujte si zda jste nezapomněli přeložit a nainstalovat pro platformu 32-bit Windows balíček LangMan_Registrator, který je dodáván společně s ostatními balíčky komponent LangMan edice Ultimate. Případně ověřte, zda je tento balíček povolen ve správci instalovaných komponent.

HW & SW Development

www.regulace.org

42/67

LangMan 2.0

4.6

TLexicon = class ( TLMList ) Unit: LangManCore; Společná třída všech lexikonů. Implementuje základní funkcionalitu pro lexikony.

4.6.1

Metody třídy TLexicon

4.6.1.1

Function CompleteString(const Str: string): string; Funkce CompleteString vrací zadaný řetězec Str, u něhož jsou odkazy na řetězce lexikonu nahrazeny řetězci lexikonu v aktuálně zvoleném jazyce. Tyto odkazy generuje níže popsaná vlastnost Link, případně SLink. Tato funkce najde své využití pro překlad dynamicky generovaných rozsáhlých textů. Místo konkrétních řetězců v konkrétním jazyce použijete při generování textu pouze odkazy na příslušné řetězce lexikonu a až v okamžiku výstupu na obrazovku, tiskárnu apod. řetězec s odkazy převedete do čitelné podoby v požadovaném jazyce. Tuto funkci využívá také nevizuální objekt balíčku LangMan TLangManStrings (viz popis třídy TLangManStrings) pro dynamický překlad objektů, odvozených od TStrings. Např. TMemo, TRichEdit apod.

4.6.2

Vlastnosti třídy TLexicon

4.6.2.1

Property Link [Index: Integer]: string; (read-only) Vlastnost Link vrací odkaz typu string na řetězec lexikonu na pozici Index. Takto získaný odkaz můžete vkládat do textu při dynamickém vytváření nějakých výpisů, logů apod. Pomocí funkce CompleteString (viz výše) pak převedete vzniklý text s odkazy do čitelné podoby v aktuálně zvoleném jazyce. Více o využití této funkce najdete také v popisu nevizuálního objektu TLangManStrings nebo u popisu vizuální komponenty TLangManRichEdit.

HW & SW Development

www.regulace.org

43/67

LangMan 2.0

4.7

TDesignedLexicon(X) = class ( TCustomDesignedLexicon ) TUniDesignedLexicon = class ( TDesignedLexicon ) Unit: LangManComp(X/Uni); Kromě automatického překládání statických komponent, umístěných na formulářích, jsou v programech často zapotřebí řetězce pro různá dynamicky vytvářená dialogová okna, hlášení apod. K těmto účelům slouží lexikony, ve kterých lze potřebné řetězce nadefinovat. Ty jsou poté automaticky překládány, takže při čtení konkrétního záznamu je tento čten vždy už v příslušném jazyce. Řetězce v T(Uni)DesignedLexicon(X) se definují pomocí editoru přímo v object inspektoru. TCustomDesignedLexicon = class ( TLexicon ) Unit: LangManCore;

4.7.1

Metody tříd T(Uni)DesignedLexicon(X)

4.7.1.1

Function CreateItem( Text: string ): Integer; Funkce CreateItem slouží pro přidání řetězce Text do lexikonu za běhu programu. Návratovou hodnotou je pozice (Index) nového řetězce v lexikonu.

4.7.2

Vlastnosti tříd T(Uni)DesignedLexicon(X)

4.7.2.1

Property Item [Index: Integer]: string; (read-only) Vlastnost Item vrací řetězec z pozice Index v aktuálně zvoleném jazyce.

4.7.2.2

Property Items : TStringList Vlastnost Items slouží pro editaci položek lexikonu v object inspectoru. Řetězce je nutné do tohoto seznamu vkládat v jazyce návrhu, který odpovídá DesignLanguageName přiřazeného enginu. V programu lze potom tyto řetězce číst už v konkrétním zvoleném jazyce pomocí vlastnosti Item.

HW & SW Development

www.regulace.org

44/67

LangMan 2.0

4.8

TProgrammableLexicon(X) = class ( TCustomProgrammableLexicon ) TUniProgrammableLexicon = class( TProgrammableLexicon ) Unit: LangManComp(X/Uni); Položky programovatelného lexikonu mohou být na rozdíl od DesignedLexiconu definovány až ve zdrojovém kódu programu například v metodě události OnInitialization. Tento lexikon najde své uplatnění v případech, kdy jsou jazykové řetězce známy až při běhu programu. Podmínkou při pořizování překladu je, aby se v lexikonu před editací jazyka nacházely všechny položky, které mají být automaticky překládány, jinak nebude možné provést jejich lokalizaci do jiných jazyků. Z toho také vyplívá skutečnost, že položky tohoto lexikonu nebudou viditelné v editoru jazyků, spuštěného při návrhu aplikace z prostředí Delphi. TCustomProgrammableLexicon = class ( TLexicon ) Unit: LangManCore;

4.8.1

Metody tříd T(Uni)ProgrammableLexicon(X)

4.8.1.1

Procedure DefineItem(ItemNr: Word; Text: string); Tato metoda zavede řetězec Text do lexikonu na pozici ItemNr. Pokud se už na dané pozici vyskytuje jiný řetězec, bude přepsán řetězcem novým.

4.8.2

Vlastnosti tříd T(Uni)ProgrammableLexicon(X)

4.8.2.1

Property Item [Index: Integer]: string; (read-only) Vlastnost Item vrací řetězec z pozice Index v aktuálně zvoleném jazyce.

4.8.3

Události tříd T(Uni)ProgrammableLexicon(X)

4.8.3.1

OnInitialization: TNotifyEvent Tato událost je volána při inicializaci lexikonu. V metodě této události je možné definovat položky lexikonu.

HW & SW Development

www.regulace.org

45/67

LangMan 2.0

4.9

TInlineLexicon(X) = class ( TCustomInlineLexicon ) TUniInlineLexicon = class ( TInlineLexicon ) Unit: LangManComp(X/Uni);

(pouze v edici Ultimate)

Položky tohoto lexikonu definujete doslova inline přímo v kódu programu pomocí vlastnosti Loc['text'] nebo u odkazu pomocí vlastnosti SLink['text']. Inline lexikon se od předchozích liší tím, že nepoužívá indexy, ale přímo samotné řetězce zapsané ve výchozím jazyku návrhu. Položky tohoto lexikonu ale NEmusíte před editací jazyka inicializovat (jako je tomu u ProgrammableLexiconu), protože se do překladače zavedou samy už při kompilaci aplikace. Nespornou výhodou tohoto lexikonu je samozřejmě to, že se nemusíte vázat na nějaké indexy a neustále si pamatovat který řetězec máte pod kterým indexem, ale vlastně jen použijete řetězec přímo v kódu programu a nic dál neřešíte. Jedinou podmínkou je pouze nutnost použít v hranatých závorkách vlastností Loc a SLink přímo nepojmenovaný konstantní řetězec v uvozovkách. Nelze předávat proměnnou ani nepřímo definovanou konstantu. V těchto případech by byla nutná inicializace takových záznamů ještě před editací jazyka. TCustomInlineLexicon = class ( TLexicon ) Unit: TLangManCore;

4.9.1

Vlastnosti tříd T(Uni)InlineLexicon(X)

4.9.1.1

Property Item [Index: Integer]: string; (read-only) Vlastnost Item vrací řetězec z pozice Index v aktuálně zvoleném jazyce.

4.9.1.2

Property Loc [LocalizableString: String]: string; (read-only) Vlastnost Loc vrací předaný řetězec v aktuálně zvoleném jazyce. Pro správnou funkci musí být textový parametr LocalizableString (originální znění parametru v jazyce návrhu) definován přímo pomocí uvozovek, tedy ve formě Loc['libovolný text v jazyce návrhu'].

4.9.1.3

Property SLink [LocalizableString: String]: string; (read-only) Vlastnost SLink vrací (podobně jako vlastnost Link) odkaz typu string na lokalizovaný řetězec lexikonu. Ovšem parametrem není číselná adresa položky v lexikonu, nýbrž přímo zadané originální znění řetězce, na který link odkazuje. Takto získaný odkaz můžete vložit do textu při dynamickém vytváření nějakých výpisů, logů apod. Pomocí funkce CompleteString (viz kapitola 4.6.1.1) pak převedete vzniklý text s odkazy do čitelné podoby v aktuálně zvoleném jazyce. Více o využití této funkce najdete také v popisu nevizuálního objektu TLangManStrings nebo u popisu vizuální komponenty TLangManRichEdit, u které lze tento typ odkazu také použít.

HW & SW Development

www.regulace.org

46/67

LangMan 2.0

4.10

TLangCombo(X) = class ( TCustomComboBox ) TUniLangCombo = class ( TUniCustomComboBox ) Unit: LangManComp(X/Uni); Jedná se o standardní ComboBox, který je po přiřazení k enginu automaticky naplněn existujícími jazyky. Volbou jazyka dojde k přeložení všech klientů a lexikonů.

4.10.1

Vlastnosti tříd T(Uni)LangCombo(X)

4.10.1.1

Property LangManEngine: T(Uni)LangManEngine(X) Této vlastnosti musí být přiřazen adekvátní engine, se kterým má být combo box propojen.

4.10.2

Vlastnosti třídy T(Uni)LangCombo

4.10.2.1

Property StyleCombo: TLangComboStyle Tato vlastnost je obdobou vlastnosti Style ComboBoxu s tím rozdílem, že zde nelze nastavit styl csDropDown.

4.10.3

Události tříd T(Uni)LangCombo(X)

4.10.3.1

OnChangeLanguage: TNotifyEvent Událost volaná po změně jazyka.

HW & SW Development

www.regulace.org

47/67

LangMan 2.0

4.11

TLangFlagsCombo = class ( TCustomComboBoxEx ) Unit: LangManComp; TLangFlagsCombo je vylepšený ComboBox, který má před názvy jazyků navíc zobrazeny i příslušné vlajky (ikony jazyků). Jinak je funkce obdobná jako u TLangCombo.

4.11.1

Vlastnosti třídy TLangFlagsCombo

4.11.1.1

property LangManEngine: TLangManEngine Této vlastnosti musí být přiřazen TLangManEngine, se kterým má být TLangFlagsCombo propojen.

4.11.2

Události třídy TLangFlagsCombo

4.11.2.1

OnChangeLanguage: TNotifyEvent Událost volaná po změně jazyka.

HW & SW Development

www.regulace.org

48/67

LangMan 2.0

4.12

TLangFlag(X) = class ( TImage ) TUniLangFlag = class ( TUniImage ) Unit: TLangManComp(X/Uni); Tyto vizuální komponenty jsou téměř shodné s TImage (TUniIamge). Navíc je pouze vlastnost LangManEngine pro spojení s enginem, jehož vlajka (ikona) aktuálně zvoleného jazyka má být komponentou zobrazena.

4.12.1

Vlastnosti tříd T(Uni)LangFlag(X)

4.12.1.1

Property LangManEngine: T(Uni)LangManEngine(X) Této vlastnosti musí být přiřazen adekvátní engine, se kterým má být T(Uni)LangFlag(X) propojena.

HW & SW Development

www.regulace.org

49/67

LangMan 2.0

4.13

TValuedLabel = class ( TCustomLabel ) TUniValuedLabel = class ( TUniLabel ) TValuedLabelX = class ( TLabel ) Unit: LangManCtrls(X), LangManCompUni; T(Uni)ValuedLabel(X) jsou doplňkové komponenty vycházející ze standardních komponent TLabel (TUniLabel). Místo vlastnosti Caption (Text) mají vlastnosti ValueName, ValueSeparator, ValueSpaces a Value. Tyto jsou ve výsledném zobrazení pospojovány, přičemž ValueSpaces udává počet mezer za ValueSeparator. Trik spočívá v tom, že LangMan u této komponenty překládá, kromě Hint u VCL verze, pouze vlastnost ValueName. V programu potom stačí zapisovat pouze hodnotu „Value“. Výsledný řetězec, který je zobrazen touto vizuální komponentou má následující formát: 'ValueName' + 'ValueSeparator' + ValueSpaces x ' ' + 'Value'.

4.13.1

Vlastnosti tříd T(Uni)ValuedLabel(X)

4.13.1.1

Property Value: TCaption Této vlastnosti může být přiřazen libovolný řetězec.

4.13.1.2

Property ValueName: TCaption Do překladů je zahrnována pouze tato vlastnost, které by měl být přiřazen název hodnoty Value v jazyce návrhu.

4.13.1.3

Property ValueSeparator : string Této vlastnosti může být přiřazen libovolný řetězec, který má být ve výsledku vložen mezi ValueName a Value.

4.13.1.4

Property ValueSpaces : byte Tato vlastnost udává počet mezer mezi ValueSeparator a Value.

HW & SW Development

www.regulace.org

50/67

LangMan 2.0

4.14

TLangManStrings = class ( TStringList ) Unit: LangManCore; Třída TLangManStrings slouží pro snadný dynamický překlad objektů, odvozených od třídy TStrings, například různých seznamů, celých rozsáhlých textových souborů, vizuálních komponent TMemo, TRichEdit apod. V okamžiku, kdy v programu vypisujete například nějaký log do komponenty TMemo a chcete, aby po změně jazyka byl tento, za běhu programu vytvořený, výpis přeložen do zvoleného jazyka, poslouží vám k tomu objekt TLangManStrings, který se o vše postará za vás.

4.14.1

Konstruktor třídy TLangManStrings

4.14.1.1

Constructor Create(ControlledStrings: TStrings; Lexicon: TLexicon); Při vytváření objektu třídy TLangManStrings je třeba v parametrech konstruktoru předat následující: V ControlledStrings musí být předán objekt odvozený od TStrings, který má být novým objektem spravován – z funkčního hlediska se jedná o nahrazení původního objektu nově vytvořeným objektem. Přičemž původní objekt samozřejmě existuje dál, ale slouží pouze pro výstup přeloženého textu ve zvoleném jazyce, kdežto u nového objektu se pracuje pouze z odkazy na řetězce lexikonu. V parametru Lexicon musí být předán lexikon, jehož řetězce mají být pro překlad textů použity. Od chvíle zavolání tohoto konstruktoru by už v programu nemělo být k textovému obsahu původního objektu typu TStrings přistupováno jinak než prostřednictvím tohoto objektu, který je odvozen od třídy TStringList, která je také potomkem třídy TStrings. Jeho metody Add, AddObject, Insert, InsertObject, Delete, Clear, Exchange, Sort, CustomSort mají stejnou funkci a stejný vliv na původní objekt jako by se jednalo o metody samotného objektu.

4.14.2

Metody třídy TLangManStrings

4.14.2.1

Procedure Translate; Tato procedura provede znovu vypsání celého textu spravovaného objektu v právě zvoleném jazyce. Po změně jazyka příslušného enginu je tato metoda zavolána automaticky, ale může být zapotřebí například v případě, kdy za běhu programu změníte nějakou položku souvisejícího lexikonu a chcete, aby se změna okamžitě promítla i do příslušného textu.

HW & SW Development

www.regulace.org

51/67

LangMan 2.0

4.15

TLangManRichEdit = class ( TCustomRichEdit ) Unit: LangManComp; Jedná se o vizuální komponentu vyvinutou pro stejný účel jako je třída TLangManStrings. Tedy pro generování různých výpisů, logů, protokolů apod. ale zde navíc s možností text formátovat. Můžete vkládat řetězce s různými typy písma, různou velikostí znaků, barev, stylů atd. Přičemž jazyk výsledného dokumentu odpovídá právě zvolenému jazyku a při změně jazyka se celý dokument automaticky přeloží. TLangManRichEdit má vlastnost ReadOnly skrytou a na pevno nastavenou na hodnotu true. Není přítomna ani vlastnost Lines a veškeré zapisování a úpravy textu mají být prováděny pouze pomocí níže popsaných metod.

4.15.1

Metody třídy TLangManRichEdit

4.15.1.1

Procedure AssignStyles(LMStringStyles: TLMStringStyles); Lze použít pro přímé přiřazení pole typu TLMStringStyles s definicemi všech stylů písma pro váš dokument. Typ TLMStringStyles je definován následovně: TLMStringStyles = array of TLMStringStyle;

kde TLMStringStyle = record Color: TColor; Font: TFontName; Charset: TFontCharset; Style: TFontStyles; Size: Integer; Pitch: TFontPitch; end;

4.15.1.2

Procedure ClearStyles; Maže pole s definicemi stylů písma.

4.15.1.3

Function GetStyles: TLMStringStyles; Vrací pole definic stylů písma.

4.15.1.4

Function StylesCount: Integer; Vrací počet definovaných stylů písma.

HW & SW Development

www.regulace.org

52/67

LangMan 2.0

4.15.1.5

Function SetStyle(Style: TFontStyles; Size: Integer = 0; Color: TColor = clDefault; FontName: TFontName = ''; Charset: TFontCharset = DEFAULT_CHARSET; Pitch: TFontPitch = fpDefault; StyleIndex: ShortInt = -1): Integer; Nastavuje styl písma. Každý styl písma vychází z nastavení vlastnosti Font. Kromě prvního parametru Style jsou všechny ostatní parametry nepovinné. Zadání výchozích hodnot parametrů znamená, že se použije příslušná hodnota z vlastnosti Font. Tedy pro Size=0 bude pro příslušný styl písma použita hodnota Font.Size atd. Posledním parametrem je index stylu. Pro výchozí hodnotu -1 se tento styl přidá jako nový na konec pole stylů. Pokud bude parametr nastaven na hodnotu indexu již existujícího stylu, provede se pouze modifikace příslušného stylu. Funkce vrací index toho stylu, který byl zavoláním funkce nastaven.

4.15.1.6

Function Format(const Text: String; StyleIndex: ShortInt): String; Tato funkce formátuje řetězec Text dle přednastaveného stylu na indexu StyleIndex. Výsledek této funkce může být následně použit pro zapsání do dokumentu pomocí metod Write, WriteLn, RewriteLine a InsertLine.

4.15.1.7

Procedure Write(const Text: String; StyleIndex: ShortInt = -1); Zapisuje řetězec Text na konec dokumentu. Pokud v parametru StyleIndex předáte proceduře nezápornou hodnotu, bude pro neformátované části řetězce použit vybraný styl. Další dílčí úseky řetězce Text můžou mít samozřejmě nastaveny i jiné styly pomocí funkce Format. Poznámka: Funkce Format může být volána i vnořeně pro jednotlivé podčásti řetězců. Například výsledek následujícího kódu With LangManRichEdit1 do Write('Ahoj ' +Format('celý ' +Format('světe',3) + '!',2),1);

může vypadat třeba takto: Ahoj celý světe!

4.15.1.8

Procedure WriteLn(const Text: String; StyleIndex: ShortInt = -1); Prakticky stejné jako Write, pouze je text zakončen skokem na nový řádek.

4.15.1.9

Procedure NextLine; Zapíše pouze skok na nový řádek.

4.15.1.10 Procedure Clear; Maže celý dokument. HW & SW Development

www.regulace.org

53/67

LangMan 2.0

4.15.1.11 Function LinesCount: Integer; Vrací počet řádků dokumentu. Na hodnotu nemá vliv automatické zalamování při WordWrap = true.

4.15.1.12 Function ReadLineText(LineIndex: Integer): String; Vrací řetězec na řádku LineIndex. Pro první řádek je LineIndex = 0. Automaticky zalomený řádek je vrácen celý a je počítán jako jeden řádek.

4.15.1.13 Function ReadLineFText(LineIndex: Integer): String; Vrací řádek LineIndex v surovém interním formátu včetně pomocných znaků formátování a odkazů na lexikon. Tato data jsou vhodná například pro úpravu a následné vrácení na příslušný řádek metodou RewriteLine.

4.15.1.14 Procedure DeleteLine(LineIndex: Integer); Vymaže řádek s indexem LineIndex. První řádek má vždy index 0.

4.15.1.15 Procedure RewriteLine(LineIndex: Integer; const Text: String; StyleIndex: ShortInt = -1); Nahradí řádek LineIndex novým řetězcem Text. Stejně jako u metod Write, WriteLn lze definovat i styl pro daný řádek.

4.15.1.16 Procedure InsertLine(LineIndex: Integer; const Text: String; StyleIndex: ShortInt = -1); Na řádek LineIndex vloží nový řetězec Text. Stejně jako u Write, WrieLn, RewriteLine lze definovat styl (StyleIndex) pro daný řádek.

4.15.1.17 Procedure Translate; Tato procedura provede znovu vypsání celého dokumentu v právě zvoleném jazyce. Po změně jazyka příslušného enginu je tato metoda zavolána automaticky, ale může být zapotřebí například v případě, kdy za běhu programu změníte nějakou položku lexikonu AssignedLexicon a chcete, aby se změna okamžitě promítla i v dokumentu.

4.15.1.18 Procedure LoadFromFile(const SourceFile: TFileName; Encoding: TEncoding); Načte text komponenty ze souboru. Tento text může obsahovat formátovací značky a odkazy na lexikon, takže se ve výsledku dokument zobrazí ve zvoleném jazyce. Encoding je nepovinný parametr, kterým lze určit kódovaní zdrojového souboru.

HW & SW Development

www.regulace.org

54/67

LangMan 2.0

4.15.1.19 Procedure LoadFromStream(SourceStream: TStream; Encoding: TEncoding); Načte text komponenty ze streamu SourceStream. Tento text může obsahovat formátovací značky a odkazy na lexikon, takže se ve výsledku dokument zobrazí ve zvoleném jazyce. Encoding je nepovinný parametr, kterým lze určit kódovaní zdrojového textu.

4.15.1.20 Procedure SaveRichTextToFile(const DestinationFile: TFileName; Encoding: TEncoding); Uloží celý dokument ve formátu RTF do souboru DestinationFile s kódováním dle parametru Encoding. Tento parametr je nepovinný.

4.15.1.21 Procedure SaveRichTextToStream(DestinationStream: TStream; Encoding: TEncoding); Uloží celý dokument ve formátu RTF do streamu DestinationStream s kódováním dle parametru Encoding. Tento parametr je nepovinný.

4.15.1.22 Procedure SaveEncodedFormToFile(const DestinationFile: TFileName; Encoding: TEncoding); Uloží celý dokument v prostém textu s formátovacími značkami a odkazy na řetězce lexikonu do souboru DestinationFile s kódováním dle parametru Encoding. Parametr Encoding je nepovinný. Soubor uložený touto metodou, lze do komponenty opět načíst pomocí metody LoadFromFile se zachováním funkčnosti automatických překladů.

4.15.1.23 Procedure SaveEncodedFormToStream(DestinationStream: TStream; Encoding: TEncoding); Zapíše celý dokument v prostém textu s formátovacími značkami a odkazy na řetězce lexikonu do streamu DestinationStream s kódováním dle parametru Encoding. Parametr Encoding je nepovinný. Stejné data streamu lze použít pro zpětné načtení dokumentu do komponenty pomocí metody LoadFromStream. Formátování a funkčnost automatických překladů dokumentu tak bude plně zachována.

4.15.2

Vlastnosti třídy TLangManRichEdit

4.15.2.1

Property AssignedLexicon: TLexicon Této vlastnosti je nutné přiřadit lexikon, jehož řetězce budou používány při tvorbě dokumentu. Pouze řetězce vložené do dokumentu pomocí vlastnosti Link nebo SLink zvoleného lexikonu nebo přímo vlastností Link nebo SLink této komponenty budou automaticky vloženy ve zvoleném jazyce a při změně jazyka automaticky v dokumentu přepsány.

HW & SW Development

www.regulace.org

55/67

LangMan 2.0

4.15.2.2

Property AutoFont: Boolean Nastavením této vlastnosti na hodnotu false, můžete vypnout automatickou změnu fontu. Tato funkce je standardně zapnutá i u komponenty TRichEdit. Některé české znaky s diakritikou ovšem způsobují nežádoucí automatickou změnu fontu i když to ve skutečnosti není zapotřebí. Proto se tvůrce komponent LangMan rozhodl přidat vlastnost AutoFont, která umožní snadno tuto nežádoucí funkci vypnout.

4.15.2.3

Property Link [Index: Integer]: string; (read-only) Vlastnost Link vrací odkaz typu string na řetězec Index lexikonu AssignedLexicon. Po zapsání takto získaného odkazu do dokumentu dojde k vypsání příslušného řetězce lexikonu v aktuálně zvoleném jazyce a po přepnutí jazyka se všechny takto vložené úseky textu automaticky přepíší v nově zvoleném jazyce. Následující příklad demonstruje vložení řetězce č.1 z asociovaného lexikonu do dokumentu této komponenty. Předpokladem je správně nastavená vlastnost AssignedLexicon. With LangManRichEdit1 do Write(Link[1]);

4.15.2.4

Property SLink [LocalizableString: String]: string; (read-only) (podporováno pouze v edici Ultimate) Vlastnost Slink vrací odkaz typu string na lokalizovaný řetězec lexikonu AssignedLexicon. Ovšem parametrem není číselná adresa položky v lexikonu, nýbrž přímo zadané originální znění řetězce, na který link odkazuje. Po zapsání takto získaného odkazu do dokumentu dojde k vypsání příslušného řetězce lexikonu v aktuálně zvoleném jazyce a po přepnutí jazyka se všechny takto vložené úseky textu automaticky přepíší v nově zvoleném jazyce. Následující příklad demonstruje vložení lokalizovatelného řetězce 'Ahoj světe!' z asociovaného lexikonu do dokumentu této komponenty. Předpokladem je správně nastavená vlastnost AssignedLexicon, do které musí být přiřazen libovolný TInlineLexicon. With LangManRichEdit1 do Write(SLink['Ahoj světe!']);

Poznámka: Není vůbec důležité, aby se použitý řetězec, v tomto případě 'Ahoj světe!', vyskytoval v lexikonu ještě před vygenerováním odkazu, protože vlastnost SLink jej zároveň definuje stejně jako vlastnost Loc příslušného lexikonu. Může se tedy vždy jednat o unikátní jinde v programu dosud nepoužitý řetězec.

HW & SW Development

www.regulace.org

56/67

LangMan 2.0

5

Jazykové soubory v resources T(Uni)LangManEngine(X) standardně hledá jazykové soubory podle pravidel definovaných vlastnostmi LangFileExtension, LangFileSignature a LangSubdirectory v souborovém systému zařízení / počítače. Chcete-li mít jazykové soubory v resources vaší aplikace, není to žádný problém, ale aby je engine viděl, musíte vložit ID těchto souborů do seznamu LangResources (viz kapitola 4.1.2.15). Na následujících řádcích uvádím jeden z možných postupů, jak přidat jazykové soubory do resources aplikace. V IDE Delphi přes menu Project / Resources... otevřete dialogové okno pro editaci zdrojů (resources), které mají být přilinkovány do souboru aplikace.

Obr. 5.1: Dialogové okno pro editaci zdrojů (resources) Pomocí tlačítka přidat (Add...), vložte platný jazykový soubor a v poli Resource Identifier zadejte svůj název pro přidaný jazyk. Tento název volte pokud možno výstižně a s vědomím, že v případě editace interního jazyka uživatelem (pokud je to dovoleno nastavením LangResourcesAllowEdit na true), bude tento jazyk exportován na disk pod stejným názvem a s koncovkou přidělenou dle vlastnosti LangFileExtension příslušného jazykového enginu. Resource Type ponechejte na RCData. Po kliknutí na tlačítko OK a sestavení programu (Build) se popsaným způsobem vybrané jazykové soubory přilinkují do souboru vaší aplikace. Při každém dalším sestavení programu se použije vždy aktuální obsah jazykových souborů, takže se nemusíte obávat žádných starostí o neustálé importování jazykových souborů po každé změně – nic takového. Na způsobu tvorby a úprav jazykových souborů se nic nemění. Kdykoli můžete použít vestavěný editor jazyků LangMan a můžete se spolehnout, že hned při následné kompilaci bude přilinkována vždy aktuální verze. HW & SW Development

www.regulace.org

57/67

LangMan 2.0 Nyní je ale ještě zapotřebí zadat příslušnému jazykovému enginu (T(Uni)LangManEngine(X)) do vlastnosti LangResources, které interní jazyky z resources má načítat. Po rozkliknutí LangResources v object inspectoru se zobrazí String List Editor. Na jednotlivé řádky nyní vypište názvy interních jazykových souborů (Resource Identifier), které jste ke každému jazykovému souboru přiřadily v dialogovém okně Resources.

6

Dynamické generování textů Generuje-li váš program za chodu nějaký výpis, log soubor apod., může do tohoto souboru vkládat příslušné řetězce z lexikonu, který je vypisuje vždy v aktuálně zvoleném jazyce. Tento postup má ale jednu slabinu. Při následné změně jazyka, zůstane dosavadní obsah výpisu v původním jazyce, zatímco pokračování výpisu bude v jazyce změněném. Za normálních okolností asi nemá uživatel programu žádný důvod volit jiný jazyk, než ten který si zvolil na začátku a který mu nejlépe vyhovuje. Jsou ale případy, kdy je změna jazyka za chodu programu žádoucí a je i žádoucí, aby se změnil jazyk u celého výpisu od začátku ne jenom u části, která v čase následuje. Pro tyto případy byla vytvořena třída TLangManStrings, vizuální komponenta TLangManRichEdit a do lexikonů byla přidána metoda CompleteString a vlastnosti Link a SLink (T(Uni)InlineLexicon(X)). Příklad použití třídy TLangManStrings s komponentou TMemo: Máte-li do své aplikace například vloženou vizuální komponentu TMemo, do které program generuje za chodu nějaký výpis, a požadujete, aby se jazyk celého výpisu dal v kterémkoli okamžiku změnit, použijte k tomu třídu TLangManStrings. Postup je následující: V rutině události OnCreate formuláře vytvoříte objekt např. Memo: Memo := TLangManStrings.Create(Memo1.Lines, MainLexicon);

kde Memo1 je vizuální komponenta TMemo a MainLexicon je jazykový lexikon (T(Uni)DesignedLexicon(X), T(Uni)ProgrammableLexicon(X) nebo T(Uni)InlineLexicon(X)), který obsahuje všechny potřebné jazykové řetězce pro dynamické generování vašeho výpisu (to neplatí pro T(Uni)InlineLexicon(X), protože se při vložení odkazu pomocí SLink příslušný řetězec do lexikonu zavede automaticky). Tento krok lze považovat za jakési nahrazení vlastnosti Memo1.Lines novým objektem Memo. Takže od této chvíle musíte veškerý textový obsah vlastnosti Lines měnit výhradně prostřednictvím nového objektu Memo třídy TLangManStrings! Jakékoli manipulace s řetězci ve vlastnosti Memo1.Lines tedy provádíte výhradně přes objekt Memo a to úplně stejně, jako byste pracovali přímo s Memo1.Lines. Například nový řádek vložíte následovně: Memo.Add('Text nového řádku'); HW & SW Development

www.regulace.org

58/67

LangMan 2.0

Výsledkem bude přidání řetězce 'Text nového řádku' na nový řádek vlastnosti Memo1.Lines. Nyní se dostáváme k tvorbě přeložitelného textu pomocí lexikonu MainLexicon, který byl v konstruktoru objektu Memo předán jako druhý parametr. Takže například pokud se na položce s indexem 2 lexikonu MainLexicon nachází řetězec 'Můj text' (aktuální jazyk je čeština), mohli byste vložit tento řetězec přímo následujícím způsobem: Memo.Add(MainLexicon.Item[2]);

Efekt by byl úplně stejný jako v tomto případě: Memo.Add('Můj text');

Jedinou výhodou by bylo, že je právě vložený řetězec v aktuálně zvoleném jazyce. V okamžiku, kdy by ale uživatel změnil jazyk u příslušného enginu, již vložený text by se nezměnil. Pokud byste ale řetězec vložily následujícím způsobem pomocí odkazu Link (pokud MainLexicon není T(Uni)InlineLexicon(X)) nebo SLink (pokud je MainLexicon T(Uni)InlineLexicon(X)): Memo.Add(Memo.Link[2]); Memo.Add(Memo.SLink['Můj text']);

bude v daném okamžiku v komponentě Memo1 na novém řádku vypsán sice stejný text jako v předešlém případě, ale s tím rozdílem, že pokud by uživatel změnil jazyk, převede se automaticky text na posledním řádku Memo1.Lines také do nově zvoleného jazyka. Stejně jako metoda Add fungují bez rozdílu od původních metod třídy TStrings i další metody jako jsou AddObject, Insert, InsertObject, Delete, Clear, Exchange, Sort a CustomSort třídy TLangManStrings. Pouze je nutné dávat pozor na to, že výsledné přidělení indexů řetězcům vlastnosti Lines komponenty TMemo se může od objektu třídy TLangManStrings lišit. Například, budete-li mít nastaveno u komponenty TMemo automatické zalamování řádků, může se tím počet řádků o počet zalomení zvýšit oproti počtu řádků v TLangManStrings. I proto je důležité opravdu dbát na to, aby se k textu původního objektu přistupovalo pouze přes náhradní objekt typu TLangManStrings. Odměnou je velmi efektní na čase nezávislá možnost změny jazyka u rozsáhlých textů TStrings a opět, jak je tomu u komponent LangMan zvykem, bez nároků na čas programátora, který by jinak musel pro dosažení stejného výsledku jít mnohem složitější a pracnější cestou.

HW & SW Development

www.regulace.org

59/67

LangMan 2.0

7

Tipy a triky

7.1

Rychlá editace položek DesignedLexiconu Dvojklikem na komponentě T(Uni)DesignedLexicon(X) v IDE Delphi snadno a rychle otevřete editor položek vlastnosti Items.

7.2

Vkládání zvláštních znaků LangMan dovoluje používání všech znaků sady Unicode (od Delphi 2009) včetně speciálních znaků s číselnou hodnotou menší než 32. Pokud potřebný znak nejde v editoru zadat přímo prostřednictvím klávesnice, lze vložit jakýkoli znak (kromě nulového) pomocí zástupného kódu následujícím způsobem: '#code'

kde code je číselný kód požadovaného znaku v desítkové soustavě. Dovolené je i zřetězení několika po sobě jdoucích speciálních znaků. Třeba kód pro nový řádek, může vypadat následovně: '#13#10'

Důležitá je jednoduchá uvozovka alespoň před prvním znakem #. Potřebujete-li, aby se v řetězci vyskytovala formule ve tvaru '#číslo, aniž by se automaticky vložil příslušný znak, nahraďte # zástupným kódem '#35' . Například „xx'#1” lze napsat takto: xx''#35'1

7.3

Integrace LangMana na formulář za běhu programu Na jakýkoli formulář (TForm, TFrame, TDataModule) nebo klidně na libovolnou komponentu třídy TComponent nebo potomka této třídy, lze komponentu T(Uni)LangManClient(X) vložit a aktivovat i za běhu programu. Je to vhodné zejména u formulářů třetích stran do jejichž kódu nemůžeme zasahovat například proto, že ani nemáme zdrojové kódy. Například pro lokalizaci formuláře Form enginem LangMan stačí zavolat: TLangManClient.Create(Form).LangManEngine := LangMan;

V první fázi dojde k vytvoření komponenty TLangManClient, která se následně vloží na formulář Form a nakonec se klient aktivuje přiřazením existujícího enginu LangMan. Pokud by nevyhovovalo výchozí nastavení HW & SW Development

www.regulace.org

60/67

LangMan 2.0 klienta a chtěli byste například povolit globální lexikon a změnit výběr vlastností, které se mají lokalizovat, je lepší to udělat ještě před přiřazením enginu například následovně: with TLangManClient.Create(Form) do begin GlobalLexicon := true; Name := 'LMClient'; TransStringProp := TransStringProp – [pnText]; LangManEngine := LangMan; // activate end;

7.4

Nevhodná výchozí konfigurace projektů U novějších Delphi je ve výchozím nastavení projektu zvolen samostatný cílový adresář pro sestavení aplikace v konfiguraci Debug a samostatný pro konfiguraci Release. V řadě případů má toto rozpoložení výhody a někdy jej lze preferovat i s použitím komponent LangMan. Je nutné si ale uvědomit, že případná relativní cesta (i prázdný řetězec je relativní cesta), zadaná ve vlastnosti LangSubdirectory enginu, bude při takovém nastavení ve výsledku generovat rozdílné umístění i pro jazykové soubory v jednotlivých konfiguracích. Někdy stačí mít aktuální jazykové soubory například jen u konfigurace Release a v ostatních konfiguracích je aktualizovat pouze občas nebo vůbec. Často bude ale žádoucí (už jen kvůli pořádku), aby projekt ve všech konfiguracích používal stejné jazykové soubory. Pokud je to i váš případ, nabízí se hned několik řešení z nichž si můžete vybrat:

7.5

•

Nastavit stejný cílový adresář pro všechny konfigurace, nebo

•

použít absolutní cestu v LangSubdirectory, nebo

•

s použitím podmínečného překladu přepsat programově při neRelease konfiguraci cestu v LangSubdirectory, nebo

•

používat pouze jednu konfiguraci projektu a podle aktuálních potřeb ji měnit, nebo

•

s použitím podmínečného překladu povolit jazykový editor pouze v jedné konfiguraci a/nebo

•

po každé úpravě jazykových souborů je automaticky synchronizovat.

Component Name Editor Všimněte si, že jsou v jazykových souborech data často zapsána s názvy jednotlivých komponent, ke kterým příslušné řetězce patří. Při změně názvu lokalizované komponenty může být proto zapotřebí upravit odpovídajícím způsobem také jazykové soubory. LangMan tyto úpravy umí provádět automaticky, dojde-li k přejmenování lokalizované komponenty a využívá k tomu vlastní Property Editor pro vlastnosti Name typu TComponentName. Existuje však několik jiných nástrojů třetích stran, které si do Delphi můžete doinstalovat a které také obsahují vlastní editor názvů komponent. Bohužel pro stejnou vlastnost může být aktivní pouze jeden editor což znamená, že

HW & SW Development

www.regulace.org

61/67

LangMan 2.0 pokud by jiný editor překryl editor LangMana, nefungovaly by automatické opravy jazykových souborů při přejmenování komponent. Abyste předešli zbytečným problémům, alternativní editor názvů komponent.

doporučuji

nepoužívat

Dosti rozšířený je například balík nástrojů CnPack, který takový editor obsahuje. Proto doporučuji tuto funkci v nastavení CnPacku vypnout. Stačí pouze zrušit zatržítko Enable u řádku Component Name Editor v nastavení CnPack na záložce Property Editor (viz obrázek). Provedená změna nastavení bude platná až od příštího spuštění Delphi (RAD Studio).

7.6

Po upgradu vždy znovu zkompilovat Po upgradu Delphi, nahrání hotfixu nebo i po upgradu jakýchkoli knihoven, TeeChartu, uniGUI frameworku atd. je nutné komponenty LangMan vždy znovu zkompilovat! Je to logické, ale nejčastěji se na to zapomíná.

HW & SW Development

www.regulace.org

62/67

LangMan 2.0

8

Porovnání možností všech edic LangMan Vlastnost

LangMan Personal

LangMan Professional

LangMan Premium

LangMan Ultimate

Run-time editor jazyků Design-time editor jazyků Neomezený počet enginů v projektu Podpora MDI aplikací Podpora webových aplikací (uniGUI) Import jazykových dat Export jazykových dat Globální lexikon Podpora run-time překladu řetězců „RESOURCESTRINGs“ Komponenty TLangManEngine TUniLangManEngine TLangManEngineX TLangManClient TUniLangManClient TLangManClientX TResourcesTranslator TUniResourcesTranslator TResourcesTranslatorX TDesignedLexicon TUniDesignedLexicon TDesignedLexiconX TProgrammableLexicon TUniProgrammableLexicon TProgrammableLexiconX TInlineLexicon TUniInlineLexicon TInlineLexiconX TLangCombo TUniLangCombo

HW & SW Development

www.regulace.org

63/67

LangMan 2.0 LangMan Personal

Vlastnost

LangMan Professional

LangMan Premium

LangMan Ultimate

TLangComboX TLangFlag TUniLangFlag TLangFlagX TLangFlagsCombo TValuedLabel TUniValuedLabel TValuedLabelX TLangManRichEdit Třída TLangManStrings Sady komponent u nichž je podporován automatický překlad řetězcových vlastností FireMonkey (FMX) VCL (kromě Ribbon Controls) Ribbon Controls (vyžadován TResourcesTranslator) Rave Reports TeeChart SynEdit uniGUI Možnost přidávání dalších komponent Podporované platformy 32-bit Windows 64-bit Windows OS X iOS Android Podpora stylu Microsoft Modern UI (dříve Metro) VCL Metro FireMonkey (FMX) Metro Další možnosti Včetně zdrojových kódů Povolené úpravy zdrojových kódů Komerční využití Technická podpora HW & SW Development

www.regulace.org

64/67

LangMan 2.0

9

Omezení dle platforem Některé funkce komponent LangMan jsou platformě závislé a proto nefungují pod všemi systémy. Následující tabulka znázorňuje, které to jsou a jaké je jejich omezení. Platforma Funkce / komponenta

32-bit 64-bit Windows Windows

OSX

iOS

Android

Vestavěný editor jazyků T(Uni)ResourcesTranslator(X)

HW & SW Development

www.regulace.org

65/67

LangMan 2.0

Revize dokumentu Datum 9.12.2013

Revize

Poznámka

08

Nové Tipy a triky

6.12.2013

07

Vydání LangMan verze 2.0.0 + Podpora překladu řetězců „RESOURCESTRING“ + Podpora FireMonkey + Podpora platformy 64-bit Windows + Podpora platformy OS X + Podpora platformy iOS + Podpora platformy Android + Podpora uniGUI + Podpora komponent SynEdit + Plná podpora komponent z palety Ribbon Controls + Globální lexikon + TLangFlag(X) + TUniLangFlag + TUniLangCombo + TUniValuedLabel + TInlineLexicon(X) + TResourcesTranslator(X) + Vyhledávání v řetězcích + Možnost používání řídicích znaků + Nastavení omezení překladu pomocí vlastnosti Tag + Design-time editor + Import / export + ISO kódy

9.1.2013

06

Vydání LangMan verze 1.2.4 + podpora MDI aplikací

11.2.2012

05

Vydání LangMan verze 1.2.1

24.1.2012

04

Vydání LangMan verze 1.2.0 + TLangManRichEdit

15.4.2011

03

Vydání LangMan verze 1.1.8

15. 8. 2010

02

Vydání LangMan verze 1.1.1 + TLangManStrings

17. 2. 2010

01

Vydání LangMan verze 1.1.0 + podpora jazykových souborů v resources

HW & SW Development

www.regulace.org

66/67

LangMan 2.0

Informace o výrobci Ing. Tomáš Halabala – REGULACE.ORG

Slunná 848, Luhačovice CZ-76326 Czech Republic Tel.:

+420 728 677 659

E-mail:

[email protected]

Web:

http://www.regulace.org

HW & SW Development

www.regulace.org

67/67