Faire une application multilangage avec C++Builder

Ci-dessous, le fichier .h qui va me permettre d'expliquer la structure de la classe :

//---------------------------------------------------------------------------
            
#ifndef GestionLangueH
#define GestionLangueH
            
#include <string> 
#include <hash_map>
#include <vcl.h>
//---------------------------------------------------------------------------
            
typedef void (__fastcall(__closure*ptrOnClick))(TObject *);

class GestionLangue
{
private:
  std::hash_map<int,std::string> listLangues;
  std::string  fichier;
  int defaut;
  char separateur;
  std::vector<std::string> vectProp;
  void ChangeComponent(TComponent*, int);
  void __fastcall ChangeProp(TComponent*, String, String);
  void ChangePropStringList(TComponent*, std::string, std::string);
public :
  GestionLangue(){defaut = 0;};
  ~GestionLangue(){;};
  void Init(TMenuItem*, std::string, ptrOnClick);
  void Change(int);
};
#endif

Nous allons trouver dans cette classe plusieurs fonctions, deux qui seront connues à l'extérieur de la classe et qui serviront donc de relais entre l'application et la classe, et trois secondaires, qui seront appelées par les deux précédentes.

En plus de ces fonctions, nous trouvons trois attributs :

• listLangues : une hash_map qui contient le listing des langues contenues dans le fichier XML ;
• fichier : une string qui contient le chemin complet du fichier XML de traduction ;
• defaut : un entier qui contient l'index de la langue utilisée par défaut par la classe ;
• separateur : un char qui contient le caractère de séparation lors de liste de chaine de caractère ;
• vectProp : un vecteur qui contient la liste des propriétés pouvant être modifiées sur un composant.

Descriptif des fonctions :

• GestionLangue : Constructeur, initialise l'attribut defaut à 0 ;
• ~GestionLangue : Destructeur ;
• Init : Fonction d'initialisation de la classe; configure la liste des langues disponibles dans le fichier XML, remplit le menu de langue et charge la langue par défaut ;
• Change : Charge la langue demandée ;
• ChangeComponent : Fonction récursive qui charge le contenu du fichier XML pour le composant et s'appelle elle-même pour les composants enfants ;
• ChangeProp : Fonction modifiant les propriétés de type String ;
• ChangePropStringList : Fonction modifiant les propriétés de type StringList.

Le fichier XML contiendra trois parties, la partie « Parametre », dans laquelle seront contenus les paramètres tels que le caractère de séparation de chaine de caractère multiligne ou la propriété modifiable par la classe, la partie « Langues », qui définira les langues définies dans le fichier, et la partie « Labels », qui contiendra les labels des différents composants de l'application dans toutes les langues définies dans la première partie du fichier.
Enfin, la balise principale du fichier s'appellera ici « Traductions ».

I-B-1. Structure de la partie « Parametre »▲

I-B-2. Structure de la partie « Langues »▲

I-B-3. Structure de la partie « Labels »▲

Le méthode la plus courte et générale pour modifier les propriétés des composants sous Builder est d'utiliser la fonction SetPropValue, cette fonction permet de modifier une propriété de type AnsiString/String grâce à un pointeur sur ce composant et le nom de la propriété à modifier :

TButton* button1;
...
SetPropValue(button1, "Caption", "Test");

Nous allons donc pouvoir grâce à cette fonction écrire une méthode que l'on appellera ChangeProp.
Nous allons passer à cette méthode plusieurs paramètres, le paramètre pControl est de type TComponent*, tous les composants héritent de cette classe, ce qui permet de passer à cette fonction le pointeur de n'importe quel composant.
Attention tout de même, certaines propriétés spécifiques à certaines classes de composants sont implémentées dans des classes de plus basses couches, et ne sont donc pas connues par la classe TComponent, nous verrons plus tard comment traiter ce cas.
Le paramètre Property_Name spécifie le nom de la propriété à modifier, et le paramètre AValue la valeur à attribuer à cette propriété.
Nous avons donc une fonction qui ressemble actuellement à ceci :

void __fastcall GestionLangue::ChangeProp(TComponent* pControl, String Property_Name, String AValue)
{
  SetPropValue(pControl, Property_Name, AValue);  //Modification de la propriété
}

Le problème comme je l'ai indiqué précédemment est que la propriété à modifier n'existe pas forcément au niveau de la classe TComponent, nous allons donc vérifier son existence grâce à la fonction IsPublishedProp.
Cette fonction retourne la liste des propriétés contenue par le composant qui lui est passé en paramètre.
Suite à ce test et quelques autres, nous arrivons à une fonction sécurisée qui ne plantera pas le programme :

void __fastcall GestionLangue::ChangeProp(TComponent* pControl, String Property_Name, String AValue)
{
  try
  {
    if (pControl != NULL)  //On teste si le pointeur sur le composant n'est pas NULL
    {
      //On teste si la propriété est accessible
      if (IsPublishedProp(pControl, Property_Name))  
      {
        try
        {
          SetPropValue(pControl, Property_Name, AValue);  //Modification de la propriété
        }
        catch(EPropertyError &propError){}
      }
    }
  }
  catch(...){}
}

Certaines propriétés n'étant pas du texte brut, la méthode SetPropValue ne leur convient pas et il n'existe malheureusement pas de fonction sous builder permettant de créer une méthode générique.
Nous allons voir dans cet exemple le cas des propriétés de type TStrings.

Pour traiter les propriétés de type TStrings, nous allons coder une fonction qui s'appellera ChangePropStrings.
La propriété principale utilisant les TStrings est la propriété Items, le problème de cette propriété est qu'elle ne figure pas dans une classe de base, mais directement dans les classes des composants.
Pour accéder à cette propriété nous devrons donc caster notre objet TComponent en la classe du composant qui lui convient, s’il y a beaucoup de types de composant différents cela peut vite prendre beaucoup de place, même si le code est basique, car il faut tester un par un les types de composants comportant une TStrings :

void GestionLangue::ChangePropStrings(TComponent* pControl, string AValue, string typeComponant)
{
  TStrings * contenu;
  //Récupération du pointeur du TStrings à modifier
  if(typeComponant == "TComboBox")
    contenu = (dynamic_cast <TComboBox*> (pControl))->Items;
  else if(typeComponant == "TRadioGroup")
    contenu = (dynamic_cast <TRadioGroup*> (pControl))->Items;
  else
    return;
}

Une fois que l'on a récupéré la TStrings, il n'y a plus qu'à remplacer l'ancien contenu par sa traduction.
Comme le Texte contenu dans un TStrings est divisé en plusieurs lignes, nous devons définir un caractère qui servira de séparateur pour les différentes lignes, ce caractère est défini dans la section Parametre du fichier XML.

void GestionLangue::ChangePropStrings(TComponent* pControl, string AValue, string typeComponant)
{
  TStrings * contenu;
  istringstream iss(AValue);
  string ligne;
  if(typeComponant == "TComboBox")
    contenu = (dynamic_cast <TComboBox*> (pControl))->Items;
  else if(typeComponant == "TRadioGroup")
    contenu = (dynamic_cast <TRadioGroup*> (pControl))->Items;
  else
    return;
  contenu->Clear();
  while ( std::getline( iss, ligne, separateur ) )
  {
    contenu->Add(ligne.c_str());
  }
}

En premier lieu nous allons créer l'interface.
Dans l'exemple ci-dessous j'ai placé une diversité assez importante de composants, ce qui permet de rencontrer tous les cas de figure gérés et décrits précédemment lors de l'écriture de la classe GestionLangue :

• 2 TgroupBox ;
• 2 Tlabel ;
• 1 Tedit ;
• 1 TcomboBox ;
• 1 TcheckBox ;
• 1 TradioBox ;
• 1 Tbutton ;
• 1 TmainMenu.

Le menu est composé d'un sous-menu, ce qui permet également de tester toutes les situations avec un menu.

Après avoir créé l'interface, nous allons créer le fichier XML, ce fichier est composé de trois parties.
Deux utiles à l'initialisation, et la dernière qui contient les différentes traductions.
La balise principale du fichier XML n'a pas d'importance, le programme est fait de manière à passer outre les modifications de cette bannière obligatoire en XML.

V-B-1. La partie « Parametre »▲

<Parametre Separateur="\">
  <Proprietes>
    <Propriete>Caption</Propriete>
    <Propriete>Text</Propriete>
    <Propriete>Hint</Propriete>
    <Propriete>Items</Propriete>
  </Proprietes>
</Parametre>

V-B-2. La partie « Langues »▲

<Langues>
  <Langue index="FR" name="FrenchLang" default="1" />
  <Langue index="EN" name="EnglishLang" default="0" />
</Langues>

V-B-3. La partie « Labels »▲

<Labels>
  <FenetrePrincipale type="TFenetrePrincipale">
    <Caption>
      <FR>Application multilangage</FR>
      <EN>Application multilanguage</EN>
    </Caption>
  </FenetrePrincipale>
  <GroupBox1 type="TGroupBox">
    <Caption>
      <FR>Premier groupe d'objet</FR>
      <EN>First group of object</EN>
    </Caption>
  </GroupBox1>
  <CheckBox1 type="TCheckBox">
    <Caption>
      <FR>Affichage de la case à cocher</FR>
      <EN>Display of the checkbox</EN>
    </Caption>
  </CheckBox1>
  <ComboBox1 type="TComboBox">
    <Items>
      <FR>Choix 1\Choix 2\Choix 3\Choix 4</FR>
      <EN>Choice 1\Choice 2\Choice 3\Choice 4</EN>
    </Items>
  </ComboBox1>
  <Label1 type="TLabel">
    <Caption>
      <FR>Affichage 1</FR>
      <EN>Results 1</EN>
    </Caption>
  </Label1>
  <Label2 type="TLabel">
    <Caption>
      <FR>Affichage 2</FR>
      <EN>Results 2</EN>
    </Caption>
  </Label2>
  <GroupBox2 type="TGroupBox">
    <Caption>
      <FR>Deuxième groupe d'objet</FR>
      <EN>Second group of object</EN>
    </Caption>
  </GroupBox2>
  <Button1 type="TButton">
    <Caption>
      <FR>Bouton</FR>
      <EN>Button</EN>
    </Caption>
  </Button1>
  <RadioGroup1 type="TRadioGroup">
    <Items>
      <FR>Premier choix\Deuxième choix\Troisième choix\Quatrième choix</FR>
      <EN>First choice\Second Choice\Third choice\Fourth choice</EN>
    </Items>
    <Caption>
      <FR>Groupe de choix</FR>
      <EN>Choice group</EN>
    </Caption>
  </RadioGroup1>
  <Langue1 type="TMenuItem">
    <Caption>
      <FR>Langue</FR>
      <EN>Language</EN>
    </Caption>
  </Langue1>
  <FrenchLang type="TMenuItem">
    <Caption>
      <FR>Français</FR>
      <EN>French</EN>
    </Caption>
  </FrenchLang>
  <EnglishLang type="TMenuItem">
    <Caption>
      <FR>Anglais</FR>
      <EN>English</EN>
    </Caption>
  </EnglishLang>
  <sousMenu1 type="TMenuItem">
    <Caption>
      <FR>Sous menu</FR>
      <EN>Sub menu</EN>
    </Caption>
  </sousMenu1>
  <sousMenu2 type="TMenuItem">
    <Caption>
      <FR>Sous-sous menu</FR>
      <EN>Sub-sub menu</EN>
    </Caption>
  </sousMenu2>
</Labels>

Rien de très compliqué dans ce paragraphe :)
Nous allons d'abord créer dans la classe de la fenêtre principale l'événement OnClick qui sera attribué aux boutons du menu de sélection des langues.
L'id de la langue est toujours enregistré dans le Tag du bouton, nous allons donc le récupérer grâce au paramètre Sender qui se trouve dans chaque fonction événement.
Le paramètre Sender contient l'adresse du composant appelant cet événement.
Nous nous retrouvons donc avec un événement OnClick de ce genre :

void __fastcall TFenetrePrincipale::LangueClick(TObject *Sender)
{
  langue->Change(((TMenuItem*)Sender)->Tag);
}

private:    // Déclarations de l'utilisateur
  GestionLangue * langue;

Une fois l'événement codé, nous allons ajouter la classe GestionLangue dans le projet de l'application, et ajouter l'initialisation de celle-ci dans le constructeur de la fenêtre principale de l'application.
Nous allons donc ici instancier le pointeur de la classe GestionLangue, et appeler la fonction Init, en lui passant le composant TMainMenu qui doit contenir les boutons de sélection de la langue, le chemin du fichier XML et l'adresse de l'événement OnClick défini ci-dessus :

__fastcall TFenetrePrincipale::TFenetrePrincipale(TComponent* Owner)
    : TForm(Owner)
{
  AnsiString file ;
  file = Application->ExeName + "\\..\\label.xml";
  langue = new GestionLangue;
  langue->Init(FenetrePrincipale->Langue1,file.c_str(),(ptrOnClick)&LangueClick);
}