source: trunk/jabberit_messenger/java_source/src/nu/fw/jeti/util/I18N.java @ 1001

/*
 * Creado el 30/06/2004 por Rodolfo Gonzalez Gonzalez <rodolfo@equinoxe.g-networks.net>
 *
 * This class is a wrapper for easier i18n of Jeti. It uses the standard i18n 
 * mechanisms given by Java. 
 * 
 */
package nu.fw.jeti.util;

import java.io.*;
import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.*;

import javax.swing.AbstractButton;
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.UIManager;

import nu.fw.jeti.backend.Start;
import nu.fw.jeti.backend.URLClassloader;

/**
 * @author Rodolfo Gonzalez <rodolfo@equinoxe.g-networks.net>
 */
public class I18N
{
        private static ResourceBundle jetiBundle;
        private static Map pluginsBundle;
        private Language[] languages;
        private Map countries;

        public I18N()
        {
                countries = new HashMap();
                if ( Start.applet || Start.webstart )
                {
                        try
                        {
                                BufferedReader data = null;
                                InputStream is  = getClass().getResourceAsStream("/languages/list.txt");
                                if(is==null)return;//no languages
                                data =new BufferedReader(new InputStreamReader(is));
                                //data =new BufferedReader(new InputStreamReader(new URL(Start.programURL + "languages/list.txt").openStream()));
                                List locales = new LinkedList();
                                while (true)
                                {
                                        String file = data.readLine();
                                        if (file ==null) break;//end of stream
                                        locales.add(new Locale(file));
                                }
                                data.close();
                                extractLanguages(locales);
                                extractCountries();
                        }
                        catch (IOException ex){ex.printStackTrace();}
                }
                else
                {
                        extractLanguages(searchTranslations());
                        extractCountries();
                }
        }

        private List searchTranslations()
        {
                String urlString = Start.path + "languages" + File.separator;
                File path = new File(urlString);
                File file[] = path.listFiles();
                List locales = new LinkedList();
                //locales.add(new Locale("en"));//english is available, but java always selects default locale before base locale
                if (file == null) return locales;
                for (int i = 0; i < file.length; i++)
                {
                        Locale locale = getLocale(file[i].getName());
                        if (locale != null) locales.add(locale);
                }
                return locales;
        }

        private Locale getLocale(String filename)
        {
                if (!filename.startsWith("jeti") || !filename.endsWith(".properties")) return null;
                int nlen = "jeti".length();
                String language, country = "";
                switch (filename.length() - nlen - 11)
                {
                        case 6:
                                // E.g. name+"_en_US"+".properties"
                                if (filename.charAt(3 + nlen) != '_') return null;
                                country = filename.substring(nlen + 4, nlen + 6);
                        // no break; here!
                        case 3:
                                if (filename.charAt(nlen) != '_') return null;
                                language = filename.substring(nlen + 1, nlen + 3);
                                Locale locale = new Locale(language, country);
                                return locale;
                }
                return null;
        }

        private void extractLanguages(List availableLocales)
        {
                Set lang = new HashSet();
                for (Iterator i = availableLocales.iterator(); i.hasNext();)
                {
                        Locale l = (Locale) i.next();
                        String language = l.getLanguage();
                        List langLocs = (List) countries.get(language);
                        if (langLocs == null)
                        {
                                langLocs = new ArrayList();
                                countries.put(language, langLocs);
                        }
                        langLocs.add(new Country(l));
                        lang.add(new Language(l));
                }
                //add default locale:
                Locale l = Locale.getDefault();
                String language = l.getLanguage();
                List langLocs = (List) countries.get(language);
                if (langLocs == null)
                {
                        langLocs = new ArrayList();
                        countries.put(language, langLocs);
                }
                lang.add(new Language(l));
                languages = (Language[]) lang.toArray(new Language[0]);
        }

        private void extractCountries()
        {
                Locale[] allLocales = Locale.getAvailableLocales();
                for (int i = 0; i < allLocales.length; i++)
                {
                        String language = allLocales[i].getLanguage();
                        for (int j = 0; j < languages.length; j++)
                        {
                                if (language.equals(languages[j].getLanguageCode()))
                                {
                                        List langLocs = (List) countries.get(language);
                                        Country country = new Country(allLocales[i]);
                                        if (!langLocs.contains(country)) langLocs.add(country);
                                        //System.out.println(allLocales[i].getDisplayCountry());
                                }
                        }
                }
        }

        /**
         * @return The available languages
         */
        public Language[] getLanguages()
        {
                return languages;
        }

        /**
         * @return The countries that are possible with the available languages
         */
        public Map getCountries()
        {
                return countries;
        }

        
        public static String getText(String type, String messageID) {
                ResourceBundle bundle = (ResourceBundle)pluginsBundle.get(type);
                if(bundle == null) bundle = jetiBundle;
                return getText(bundle,messageID);
        }
        
        /**
         * Gives back a translation of the input key without '&' (which is used for mnemonics)
         * 
         * @param messageID is the English phrase used as key, following the GNU gettext style
         * @param bundle is the name of the base resource bundle file
         * @return result (or messageID in case of error)
         */
        public static String gettext(String messageID)
        {
                return getText(jetiBundle, messageID);
        }
        
        private static String getText(ResourceBundle bundle, String messageID)
        {
                if (messageID==null)return null;
                String translation = getTextWithAmp(bundle,messageID);
                //remove &
                int i = translation.indexOf("&");
                if (i > -1)
                {
                        translation = translation.substring(0, i) + translation.substring(i + 1, translation.length());
                        //i = translation.indexOf("&",i);
                }
                return translation;
        }

        /**
         * Gives back a translation of the input key
         * 
         * @param messageID is the English phrase used as key, following the GNU gettext style
         * @param bundle is the name of the base resource bundle file
         * @return result (or messageID in case of error)
         */
        public static String getTextWithAmp(String messageID)
        {//TODO change back to private when string prep is implemented
                return getTextWithAmp(jetiBundle, messageID);
        }
        
        private static String getTextWithAmp(ResourceBundle bundle, String messageID)
        {
                if (messageID==null)return null;
                if(bundle!=null)
                {
                        try
                        {
                                return (String) bundle.getObject(messageID);
                        } catch (MissingResourceException e)
                        {
                                System.out.println(messageID + " is not translated");
                        }
                }
                int dotPos = messageID.lastIndexOf('.');
                if (dotPos>0) messageID = messageID.substring(dotPos+1);
                //return messageID.replaceAll("_"," "); 
                return messageID.replace('_',' '); 
        }

        public static void setTextAndMnemonic(String messageID,JLabel label) {
        setTextAndMnemonic(messageID, label, false);
    }

        public static void setTextAndMnemonic(String messageID,JLabel label, boolean addDots)
        {
                String mnemonicText = getTextWithAmp(messageID);
                String translation=mnemonicText;
                int pos = mnemonicText.indexOf("&");
                if (pos > -1)
                {
                        translation = mnemonicText.substring(0, pos) + mnemonicText.substring(pos + 1, mnemonicText.length());
                }
        if (addDots) {
            translation += "...";
        }
                label.setText(translation);
                pos = getMnemonicPosition(mnemonicText);
                if(pos>-1) label.setDisplayedMnemonic(mnemonicText.charAt(pos));
                if(pos>0) label.setDisplayedMnemonicIndex(pos-1);
        }
        
        public static void setMnemonic(String messageID, JLabel label)
        {
                String translation = getTextWithAmp(messageID);
                int pos = getMnemonicPosition(translation);
                if(pos>-1)label.setDisplayedMnemonic(translation.charAt(pos));
                if(pos>1)label.setDisplayedMnemonicIndex(pos-1);
        }
        
        public static void setMnemonic(String messageID, AbstractButton button)
        {
                String translation = getTextWithAmp(messageID);
                int pos = getMnemonicPosition(translation);
                if(pos>-1)button.setMnemonic(translation.charAt(pos));
                if(pos>1)button.setDisplayedMnemonicIndex(pos-1);
        }

        /**
         * @param messageID is the English phrase used as key, following the
     *              GNU gettext style
         * @param bundle is the name of the base resource bundle file
         * @param button The button to set the mnemonic on
         */
        public static void setTextAndMnemonic(String messageID,AbstractButton button)
        {
        setTextAndMnemonic(messageID, button, false);
    }

        /**
         * @param messageID is the English phrase used as key, following the
     *              GNU gettext style
         * @param bundle is the name of the base resource bundle file
         * @param button The button to set the mnemonic on
         * @param addDots If true add '...' to the translated text
         */
        public static void setTextAndMnemonic(String messageID,AbstractButton button,
                                          boolean addDots)
        {
                String mnemonicText = getTextWithAmp(messageID);
                
                String translation=mnemonicText;
                int pos = mnemonicText.indexOf("&");
                if (pos > -1)
                {
                        translation = mnemonicText.substring(0, pos) + mnemonicText.substring(pos + 1, mnemonicText.length());
                }
        if (addDots) {
            translation += "...";
        }
                button.setText(translation);
                pos = getMnemonicPosition(mnemonicText);
                if(pos>-1)button.setMnemonic(mnemonicText.charAt(pos));
                if(pos>0) button.setDisplayedMnemonicIndex(pos-1);
                
        }

        private static int getMnemonicPosition(String translation)
        {
                int index = translation.indexOf("&");
                if (index >= 0) return index+1;
                return -1;
        }

        static public void init()
        {
                ClassLoader classLoader=null;
        if (!Start.applet && !Start.webstart) {
            try {
                                URL url = new URL(Start.programURL, "languages/");
                classLoader = new URLClassloader(
                    new URL[] { url}, I18N.class.getClassLoader());
            } catch (MalformedURLException e) {
                                e.printStackTrace();
                        }
                } else classLoader = I18N.class.getClassLoader();
                //               see if the user has some preferences
                String myLanguage = Preferences.getString("jeti", "language", "");
                String myCountry = Preferences.getString("jeti", "country", "");
                Locale myLocale=null;
        if (myLanguage != "") {
            myLocale = new Locale(myLanguage, myCountry);
        } else {
            myLocale = Locale.getDefault();
        }
        jetiBundle = loadLanguage("jeti",classLoader,myLocale);
        if(jetiBundle==null || jetiBundle.getLocale().getLanguage().equals(""))
        {
                // Make it fall back to English, this way we always get at least
                // the english texts (which contains the menu mnemonic markings)
                myLocale= new Locale(Locale.ENGLISH.getLanguage(),myCountry);
                System.out.println("lang not found, default: " + myLocale);
                jetiBundle = loadLanguage("jeti",classLoader,myLocale);
        }
        pluginsBundle = new HashMap();
        pluginsBundle.put("drawing",loadLanguage("drawing",classLoader,myLocale));
        JComponent.setDefaultLocale(myLocale);
                   
        //loadLanguage(classLoader, myLocale);
                UIManager.put("OptionPane.okButtonText", gettext("OK"));
                UIManager.put("OptionPane.cancelButtonText", gettext("Cancel"));
                
        }

        private static ResourceBundle loadLanguage(String type, ClassLoader classLoader, Locale myLocale)
        {
                try {
            return ResourceBundle.getBundle("languages/" +type, myLocale);
        } catch (MissingResourceException e) {
            try {
                return ResourceBundle.getBundle(type,
                                                      myLocale, classLoader);
            } catch (MissingResourceException e2) {
                System.out.println(e2.getMessage());
                return null;
            }
        }
        }

        public static class Country
        {
                private String country;
                private String countryCode;

                public Country(Locale locale)
                {
                        country = locale.getDisplayCountry();
                        if (country.equals("")) country = gettext("main.options.standard.Other");
                        countryCode = locale.getCountry();
                }

                public String getCountryCode()
                {
                        return countryCode;
                }

                public String toString()
                {
                        return country;
                }

        }

        public static class Language
        {
                private String language;
                private String languageCode;

                public Language(Locale locale)
                {
                        language = locale.getDisplayLanguage();
                        languageCode = locale.getLanguage();
                }

                public String getLanguageCode()
                {
                        return languageCode;
                }

                public String toString()
                {
                        return language;
                }
                
                public boolean equals(Object obj)
                {
                        return language.equals(((Language)obj).language);
                }
                
                public int hashCode()
                {
                        return language.hashCode();
                }
                
                
        }
}


/*
 * Overrides for emacs
 * Local variables:
 * tab-width: 4
 * End:
 */