Accueil

Tutorial programmation n°2 : Gestion des langues

 

Introduction :

Voici un petit système simple pour la gestion des langues dans votre application. Cette AIM va vous permettre de charger le texte de vos HUD dans la langue correspondant au système en lisant le fichier xml correspondant.

Télécharger l'archive STE ( Nécessite Shiva 1.9.2 2013 05 12 ou versions suivantes )

Le fichier contient les éléments suivants:

- Une AIM "Language"

- Un HUD "monHUD"

- Deux fichiers XML contenant les langues : "language_fr" et "language_en"

 

1 - Structure du fichier de langue :

Voici le contenu du fichier xml "language_fr" :

 <?xml version="1.0" encoding="utf-8" ?>
<language_fr>
    <monHUD>
        <V s="editText" >Champ de saisie</V>
        <V s="label" >Texte simple</V>
        <V s="button" >Bouton</V>
        <V s="checkbox" >Case à cocher</V>
    </monHUD>
</language_fr>

Ce fichier défini le texte de 4 composants du HUD "monHUD":

  • "monHUD.editText"
  • "monHUD.label"
  • "monHUD.button"
  • "monHUD.checkbox"

 

 2 - Scripts de l'AIM "Language"

Voici le contenu du handler "onInit", ce handler est exécuté au lancement de l'application. Les commentaires permettent de comprendre un peu ce que fait ce handler:

  1. local u = this.getUser ( )
  2.  
  3. -- Initialise la langue
  4. user.sendEventImmediate ( u, "Language", "onStart")
  5.  
  6. -- Crée le hud "monHUD"
  7. hud.newTemplateInstance ( this.getUser ( ), "monHUD", "monHUD" )
  8.  
  9. -- Met à jour le HUD "monHUD"
  10. user.sendEventImmediate ( u, "Language", "onTranslateHUD", "monHUD" )
  11.  
  12.  
  13.  


Voici le contenu du handler "onStart", qui doit être appellé au lancement de l'application. Ce handler a pour fonction de charger le contenu du xml correspondant à la langue de l'OS de l'utilisateur. Ce contenu est stocké dans des variables d'environnement (Le nom de la variable est du type "language."..sNomDeLinstanceDuHUD.."."..sNomDuComposant )

  1. --------------------------------------------------------------------------------
  2. -- Handler.......... : onStart
  3. -- Author........... :
  4. -- Description...... :
  5. --------------------------------------------------------------------------------
  6.  
  7. --------------------------------------------------------------------------------
  8. function Language.onStart ( )
  9. --------------------------------------------------------------------------------
  10.  
  11. local u = this.getUser ( )
  12.  
  13. -- Défini le nom du fichier à charger en fonction de la langue de l'OS
  14. local sXMLName = "language_en" -- Défini le fichier à charger par défaut
  15.  
  16. if ( system.getOSLanguage ( ) == system.kLanguageFrench )
  17. then
  18. sXMLName = "language_fr"
  19.  
  20. elseif ( system.getOSLanguage ( ) == system.kLanguageEnglish )
  21. then
  22. sXMLName = "language_en"
  23.  
  24. -- Par défaut
  25. else
  26.  
  27. end
  28.  
  29. log.message ( "language.onStart() - sXMLName = ",sXMLName )
  30.  
  31. -- Création de variable d'environement à partir du fichier
  32. local hXML = this.hXML ( )
  33. xml.empty ( hXML )
  34. local bOK = xml.createFromResource ( hXML, sXMLName )
  35.  
  36. if ( bOK )
  37. then
  38. local hRoot = xml.getRootElement ( hXML )
  39.  
  40. log.message ( "Language.onStart() - hRoot = ", xml.toString ( hRoot) )
  41.  
  42. local iCount = xml.getElementChildCount ( hRoot )
  43.  
  44. for i = 0, iCount - 1
  45. do
  46. local hChild = xml.getElementChildAt ( hRoot, i )
  47. local bIsContainer = xml.getElementChildCount ( hChild ) > 0
  48.  
  49. -- Dans le cas ou l'élément XML ai des enfants ( toujours le cas dans notre exemple )
  50. if ( bIsContainer )
  51. then
  52. log.message ( "Container, child count ="..xml.getElementChildCount ( hChild ))
  53.  
  54. local sChild = xml.getElementName ( hChild )
  55. local jCount = xml.getElementChildCount ( hChild )
  56. for j = 0, jCount - 1
  57. do
  58. local hChild2 = xml.getElementChildAt ( hChild, j )
  59. local sVarName = xml.getAttributeValue ( xml.getElementAttributeWithName ( hChild2, "s" ) )
  60. local sVar = xml.getElementValue ( hChild2 )
  61.  
  62. user.setEnvironmentVariable ( u, "language."..sChild.."."..sVarName , sVar ) -- Mémorise le texte dans une variable d'environement
  63.  
  64. log.message ( "Language.onStart() - Create variable : language."..sChild.."."..sVarName, ", with the value : ",sVar )
  65. end
  66.  
  67. -- Dans le cas où l'élément XML n'ai pas d'enfant
  68. else
  69. local sVarName = xml.getAttributeValue ( xml.getElementAttributeWithName ( hChild, "s" ) )
  70. local sVar = xml.getElementValue ( hChild )
  71.  
  72. user.setEnvironmentVariable ( u, "language."..sVarName, sVar )-- Mémorise le texte dans une variable d'environement
  73. log.message ( "Language.onStart() - Create variable : ", sVarName, ", with the value : ",sVar )
  74. end
  75.  
  76. end
  77.  
  78.  
  79. else
  80. log.error ( "Language.onStart() - Can't create XML from ressource : ", sXMLName )
  81. end
  82. --------------------------------------------------------------------------------
  83. end
  84. --------------------------------------------------------------------------------
  85.  

 

Et enfin, voici le handler "onTranslateHUD". ce handler prend en paramètre le préfixe du template du HUD à mettre à jour ("monHUD" dans notre cas).
 Ce handler, lis les variables d'environnement une à une. Lorsqu'une variable d'environnement concerne le HUD ( nom contenant "language."..s ) et qu'elle concerne un composant de type bouton, edit text, label ou checkbox alors on met à jour son texte:

  1. --------------------------------------------------------------------------------
  2. -- Handler.......... : onTranslateHUD
  3. -- Author........... :
  4. -- Description...... :
  5. --------------------------------------------------------------------------------
  6.  
  7. --------------------------------------------------------------------------------
  8. function Language.onTranslateHUD ( s )
  9. --------------------------------------------------------------------------------
  10.  
  11. log.message ( "Language.onTranslateHUD (",s,")" )
  12.  
  13. local u = this.getUser ( )
  14. local count = application.getCurrentUserEnvironmentVariableCount ( )
  15.  
  16. for i = 0, count - 1
  17. do
  18. local sVarName = application.getCurrentUserEnvironmentVariableNameAt ( i )
  19. local sVar = user.getEnvironmentVariable ( u, sVarName )
  20. if ( string.contains ( sVarName, "language."..s) )
  21. then
  22.  
  23. local sTag = string.replace ( sVarName, "language.", "" )
  24. local hComponent = hud.getComponent ( u, sTag)
  25.  
  26.  
  27. if ( hComponent )
  28. then
  29. if ( hud.getComponentType ( hComponent ) == hud.kComponentTypeLabel )
  30. then
  31.  
  32. hud.setLabelText ( hComponent , sVar )
  33.  
  34. elseif ( hud.getComponentType ( hComponent ) == hud.kComponentTypeButton )
  35. then
  36. hud.setButtonText ( hComponent, sVar )
  37.  
  38. elseif ( hud.getComponentType ( hComponent ) == hud.kComponentTypeCheck )
  39. then
  40. hud.setCheckText ( hComponent, sVar )
  41.  
  42. elseif ( hud.getComponentType ( hComponent ) == hud.kComponentTypeEdit )
  43. then
  44. hud.setEditText ( hComponent, sVar )
  45. end
  46. else
  47. log.warning ( "Language.onTranslate ( ",s,") - Can't find the component with the tag : ", sTag )
  48. end
  49.  
  50.  
  51. end
  52. end
  53. --------------------------------------------------------------------------------
  54. end
  55. --------------------------------------------------------------------------------
  56.  
  57.  
  58.  

3 - Comment ajouter une langue supplémentaire ?

Si vous souhaitez ajouter une langue, par exemple l'Italien, vous devez :

  1. Créer un nouveau fichier xml "language_it" en vous basant sur un des xml existant.
  2. Ajouter le xml aux ressources du game
  3. Mettre à jour le handler "onStart" ainsi:
  1. --------------------------------------------------------------------------------
  2. -- Handler.......... : onStart
  3. -- Author........... :
  4. -- Description...... :
  5. --------------------------------------------------------------------------------
  6.  
  7. --------------------------------------------------------------------------------
  8. function Language.onStart ( )
  9. --------------------------------------------------------------------------------
  10.  
  11. local u = this.getUser ( )
  12.  
  13. -- Défini le nom du fichier à charger en fonction de la langue de l'OS
  14. local sXMLName = "language_en" -- Défini le fichier à charger par défaut
  15.  
  16. if ( system.getOSLanguage ( ) == system.kLanguageFrench )
  17. then
  18. sXMLName = "language_fr"
  19.  
  20.  
  21. elseif ( system.getOSLanguage ( ) == system.kLanguageItalian )
  22. then
  23. sXMLName = "language_it"
  24.  
  25. elseif ( system.getOSLanguage ( ) == system.kLanguageEnglish )
  26. then
  27. sXMLName = "language_en"
  28.  
  29.  
  30. -- Par défaut
  31. else
  32.  
  33. end
  34.  
  35. log.message ( "language.onStart() - sXMLName = ",sXMLName )
  36.  
  37. -- Création de variables d'environement à partir du fichier
  38. local hXML = this.hXML ( )
  39. xml.empty ( hXML )
  40. local bOK = xml.createFromResource ( hXML, sXMLName )
  41.  
  42. if ( bOK )
  43. then
  44. local hRoot = xml.getRootElement ( hXML )
  45.  
  46. log.message ( "Language.onStart() - hRoot = ", xml.toString ( hRoot) )
  47.  
  48. local iCount = xml.getElementChildCount ( hRoot )
  49.  
  50. for i = 0, iCount - 1
  51. do
  52. local hChild = xml.getElementChildAt ( hRoot, i )
  53. local bIsContainer = xml.getElementChildCount ( hChild ) > 0
  54.  
  55. -- Dans le cas ou l'élément XML ai des enfants ( toujours le cas dans notre exemple )
  56. if ( bIsContainer )
  57. then
  58. log.message ( "Container, child count ="..xml.getElementChildCount ( hChild ))
  59.  
  60. local sChild = xml.getElementName ( hChild )
  61. local jCount = xml.getElementChildCount ( hChild )
  62. for j = 0, jCount - 1
  63. do
  64. local hChild2 = xml.getElementChildAt ( hChild, j )
  65. local sVarName = xml.getAttributeValue ( xml.getElementAttributeWithName ( hChild2, "s" ) )
  66. local sVar = xml.getElementValue ( hChild2 )
  67.  
  68. user.setEnvironmentVariable ( u, "language."..sChild.."."..sVarName , sVar ) -- Mémorise le texte dans une variable d'environement
  69.  
  70. log.message ( "Language.onStart() - Create variable : language."..sChild.."."..sVarName, ", with the value : ",sVar )
  71. end
  72.  
  73. -- Dans le cas ou l'élément XML n'ai pas d'enfant
  74. else
  75. local sVarName = xml.getAttributeValue ( xml.getElementAttributeWithName ( hChild, "s" ) )
  76. local sVar = xml.getElementValue ( hChild )
  77.  
  78. user.setEnvironmentVariable ( u, "language."..sVarName, sVar )-- Mémorise le texte dans une variable d'environement
  79. log.message ( "Language.onStart() - Create variable : ", sVarName, ", with the value : ",sVar )
  80. end
  81.  
  82. end
  83.  
  84.  
  85. else
  86. log.error ( "Language.onStart() - Can't create XML from ressource : ", sXMLName )
  87. end
  88. --------------------------------------------------------------------------------
  89. end
  90. --------------------------------------------------------------------------------
  91.  

 

Pourquoi avoir choisir des handlers et pas des fonctions ?

Dans l'optique de l'utilisation de cette AIM dans une application, j'ai choisi d'utiliser des handler pour permettre l'appel de ces derniers depuis une autre AIM.

 

Et voila, ce tutorial touche à sa fin, j'espère qu'il vous a plu. N'hésitez pas à laisser vos commentaires si vous trouvez des erreurs dans ce dernier. Byebye !

Comments powered by Dis.cuss.It
ShoppingASEhandelAS ErhvervIndexDKServiceIndexDK