Application: gvSIG desktop

        /**

         * 

         * @deprecated  use setCurrentLocale(Locale locale, Locale alternatives[]) or LocaleManager.setCurrentLocale

         */

        public static void setCurrentLocale(Locale locale) {

            Locale alternatives[] = null;

            String localeStr = locale.getLanguage();

            if ( localeStr.equals("es") || 

                 localeStr.equals("ca") ||

                 localeStr.equals("gl") || 

                 localeStr.equals("eu") ||

                 localeStr.equals("vl") ) {

                alternatives = new Locale[2];

                alternatives[0] = new Locale("es");

                alternatives[1] = new Locale("en");

            } else {

                // prefer English for the rest

                alternatives = new Locale[2];

                alternatives[0] = new Locale("en");

                alternatives[1] = new Locale("es");

            }

            setCurrentLocale(locale, alternatives);

        }

        public static void setCurrentLocale(Locale locale, Locale alternatives[]) {

            for( int i=0 ; i<alternatives.length; i++ ) {

                addLocale(alternatives[i]);

#

# Default locales

#

locale=es

locale=en        

locale=en_US

locale=ca

locale=gl

locale=eu

locale=de

locale=cs

locale=fr

locale=it

locale=pl

locale=pt

locale=pt_BR

locale=ro

locale=zh

locale=ru

locale=el

locale=ro

locale=ro

locale=pl

locale=tr

locale=sr

locale=sw

    public static final String PLUGINS_LOCALE_MANAGER_NAME = "LocaleManager";

    private static final String PLUGINS_LOCALE_MANAGER_DESCRIPTION = "LocaleManager";

    public static LocaleManager getLocaleManager() throws LocatorException {

        return (LocaleManager) getInstance().get(PLUGINS_LOCALE_MANAGER_NAME);

    }

    public static void registerLocaleManager(Class clazz) {

        getInstance().register(PLUGINS_LOCALE_MANAGER_NAME, PLUGINS_LOCALE_MANAGER_DESCRIPTION,

                clazz);

    }

import org.gvsig.andami.impl.DefaultLocaleManager;

        PluginsLocator.registerLocaleManager(DefaultLocaleManager.class);

        // Force initialize of the LocaleManager

        PluginsLocator.getLocaleManager();

import java.net.MalformedURLException;

import org.gvsig.andami.LocaleManager;

            installLocales(i18nFolder, packageInfo);

    private void installLocales(File i18nFolder, PackageInfo packageInfo) throws MalformedURLException {

        LocaleManager localeManager = PluginsLocator.getLocaleManager();

        File folder = new File(i18nFolder, packageInfo.getCode());

        File localeConfig = new File(folder,"locale.config");

        localeManager.installLocales(localeConfig.toURI().toURL());

    }

package org.gvsig.andami.impl;

import java.io.File;

import java.net.URL;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Locale;

import java.util.Set;

import java.util.TreeSet;

import javax.swing.JComponent;

import javax.swing.SwingUtilities;

import org.apache.commons.configuration.PropertiesConfiguration;

import org.apache.commons.lang3.LocaleUtils;

import org.apache.commons.lang3.StringUtils;

import org.gvsig.andami.Launcher;

import org.gvsig.andami.LocaleManager;

import org.gvsig.andami.PluginServices;

import org.gvsig.andami.PluginsLocator;

import org.gvsig.andami.PluginsManager;

import org.gvsig.andami.config.generate.AndamiConfig;

import org.gvsig.andami.ui.mdiFrame.MDIFrame;

import org.gvsig.utils.XMLEntity;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

public class DefaultLocaleManager implements LocaleManager {

    private static final Logger logger

            = LoggerFactory.getLogger(DefaultLocaleManager.class);

    private static final String LOCALE_CODE_VALENCIANO = "vl";

    private static final String I18N_EXTENSION = "org.gvsig.i18n.extension";

    private static final String INSTALLED_TRANSLATIONS_HOME_FOLDER = "i18n";

    private static final String VARIANT = "variant";

    private static final String COUNTRY = "country";

    private static final String LANGUAGE = "language";

    private static final String REGISTERED_LOCALES_PERSISTENCE = "RegisteredLocales";

    private final Locale[] hardcoredLocales = new Locale[]{

        // Default supported locales

        SPANISH, // Spanish

        ENGLISH, // English

        new Locale("en", "US"), // English US

        new Locale("ca"), // Catalan

        new Locale("gl"), // Galician

        new Locale("eu"), // Basque

        new Locale("de"), // German

        new Locale("cs"), // Czech

        new Locale("fr"), // French

        new Locale("it"), // Italian

        new Locale("pl"), // Polish

        new Locale("pt"), // Portuguese

        new Locale("pt", "BR"), // Portuguese Brazil

        new Locale("ro"), // Romanian

        new Locale("zh"), // Chinese

        new Locale("ru"), // Russian

        new Locale("el"), // Greek

        new Locale("ro"), // Romanian

        new Locale("pl"), // Polish

        new Locale("tr"), // Turkish

        new Locale("sr"), // Serbio

        new Locale("sw") // Swahili

    };

    private Set installedLocales = null;

    private Set defaultLocales = null;

    public DefaultLocaleManager() {

        Locale currentLocale = org.gvsig.i18n.Messages.getCurrentLocale();

        this.setCurrentLocale(currentLocale);

    }

    public Locale getCurrentLocale() {

        return org.gvsig.i18n.Messages.getCurrentLocale();

    }

    public void setCurrentLocale(final Locale locale) {

        org.gvsig.i18n.Messages.setCurrentLocale(locale, this.getLocaleAlternatives(locale));

        String localeStr = locale.getLanguage();

        if ( localeStr.equalsIgnoreCase(LOCALE_CODE_VALENCIANO) ) {

            Locale.setDefault(new Locale("ca"));

        } else {

            Locale.setDefault(locale);

        }

        AndamiConfig config = Launcher.getAndamiConfig();

        config.setLocaleLanguage(locale.getLanguage());

        config.setLocaleCountry(locale.getCountry());

        config.setLocaleVariant(locale.getVariant());

        setCurrentLocaleUI(locale);

    }

    public Locale getDefaultSystemLocale() {

        String language, region, country, variant;

        language = getSystemProperty("user.language", "en");

        // for compatibility, check for old user.region property

        region = getSystemProperty("user.region", null);

        if ( region != null ) {

            // region can be of form country, country_variant, or _variant

            int i = region.indexOf('_');

            if ( i >= 0 ) {

                country = region.substring(0, i);

                variant = region.substring(i + 1);

            } else {

                country = region;

                variant = "";

            }

        } else {

            country = getSystemProperty("user.country", "");

            variant = getSystemProperty("user.variant", "");

        }

        return new Locale(language, country, variant);

    }

    public Set<Locale> getDefaultLocales() {

        if ( this.defaultLocales == null ) {

            PluginsManager pluginsManager = PluginsLocator.getManager();

            File localesFile = new File(pluginsManager.getApplicationI18nFolder(), "locale.config");

            PropertiesConfiguration config = null;

            if ( localesFile.canRead() ) {

                try {

                    config = new PropertiesConfiguration(localesFile);

                } catch (Exception ex) {

                    logger.warn("Can't open configuration '" + localesFile + "'.", ex);

                }

            }

            defaultLocales = new HashSet<Locale>();

            if ( config == null ) {

                for ( int i = 0; i < hardcoredLocales.length; i++ ) {

                    defaultLocales.add(hardcoredLocales[i]);

                }

            } else {

                List localeCodes = config.getList("locale");

                for ( Object localeCode : localeCodes ) {

                    Locale locale = LocaleUtils.toLocale((String) localeCode);

                    defaultLocales.add(locale);

                }

            }

        }

        return this.defaultLocales;

    }

    public boolean installLocales(URL localesFile) {

        PluginsManager pluginsManager = PluginsLocator.getManager();

        PropertiesConfiguration config = null;

        try {

            config = new PropertiesConfiguration(localesFile);

        } catch (Exception ex) {

            logger.warn("Can't open configuration '" + localesFile + "'.", ex);

        }

        if ( config == null ) {

            return false;

        }

        List localeCodes = config.getList("locale");

        for ( Object localeCode : localeCodes ) {

            Locale locale = LocaleUtils.toLocale((String) localeCode);

            if ( !getInstalledLocales().contains(locale) ) {

                this.installedLocales.add(locale);

            }

        }

        storeInstalledLocales();

        return true;

    }

    public Set<Locale> getInstalledLocales() {

        if ( installedLocales == null ) {

            installedLocales = new TreeSet<Locale>(new Comparator<Locale>() {

                public int compare(Locale t0, Locale t1) {

                    if( t1 == null || t0 == null ) {

                        return 0;

                    }

                    return getLanguageDisplayName(t0).compareToIgnoreCase(getLanguageDisplayName(t1));

                }

            });

            XMLEntity child = getRegisteredLocalesPersistence();

            // If the list of registered locales is not already persisted,

            // this should be the first time gvSIG is run with the I18nPlugin

            // so we will take the list of default locales

            if ( child == null ) {

                installedLocales.addAll(getDefaultLocales());

                storeInstalledLocales();

            } else {

                XMLEntity localesEntity = getRegisteredLocalesPersistence();

                for ( int i = 0; i < localesEntity.getChildrenCount(); i++ ) {

                    XMLEntity localeEntity = localesEntity.getChild(i);

                    String language = localeEntity.getStringProperty(LANGUAGE);

                    String country = localeEntity.getStringProperty(COUNTRY);

                    String variant = localeEntity.getStringProperty(VARIANT);

                    Locale locale = new Locale(language, country, variant);

                    installedLocales.add(locale);

                }

            }

        }

        return Collections.unmodifiableSet(installedLocales);

    }

    public boolean installLocale(Locale locale) {

        // Add the locale to the list of installed ones, if it

        // is new, otherwise, update the texts.

        if ( !getInstalledLocales().contains(locale) ) {

            getInstalledLocales().add(locale);

            storeInstalledLocales();

        }

        return true;

    }

    public boolean uninstallLocale(Locale locale) {

        if ( !getInstalledLocales().remove(locale) ) {

            return false;

        }

        storeInstalledLocales();

        return true;

    }

    public String getLanguageDisplayName(Locale locale) {

        String displayName;

        if ( "eu".equals(locale.getLanguage())

                && "vascuence".equals(locale.getDisplayLanguage()) ) {

            // Correction for the Basque language display name,

            // show it in Basque, not in Spanish

            displayName = "Euskera";

        } else if ( LOCALE_CODE_VALENCIANO.equals(locale.getLanguage()) ) {

            // Patch for Valencian/Catalan

            displayName = "Valenci?";

        } else {

            displayName = locale.getDisplayLanguage(locale);

        }

        return StringUtils.capitalize(displayName);

    }

    public Locale[] getLocaleAlternatives(Locale locale) {

        Locale alternatives[] = null;

        String localeStr = locale.getLanguage();

        if ( localeStr.equals("es") || 

             localeStr.equals("ca") ||

             localeStr.equals("gl") || 

             localeStr.equals("eu") ||

             localeStr.equals(LOCALE_CODE_VALENCIANO) ) {

            alternatives = new Locale[2];

            alternatives[0] = new Locale("es");

            alternatives[1] = new Locale("en");

        } else {

            // prefer English for the rest

            alternatives = new Locale[2];

            alternatives[0] = new Locale("en");

            alternatives[1] = new Locale("es");

        }

        return alternatives;

    }

    private void setCurrentLocaleUI(final Locale locale) {

        if ( !SwingUtilities.isEventDispatchThread() ) {

            try {

                SwingUtilities.invokeAndWait(new Runnable() {

                    public void run() {

                        setCurrentLocaleUI(locale);

                    }

                });

            } catch (Exception ex) {

                // Ignore

            }

        }

        try {

            JComponent.setDefaultLocale(locale);

        } catch (Exception ex) {

            logger.warn("Problems setting locale to JComponent.", ex);

        }

        try {

            MDIFrame.getInstance().setLocale(locale);

        } catch (Exception ex) {

            logger.warn("Problems settings locale to MDIFrame.", ex);

        }

    }

    public File getResourcesFolder() {

        File i18nFolder = new File(

                PluginsLocator.getManager().getApplicationHomeFolder(),

                INSTALLED_TRANSLATIONS_HOME_FOLDER

        );

        if ( !i18nFolder.exists() ) {

            i18nFolder.mkdirs();

        }

        return i18nFolder;

    }

    /**

     * Returns the child XMLEntity with the RegisteredLocales.

     */

    private XMLEntity getRegisteredLocalesPersistence() {

        XMLEntity entity = getI18nPersistence();

        XMLEntity child = null;

        for ( int i = entity.getChildrenCount() - 1; i >= 0; i-- ) {

            XMLEntity tmpchild = entity.getChild(i);

            if ( tmpchild.getName().equals(REGISTERED_LOCALES_PERSISTENCE) ) {

                child = tmpchild;

                break;

            }

        }

        return child;

    }

    /**

     * Stores the list of installed locales into the plugin persistence.

     */

    private void storeInstalledLocales() {

        XMLEntity localesEntity = getRegisteredLocalesPersistence();

        // Remove the previous list of registered languages

        if ( localesEntity != null ) {

            XMLEntity i18nPersistence = getI18nPersistence();

            for ( int i = i18nPersistence.getChildrenCount() - 1; i >= 0; i-- ) {

                XMLEntity child = i18nPersistence.getChild(i);

                if ( child.getName().equals(REGISTERED_LOCALES_PERSISTENCE) ) {

                    i18nPersistence.removeChild(i);

                    break;

                }

            }

        }

        // Create the new persistence for the registered languages

        localesEntity = new XMLEntity();

        localesEntity.setName(REGISTERED_LOCALES_PERSISTENCE);

        Set<Locale> locales = getInstalledLocales();

        for ( Iterator iterator = locales.iterator(); iterator.hasNext(); ) {

            Locale locale = (Locale) iterator.next();

            XMLEntity localeEntity = new XMLEntity();

            localeEntity.setName(locale.getDisplayName());

            localeEntity.putProperty(LANGUAGE, locale.getLanguage());

            localeEntity.putProperty(COUNTRY, locale.getCountry());

            localeEntity.putProperty(VARIANT, locale.getVariant());

            localesEntity.addChild(localeEntity);

        }

        getI18nPersistence().addChild(localesEntity);

    }

    /**

     * Returns the I18n Plugin persistence.

     */

    private XMLEntity getI18nPersistence() {

        XMLEntity entity

                = PluginServices.getPluginServices(I18N_EXTENSION).getPersistentXML();

        return entity;

    }

    @SuppressWarnings("unchecked")

    private String getSystemProperty(final String property, String defaultValue) {

        String value

                = (String) AccessController.doPrivileged(new PrivilegedAction() {

                    public Object run() {

                        return System.getProperty(property);

                    }

                });

        return value == null ? defaultValue : value;

    }

}

package org.gvsig.andami;

import java.io.File;

import java.net.URL;

import java.util.Locale;

import java.util.Set;

public interface LocaleManager {

    public static final Locale SPANISH = new Locale("es");

    public static final Locale ENGLISH = new Locale("en");

    public Set<Locale> getDefaultLocales();

    public Set<Locale> getInstalledLocales();

    public Locale getDefaultSystemLocale();

    public Locale getCurrentLocale();

    public void setCurrentLocale(Locale locale);

    public boolean installLocale(Locale locale);

    public boolean uninstallLocale(Locale locale);

    public boolean installLocales(URL localesFile);

    public File getResourcesFolder();

    public Locale[] getLocaleAlternatives(Locale locale);

    public String getLanguageDisplayName(Locale locale);

}

    /**

     * Install a new locale in the framework of andami.

     * 

     * If the locale already exists update it.

     * 

     * @param locale to install

     */

    public void installLocale(Locale locale);

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

 * MA 02110-1301, USA.

import org.gvsig.andami.LocaleManager;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

 *

    private static final Logger logger = LoggerFactory.getLogger(I18nManagerImpl.class);

    private static final String CSV_SEPARATOR = ",";

    private static final I18nManager DEFAULT = new I18nManagerImpl();

    /**

     * The list of default reference locales. The last one will be used to get

     * all the keys when translating to a new locale.

     */

    private Locale[] referenceLocales = new Locale[]{ENGLISH, SPANISH};

    LocaleManager localeManager = null;

    private LocaleManager getLocaleManager() {

        if ( localeManager == null ) {

            localeManager = PluginsLocator.getLocaleManager();

        }

        return localeManager;

    }

    /**

     * Returns the unique instance of the I18nManager.

     *

     * @return the unique instance

     */

    public static I18nManager getInstance() {

        return DEFAULT;

    }

    public static String capitalize(String text) {

        // Convert the first letter to uppercase

        String capitalLetter

                = new String(new char[]{Character.toUpperCase(text.charAt(0))});

        return capitalLetter.concat(text.substring(1));

    }

    private Set<Locale> getRegisteredLocales() {

        return getLocaleManager().getInstalledLocales();

    }

    public Locale getCurrentLocale() {

        return getLocaleManager().getCurrentLocale();

    }

    public Locale[] getInstalledLocales() {

        Set<Locale> locales = getRegisteredLocales();

        return (Locale[]) locales.toArray(new Locale[locales.size()]);

    }

    private File getResourcesFolder() {

        return getLocaleManager().getResourcesFolder();

    }

    public void setCurrentLocale(Locale locale) {

        getLocaleManager().setCurrentLocale(locale);

    }

    public Locale getDefaultSystemLocale() {

        return getLocaleManager().getDefaultSystemLocale();

    }

    public void installLocale(Locale locale) {

        getLocaleManager().uninstallLocale(locale);

    }

    public void uninstallLocale(Locale locale) throws I18nException {

        if ( getCurrentLocale().equals(locale) || isReferenceLocale(locale) ) {

            throw new UninstallLocaleException(locale);

        }

        if ( getLocaleManager().uninstallLocale(locale) ) {

            // Remove the resource bundle file

            File bundleFile

                    = new File(getResourcesFolder(), getResourceFileName(locale));

            if ( bundleFile.exists() ) {

                bundleFile.delete();

            }

        }

    }

    public String getDisplayName(Locale locale) {

        return getDisplayName(locale, locale);

    }

    public String getDisplayName(Locale locale, Locale displayLocale) {

        StringBuffer name

                = new StringBuffer(getLanguageDisplayName(locale, displayLocale));

        if ( !isEmpty(locale.getCountry()) ) {

            name.append(" - ");

            name.append(locale.getDisplayCountry(displayLocale));

        }

        if ( !isEmpty(locale.getVariant()) ) {

            name.append(" - ");

            name.append(locale.getDisplayVariant(displayLocale));

        }

        name.append(" (").append(locale.toString()).append(")");

        return name.toString();

    }

    private boolean isEmpty(String text) {

        return text == null || text.trim().length() == 0;

    }

    public String getLanguageDisplayName(Locale locale) {

        return this.getLocaleManager().getLanguageDisplayName(locale);

    }

    public String getLanguageDisplayName(Locale locale, Locale displayLocale) {

        return this.getLocaleManager().getLanguageDisplayName(locale);

        /*

        String displayName;

	// Correction for the Basque language display name,

        // show it in Basque, not in Spanish

        if ( "eu".equals(locale.getLanguage())

                && "vascuence".equals(locale.getDisplayLanguage()) ) {

            displayName = "Euskera";

        } // Patch for Valencian/Catalan

        else if ( "ca".equals(locale.getLanguage()) ) {

	    // displayName = Messages.getText("__valenciano");

            // if ("__valenciano".equals(displayName)) {

            // displayName = Messages.getText("__catalan");

            // }

            displayName = "Valenci?";

        } else {

            displayName = locale.getDisplayLanguage(displayLocale);

        return capitalize(displayName);

        */

    }

    public Locale[] installLocales(File importFile) throws I18nException {

        List importLocales = new ArrayList();

        try {

            ZipFile zipFile = new ZipFile(importFile);

            Map locales = getZipFileNonReferenceLocales(zipFile);

            if ( locales == null || locales.size() == 0 ) {

                return null;

            }

            for ( Iterator iterator = locales.entrySet().iterator(); iterator.hasNext(); ) {

                Entry entry = (Entry) iterator.next();

                String fileName = (String) entry.getKey();

                Locale locale = (Locale) entry.getValue();

                importLocales.add(locale);

                getLocaleManager().installLocale(locale);

                // Replace the old bundle with the new one

                ZipEntry zipEntry = zipFile.getEntry(fileName);

                InputStream is = zipFile.getInputStream(zipEntry);

                BufferedReader reader

                        = new BufferedReader(new InputStreamReader(is));

                File bundleFile = getResourceFile(locale);

                FileWriter fileWriter = new FileWriter(bundleFile);

                BufferedWriter writer = new BufferedWriter(fileWriter);

                String line;

                while ( (line = reader.readLine()) != null ) {

                    writer.write(line);

                    writer.write('\n');

                }

                writer.flush();

                writer.close();

                fileWriter.close();

                reader.close();

                is.close();

            }

        } catch (Exception ex) {

            throw new InstallLocalesException(importFile, ex);

        }

        return (Locale[]) importLocales.toArray(new Locale[importLocales.size()]);

    }

    public void exportLocaleForUpdate(Locale locale, Locale referenceLocale,

            File exportFile) throws I18nException {

        exportLocalesForUpdate(new Locale[]{locale}, referenceLocale,

                exportFile);

    }

    public void exportLocalesForUpdate(Locale[] locales,

            Locale referenceLocale, File exportFile) throws I18nException {

        exportLocale(locales, new Locale[]{referenceLocale}, exportFile,

                true);

    }

    public void exportLocaleForTranslation(Locale locale,

            Locale referenceLocale, File exportFile) throws I18nException {

        exportLocaleForTranslation(locale, new Locale[]{referenceLocale},

                exportFile);

    }

    public void exportLocaleForTranslation(Locale locale,

            Locale[] referenceLocales, File exportFile) throws I18nException {

        exportLocale(new Locale[]{locale}, referenceLocales, exportFile,

                false);

    }

    public Locale[] getReferenceLocales() {

        return referenceLocales;

    }

    public void setReferenceLocales(Locale[] referenceLocales) {

        this.referenceLocales = referenceLocales;

    }

    public void setDefaultLocales(Locale[] defaultLocales) {

        logger.warn("This operation (setDefaultLocales) is not supported.");

    }

    private void exportLocale(Locale[] locales, Locale[] referenceLocales,

            File exportFile, boolean update) throws I18nException {

        Locale[] refArray

                = getReferenceLocalesToExport(locales, referenceLocales);

        Set allReferenceKeys = new HashSet();

        Map referenceTexts = new HashMap(refArray.length);

        for ( int i = 0; i < refArray.length; i++ ) {

            Map texts = getAllTexts(refArray[i]);

            referenceTexts.put(refArray[i], texts);

            allReferenceKeys.addAll(texts.keySet());

        }

        try {

            FileOutputStream fos = new FileOutputStream(exportFile);

            ZipOutputStream zipos = new ZipOutputStream(fos);

            // Create the index file

            writeZipFileLocales(zipos, locales, refArray);

            PrintStream ps = new PrintStream(zipos);

            Map texts = null;

            if ( update ) {

                // First, export the locales to update

                if ( locales != null ) {

                    for ( int i = 0; i < locales.length; i++ ) {

                        texts = getAllTexts(locales[i]);

                        addPendingKeys(texts, allReferenceKeys);

                        putResourceInZip(zipos, ps, texts,

                                getResourceFileName(locales[i]));

                    }

                }

            } else { // translate

                // First, export the locales to translate, taking the keys from

                // the reference locales, but without values

                if ( locales != null ) {

                    for ( int i = 0; i < locales.length; i++ ) {

                        putResourceInZip(zipos, ps, allReferenceKeys,

                                getResourceFileName(locales[i]));

                    }

                }

            }

            // Next, export the reference locales

            if ( refArray != null ) {

                for ( int i = 0; i < refArray.length; i++ ) {

                    texts = getAllTexts(refArray[i]);

                    putResourceInZip(zipos, ps, texts,

                            getResourceFileName(refArray[i]));

                }

            }

            ps.flush();

            ps.close();

            zipos.close();

            fos.close();

        } catch (IOException ex) {

            throw new ExportLocaleException(locales, ex);

        }

    }

    /**

     * Adds the keys of the set to the map that aren't still contained in it

     * with a related empty String.

     *

     * @param texts

     * the map to complete with the keys

     * @param allReferenceKeys

     * the complete key set

     */

    private void addPendingKeys(Map texts, Set allReferenceKeys) {

        for ( Iterator iterator = allReferenceKeys.iterator(); iterator.hasNext(); ) {

            Object key = (Object) iterator.next();

            if ( !texts.containsKey(key) ) {

                texts.put(key, "");

            }

        }

    }

    /**

     * Returns the list of reference locales to export, as the union of the

     * default reference locales list and the one selected as reference. The

     * locales to translate or update are extracted from the list.

     */

    private Locale[] getReferenceLocalesToExport(Locale[] locales,

            Locale[] referenceLocalesSelected) {

        // selected by the user.

        Set exportRefLocales = new HashSet(referenceLocales.length);

        for ( int i = 0; i < referenceLocales.length; i++ ) {

            exportRefLocales.add(referenceLocales[i]);

        }

        if ( referenceLocalesSelected != null ) {

            for ( int i = 0; i < referenceLocalesSelected.length; i++ ) {

                exportRefLocales.add(referenceLocalesSelected[i]);

            }

        }

        if ( locales != null ) {

            for ( int i = 0; i < locales.length; i++ ) {

                exportRefLocales.remove(locales[i]);

            }

        }

        Locale[] refArray

                = (Locale[]) exportRefLocales.toArray(new Locale[exportRefLocales.size()]);

        return refArray;

    }

    /**

     * Returns all the localized texts and its keys for a locale.

     */

    private Map getAllTexts(Locale locale) {

        return Messages.getAllTexts(locale);

    }

    private Map getZipFileNonReferenceLocales(ZipFile zipFile)

            throws I18nException {

        ZipEntry zipEntry = zipFile.getEntry(LOCALES_FILE_NAME);

        if ( zipEntry == null ) {

            return null;

        }

        Map locales;

        try {

            InputStream is = zipFile.getInputStream(zipEntry);

            BufferedReader reader

                    = new BufferedReader(new InputStreamReader(is));

            locales = new HashMap(2);

            String line;

            while ( (line = reader.readLine()) != null ) {