L'étape suivante est la création des sources de traduction pour les multiples langues vers lesquelles vous traduisez. Chaque adaptateur est créé de sa propre manière comme décrit ici. Mais il y a quelques dispositifs généraux qui sont valables pour tous les adaptateurs.

Vous devrez savoir où stocker vos fichiers sources de traduction. Avec Zend_Translate vous n'êtes lié par aucune restriction. Les structures suivantes sont préférables :

• Structure de source unique

  /application
  /languages
    lang.en
    lang.de
  /library
  			    

  Positif : Tous les fichiers sources pour chacune des langues peuvent être trouvés dans un dossier. Aucun fractionnement des fichiers.

• Source structurée par langue

  /application
  /languages
    /en
      lang.en
      other.en
    /de
      lang.de
      other.de
  /library
  			    

  Positif : chaque langue est située dans un dossier. La traduction est facilitée car un seul dossier doit être traduit par une équipe de langue. En outre l'utilisation des dossiers multiples est transparente.

• Source structurée par application

  /application
    /languages
      lang.en
      lang.de
      other.en
      other.de
  			    

  Positif : tous les fichiers sources pour chacune des langues peuvent être trouvés dans un seul dossier. Aucun fractionnement des fichiers.

  Négatif : avoir les dossiers multiples pour la même langue est problématique.

• Source structurée par Gettext

  /languages
    /de
      /LC_MESSAGES
        lang.mo
        other.mo
    /en
      /LC_MESSAGES
        lang.mo
        other.mo
  			    

  Positif : de vieilles sources de gettext peuvent être utiliser sans changer la structure.

  Négatif : avoir des dossiers de dossiers peut être embrouillant pour les personnes qui n'ont pas utilisé gettext avant.

• Source structurée par fichier

  /application
    /models
      mymodel.php
      mymodel.de
      mymodel.en
    /views
    /controllers
      mycontroller.de
  /document_root
    /images
    /styles
    .htaccess
    index.php
    index.de
  /library
    /Zend
  			    

  Positif : chaque fichier est lié à sa propre source de traduction. source.

  Négatif : de multiples petits fichiers source de traduction rendent plus dur la traduction. En outre chaque fichier doit être ajouté comme source de traduction.

Les fichiers source uniques et structurés par langue sont les plus utilisés pour Zend_Translate.

Maintenant, que nous connaissons la structure que nous voulons avoir, nous devons créer nos fichiers sources de traduction.

Les fichiers source de type tableau sont simplement des tableaux. Mais vous devez les définir manuellement parce qu'il n'y a aucun outil pour cela. Mais parce qu'ils sont si simples, c'est la manière la plus rapide de rechercher des messages si votre code fonctionne comme prévu. C'est généralement le meilleur adaptateur pour démarrer avec des systèmes multilingues.

$english = array('message1' => 'message1',
                 'message2' => 'message2',
                 'message3' => 'message3');
$german = array('message1' => 'Nachricht1',
                'message2' => 'Nachricht2',
                'message3' => 'Nachricht3');

$translate = new Zend_Translate('array', $english, 'en');
$translate->addTranslation($deutsch, 'de');
	    

Des fichiers source Gettext sont créés par la bibliothèque GNU gettext. Il y a plusieurs outils libres disponibles qui peuvent analyser vos fichiers de code et créent les fichiers source nécessaires de gettext. Ces fichiers se termine par *.mo et ce sont des fichiers binaires. Un outil freeware pour créer ces fichiers est » poEdit. Cet outil vous aide également pour le processus de traduction lui-même.

// Les fichiers mo sont créés et déjà traduits
$translate = new Zend_Translate('gettext', 'chemin/vers/english.mo', 'en');
$translate->addTranslation('chemin/vers/german.mo', 'de');
	    

Comme vous pouvez le voir, les adaptateurs sont utilisés exactement de la même manière, avec juste une petite différence : changer "array" en "gettext". Toutes autres utilisations sont exactement les mêmes qu'avec tous autres adaptateurs. Avec l'adaptateur de gettext vous ne devez plus vous occuper de la structure des répertoires, du "bindtextdomain" et du "textdomain". Fournissez juste le chemin et le nom de fichier à l'adaptateur.

Note: Vous devriez toujours employer UTF-8 comme source d'encodage. Autrement vous aurez des problèmes si vous employez deux encodages différents. Par exemple, si un de vos fichiers source est encodé en ISO-8815-1 et un fichier différent est codé avec CP815. Vous ne pouvez utiliser qu'un seul encodage pour vos fichiers sources, ainsi une de vos langues ne s'affichera probablement pas correctement.
UTF-8 est un format portable qui supporte toutes les langues. Si vous employez l'encodage UTF-8 pour toutes les langues, vous éliminez le problème des encodages incompatibles.

Les fichiers source TMX sont les nouveaux standard industriels. Ils ont l'avantage d'être des fichiers XML et ainsi ils sont lisibles par tout éditeur de fichier et naturellement ils sont lisibles pour l'homme. Vous pouvez soit créer des fichiers TMX manuellement avec un éditeur de texte, soit utiliser un outil. Mais la plupart des programmes actuellement disponibles pour développer des fichiers source TMX ne sont pas freeware.

<?xml version="1.0" ?>
<!DOCTYPE tmx SYSTEM "tmx14.dtd">
<tmx version="1.4">
 <header creationtoolversion="1.0.0" datatype="winres" segtype="sentence" adminlang="en-us" srclang="de-at" o-tmf="abc" creationtool="XYZTool" >
 </header>
 <body>
  <tu tuid='message1'>
   <tuv xml:lang="de"><seg>Nachricht1</seg></tuv>
   <tuv xml:lang="en"><seg>message1</seg></tuv>
  </tu>
  <tu tuid='message2'>
   <tuv xml:lang="en"><seg>message2</seg></tuv>
   <tuv xml:lang="de"><seg>Nachricht2</seg></tuv>
  </tu>
		    

$translate = new Zend_Translate('tmx', 'chemin/vers/mytranslation.tmx', 'en');
// TMX peut contenir différentes langues dans le même fichier
		    

Les fichiers TMX peuvent avoir plusieurs langues dans le même fichier. Toutes autres langues incluses sont ajoutées automatiquement, ainsi vous n'avez pas à appeler addLanguage().

Si vous voulez avoir seulement les langues spécifiées de la source traduite, vous pouvez régler l'option defined_language à true. Avec cette option vous pouvez ajouter les langues souhaitées explicitement avec addLanguage(). La valeur par défaut pour cette option est d'ajouter toutes les langues.

Les fichiers source CSV sont petits et lisibles pour l'homme. Si vos clients veulent eux-mêmes traduire, vous utiliserez probablement l'adaptateur CSV.

#Exemple de fichier csv
message1;Nachricht1
message2;Nachricht2
		    

$translate = new Zend_Translate('csv', 'chemin/vers/mytranslation.csv', 'de');
$translate->addTranslation('chemin/vers/other.csv', 'fr');
		    

Le séparateur standard des fichiers CSV est le signe ';'. Mais celui-ci n'est pas obligatoire. Avec l'option 'separator' vous pouvez décider d'utiliser un autre signe de séparation.

Si vous devez avoir le signe séparateur dans votre traduction vous devez juste le doubler pour être inclus dans la traduction. Un seul signe séparateur séparera l'origine et les chaînes de traduction et deux signes séparateurs écriront le signe séparateur dans la chaîne. Voir l'exemple suivant :

#Example csv file
# original 'message,1'
message,,1,Nachricht1
# translation 'Nachricht,2'
message2,Nachricht,,2
# original 'message3,'
message3,,,Nachricht3
		    

$translate = new Zend_Translate('csv', 'chemin/vers/matraduction.csv', 'de', array('separator' => ','));
$translate->addTranslation('chemin/vers/autre.csv', 'fr');
		    

Les options peuvent être utilisées avec tous les adaptateurs. Bien sûr les options sont différentes pour chaque adaptateur. Vous pouvez mettre des options quand vous créez l'adaptateur. Pour l'instant il y a qu'une option qui est valable pour tous les adaptateurs. 'clear' décide si des données de traduction peuvent être ajoutées à l'existant ou non. Le comportement standard est d'ajouter des nouvelles données de traduction à l'existant. Les données de traduction sont seulement effacées pour la langue choisie. Donc on ne touchera pas aux autres langues.

Vous pouvez régler des options temporaires en utilisant addTranslation($donnees, $locale, array $options = array()) comme troisième paramètre optionel. Ou vous pouvez utiliser la fonction setOptions() pour régler une option.

// définir ':' comme séparateur pour les fichiers sources de traduction
$options = array('separator' => ':');
$translate = new Zend_Translate('csv', 'chemin/vers/matranslation.csv', 'fr', $options);

...

// efface le langage défini et utilise de nouvelles données de traduction
$options = array('clear' => true);
$translate->addTranslation('chemin/vers/nouveau.csv', 'en', $options);
		    

Ici vous pouvez trouver toutes les options disponibles pour les différents adaptateurs avec une description de leur utilisation :

When you want to have self defined options, you are also able to use them within all adapters. The setOptions() method can be used to define your option. setOptions() needs an array with the options you want to set. If an given option exists it will be signed over. You can define as much options as needed as they will not be checked by the adapter. Just get sure that you do not sign over any existing option which is used by an adapter.

To return the set option you can use the getOptions() method. When getOptions() is called without an parameter it will return all set options. When the optional parameter is given you will only get the particular option returned.

When working with different languages there are a few methods which will be useful.

The getLocale() method can be used to get the actual set language. It can eigther hold an instance of Zend_Locale or the identifier of a locale.

The setLocale() method sets a new standard language for translation. This prevents the need of setting the optional language parameter more than once to the translate() method. If the given language does not exist, or no translation data is available for the language, setLocale() tries to downgrade to the language without the region if any was given. A language of en_US would be downgraded to en. When also the downgraded language can not be found an exception will be thrown.

The isAvailable() method checks if a given language is already available. It returns true if data for the given language exist.

And finally the getList() method can be used to get all actual set languages for an adapter returned as array.

...
// returns the actual set language
$actual = $translate->getLocale();

...
// you can use the optional parameter while translating
echo $translate->_("my_text", "fr");
// or set a new standard language
$translate->setLocale("fr");
echo $translate->_("my_text");
// refer to the base language... fr_CH will be downgraded to fr and be used
$translate->setLocale("fr_CH");
echo $translate->_("my_text");
...
// check if this language exist
if ($translate->isAvailable("fr")) {
    // language exists
}
            

// Let's expect the browser returns this language settings
HTTP_ACCEPT_LANGUAGE = "de_AT=1;fr=1;en_US=0.8";

// Example 1:
$translate = new Zend_Translate("gettext", "\my_it.mo", "it_IT");
$translate->addTranslation("\my_es.mo","es_UG");
// no fitting language found, return the messageid

// Example 2:
$translate = new Zend_Translate("gettext", "\my_en.mo", "en_US");
$translate->addTranslation("\my_it.mo","it_IT");
// best found fitting language is "en_US"

// Example 3:
$translate = new Zend_Translate("gettext", "\my_it.mo", "it_IT");
$translate->addTranslation("\my_de.mo","de");
// best found fitting language is "de" because "de_AT" will be degraded to "de"

// Example 4:
$translate = new Zend_Translate("gettext", "\my_it.mo", "it_IT");
$translate->addTranslation("\my_ru.mo","ru");
$translate->setLocale("it_IT");
$translate->addTranslation("\my_de.mo","de");
// returns "it_IT" as translation source
                

Zend_Translate can detect translation sources automatically. So you don't have to declare each source file manually. You can let Zend_Translate do this job and scan the complete directory structure for source files.

Note: Automatic source detection is available since Zend Framework version 1.1 .

The usage is quite the same as initiating a single translation source with one difference. You must give a directory which has to be scanned instead a file.

// expect we have the following structure
//  /language
//  /language/login/login.tmx
//  /language/logout/logout.tmx
//  /language/error/loginerror.tmx
//  /language/error/logouterror.tmx

$translate = new Zend_Translate('tmx', '/language');
            

So Zend_Translate does not only search the given directory, but also all subdirectories for translation source files. This makes the usage quite simple. But Zend_Translate will ignore all files which are no sources or which produce failures while reading the translation data. So you have to get sure that all of your translation sources are correct and readable because you will not get any failure if a file is bogus or can not be read.

Note: Depending on how deep your directory structure is and how much files are within this structure it can take a long time for Zend_Translate to complete.

In our example we have used the TMX format which includes the language to be used within the source. But many of the other source formats are not able to include the language within the file. Even this sources can be used with automatic scanning if you do some pre-requisits as described below: scanned.

// expect we have the following structure
//  /language
//  /language/de/login/login.tmx
//  /language/de/error/loginerror.tmx
//  /language/en/login/login.tmx
//  /language/en/error/loginerror.tmx

$translate = new Zend_Translate('gettext', '/language', null, array('scan' => Zend_Translate::LOCALE_DIRECTORY));
                

// expect we have the following structure
//  /language
//  /language/login/login_en.tmx
//  /language/login/login_de.tmx
//  /language/error/loginerror_en.tmx
//  /language/error/loginerror_de.tmx

$translate = new Zend_Translate('gettext', '/language', null, array('scan' => Zend_Translate::LOCALE_FILENAME));
                

/languages
  en.mo
  de.mo
  es.mo
                

/languages
  view.en
  view.de
  view.es
                

/languages
  view_en.mo  -> detects english
  view_de.mo  -> detects german
  view_it.mo  -> detects italian
                

/languages
  view_en_de.mo  -> detects english
  view_en_es.mo  -> detects english and overwrites the first file because the same messageids are used
  view_it_it.mo  -> detects italian
                

/languages
  view_en-it.mo  -> detects english because '_' will be used before '-'
  view-en_it.mo  -> detects italian because '_' will be used before '-'
  view_en.it.mo  -> detects italian because '.' will be used before '_'
                

Normalement le texte sera traduit sans aucun calcul. Mais il est quelquefois nécessaire si un texte est traduit ou non dans la source. Dans ce cas la méthode isTranslated() peut être utilisé.

isTranslated($messageId, $original = false, $locale = null) prend comme premier paramètre le texte dont vous voulez vérifier que la traduction est possible. Et comme troisème paramètre optionnel la langue dont vous voulez connaître la traduction. Le second paramètre optionnel détermine si la traduction est fixée à la langue déclarée ou si une autre langue peut être utilisée. Si vous avez un texte qui peut être traduit en "fr" mais pas en "fr_fr" vous obtiendriez normalement la traduction fournie, mais avec $original réglé à true, la méthode isTranslated() retournera false dans ce cas.

$english = array('message1' => 'Nachricht 1',
                 'message2' => 'Nachricht 2',
                 'message3' => 'Nachricht 3');
$translate = new Zend_Translate('array', $english, 'de_AT');

if ($translate->isTranslated('message1')) {
    print "'message1' peut être traduit";
}
if (!($translate->isTranslated('message1', true, 'de'))) {
    print "'message1' ne peut pas être traduit en 'de', il est seulement disponible en 'de_AT'";
}
if ($translate->isTranslated('message1', false, 'de')) {
    print "'message1' peut être traduit en 'de_AT' et par conséquent en 'de'";
}
		    

Of course sometimes it is useful to have access to the translation source data. Therefor two functions exist.

The getMessageIds($locale = null) method returns all known message ids as array.

And the getMessages($locale = null) method returns the complete translation source as array. The message id is used as key and the translation data as value.

Both methods accept an optional parameter $locale which, when set, returns the translation data for the specified language. If this parameter is not given, the actual set language will be used. Keep in mind that normally all translations should be available in all languages. Which means that in a normal situation you will not have to set this parameter.

Additionally the getMessages() method is able to return the complete translation dictionary with the pseudo-locale 'all'. This will return all available translation data for each added locale.

Note: Attention: The returned array can be very big, depending on the count of added locales and the amount of translation data.

...
// returns all known message ids
$messageids = $translate->getMessageIds();
print_r($messageids);

...
// or just for the specified language
$messageids = $translate->getMessageIds('en_US');
print_r($messageids);

...
// returns all the complete translation data
$source = $translate->getMessages();
print_r($source);