Subversion Repositories eFlore/Applications.cel

package org.tela_botanica.client.i18n;

import org.tela_botanica.client.modeles.objets.Configuration;

import com.google.gwt.i18n.client.Dictionary;
import java.lang.Exception;
import java.util.ArrayList;
import java.util.List;

/**
 * Gère l'internationalisation 
 */
public class Msg {

        public static final String MESSAGE_INEXISTANT = "N/A";

        /** langue en cours */
        protected static String langue;
        /** langue par défaut */
        protected static String langueDefaut;
        /** langues disponibles */
        protected static List<String> languesDisponibles;

        /**
         * Initialisation - à appeler une fois avant tout utilisation
         * @return true si tout s'est bien passé, false sinon
         */
        public static boolean init() {
                // lire la config pour obtenir les langues
                languesDisponibles = parserLanguesDisponibles(Configuration.getLanguesDisponibles());
                // lire la config et charger la langue par défaut
                langueDefaut = Configuration.getLangueDefaut();
                // si la langue par défaut n'existe pas, on arrête tout
                return setLangue(langueDefaut);
        }

        /**
         * Initialisation - raccourci pour initialiser avec une langue
         * @param langue la langue à définir jusqu'à nouvel ordre
         * @return true si tout s'est bien passé, false sinon
         */
        public static boolean init(String langue) {
                boolean ok = false;
                if (init()) {
                        ok = setLangue(langue);
                }
                return ok;
        }

        /**
         * [Re]définit la langue en cours
         * @param langue
         * @return true si la langue a été correctement définie, false
         *                      sinon (si la langue n'est pas disponible)
         */
        public static boolean setLangue(String langue) {
                boolean ok = false;
                if (langueEstDisponible(langue)) { // on peut désactiver une langue même si le dictionnaire existe
                        String nomDictionnaire = "messages_" + langue;
                        try {
                                Dictionary.getDictionary(nomDictionnaire);
                                Msg.langue = langue;
                                ok = true;
                        } catch (Exception e) {}
                }
                return ok;
        }
        
        /**
         * Retourne true si la langue demandée est disponible
         * (ceci se fait via la valeur de config, peu importe, si le dictionnaire
         * associé existe ou non)
         * 
         * @param langue
         * @return true si la langue est disponible, false sinon
         */
        public static boolean langueEstDisponible(String langue) {
                return languesDisponibles.contains(langue);
        }

        /**
         * Retourne la langue actuellement définie; si on a essayé de définir
         * une langue qui n'est pas disponible, retournera la langue par défaut
         * 
         * @return la langue actuellement définie
         */
        public static String getLangue() {
                return langue;
        }

        /**
         * @return la langue par défaut, définie dans la configuration
         */
        public static String getLangueDefaut() {
                return langueDefaut;
        }

        /**
         * @return les langues disponibles, définies dans la configuration
         */
        public static List<String> getLanguesDisponibles() {
                return languesDisponibles;
        }

        /**
         * Retourne un message dans la langue en cours
         * @param cle
         * @return
         */
        public static String get(String cle) {
                return get(cle, langue);
        }

        /**
         * Retourne un message dans la langue en cours,
         * avec la première lettre en majuscule
         * @param cle
         * @return
         */
        public static String Get(String cle) {
                return Get(cle, langue);
        }

        /**
         * Retourne un message paramétré dans la langue en cours
         * @param cle
         * @param[] params
         * @return
         */
        public static String get(String cle, String[] params) {
                return get(cle, langue, params);
        }

        /**
         * Retourne un message paramétré dans la langue en cours,
         * avec la première lettre en majuscule
         * @param cle
         * @param[] params
         * @return
         */
        public static String Get(String cle, String[] params) {
                return Get(cle, langue, params);
        }

        /**
         * Retourne un message dans la langue demandée; s'il n'est pas trouvé, le cherche
         * dans la langue par défaut; en cas d'échec, retourne un terme générique d'avertissement
         * @param cle l'identifiant du message demandé
         * @param langue la langue dans laquelle on souhaite l'obtenir
         * @return le message dans la langue en cours s'il existe, sinon le
         *                      message dans la langue par défaut s'il existe, sinon la
         *                      chaîne définie dans Msg.MESSAGE_INEXISTANT
         */
        public static String get(String cle, String langue) {
                String nomDictionnaire = "messages_" + langue;
                String message;
                try {
                        message = Dictionary.getDictionary(nomDictionnaire).get(cle);
                } catch (Exception e) {
                        try {
                                message = Dictionary.getDictionary("messages_" + langueDefaut).get(cle);
                        } catch (Exception me) {
                                message = Msg.MESSAGE_INEXISTANT;
                        }
                }
                return message;
        }

        /**
         * Comme get(String cle, String langue), mais retourne le message
         * avec la première lettre en majuscule
         * @param cle
         * @param langue
         * @return
         */
        public static String Get(String cle, String langue) {
                String message = get(cle, langue);
                return message.substring(0,1).toUpperCase() + message.substring(1);
        }

        /**
         * Retourne un message paramétré dans la langue demandée
         * @param cle
         * @param langue
         * @param[] params
         * @return
         */
        public static String get(String cle, String langue, String[] params) {
                String message = get(cle, langue);
                for (int i = 0; i < params.length; i++) {
                        message = message.replace("{"+i+"}", params[i]);
                }
                
                return message;
        }

        /**
         * Comme get(String cle, String langue, String[] params), mais retourne le
         * message avec la première lettre en majuscule
         * @param cle
         * @param langue
         * @param params
         * @return
         */
        public static String Get(String cle, String langue, String[] params) {
                String message = get(cle, langue, params);
                return message.substring(0,1).toUpperCase() + message.substring(1);
        }
        
        /**
         * Convertit la chaine de config de langues en un objet de type liste
         * @param languesDisponibles la chaine de config 
         * @return List<String> une liste des langues disponibles
         */
        private static List<String> parserLanguesDisponibles(String languesDisponibles) {
                ArrayList<String> langues = new ArrayList<>();
                String[] languesTab = languesDisponibles.split(",");
                for (int i = 0; i < languesTab.length; i++) {
                        langues.add(languesTab[i]);
                }
                return langues;
        }
}