/ - Diff - Application: gvSIG desktop - gvSIG

Revision 42017

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n.tools.impl;
     import java.util.Locale;
     import org.gvsig.i18n.Messages;
     import org.gvsig.tools.i18n.I18nManager;
     /**
      * This manager is in charge of providing with a richer text translation than
      * the one used by default.
+     *
+     *
      * @author gvSIG Team
+     *
      */
     public class DefaultI18Manager implements I18nManager {
     	public String getTranslation(String message) {
     		return Messages.getText(message);
+    	}
             public String getTranslation(String message, String[] args) {
     		return Messages.getText(message,args);
+            }
     	public void addResourceFamily(String family, ClassLoader loader,
     			String callerName) {
     		if (!Messages.hasLocales()) {
     			Messages.addLocale(Locale.getDefault());
+    		}
     		Messages.addResourceFamily(family, loader, callerName);
+    	}
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n;
     import java.io.File;
     import java.net.MalformedURLException;
     import java.net.URL;
     import java.net.URLClassLoader;
     import java.util.ArrayList;
     import java.util.List;
     import java.util.StringTokenizer;
     /**
      * <p>This class offers a class loader which is able to load files from the specified
      * directories.</p>
+     *
      * @author C?sar Mart?nez Izquierdo (cesar.martinez@iver.es)
+     *
      */
     public class MessagesClassLoader extends URLClassLoader {
     	/**
     	 * <p>Creates a new class loader, which is able to load files from the directories
     	 * specified as parameter.</p>
+    	 *
     	 * @param urls The list of directories which will be used to load files.
     	 */
     	public MessagesClassLoader(URL[] urls) {
     		super(urls);
+    	}
     	/**
     	 * Loads a resource using the specified file name.
+    	 *
     	 * @param res The name of the resource to be loaded.
     	 */
     	public URL getResource(String res) {
     		try {
     			ArrayList resource = new ArrayList();
     			StringTokenizer st = new StringTokenizer(res, "\\/");
     			while (st.hasMoreTokens()) {
     				String token = st.nextToken();
     				resource.add(token);
+    			}
     			URL ret = null;
     			int currentUrl;
     			URL[] urls = getURLs();
     			for (currentUrl=0; currentUrl< urls.length; currentUrl++) {
     				URL url = urls[currentUrl];
     				File file = new File(url.getFile());
     				if (url.getFile().endsWith("/"))
     					ret = getResource(file, resource);
+    			}
     			if (ret != null) {
     				return ret;
+    			}
     		} catch (Exception e) {
     			e.printStackTrace();
+    		}
     		return super.getResource(res);
+    	}
     	/**
     	 * Busca recursivamente el recurso res en el directorio base. res es una
     	 * lista de String's con los directorios del path y base es el directorio
     	 * a partir del cual se busca dicho recurso. En cada ejecuci?n del m?todo
     	 * se toma el primer elemento de res y se busca dicho directorio en el
     	 * directorio base. Si se encuentra, ser? el directorio base para una
     	 * nueva llamada.
+    	 *
     	 * @param base Directorio desde donde parte la b?squeda del recurso.
     	 * @param res Lista de strings con el path del recurso que se quiere
     	 *        encontrar
+    	 *
     	 * @return URL con el recurso
     	 */
     	private URL getResource(File base, List res) {
     		File[] files = base.listFiles();
     		String parte = (String) res.get(0);
     		for (int i = 0; i < files.length; i++) {
     			if (files[i].getName().compareTo(parte) == 0) {
     				if (res.size() == 1) {
     					try {
     						return new URL("file:" + files[i].toString());
     					} catch (MalformedURLException e) {
     						return null;
+    					}
     				} else {
     					return getResource(files[i], res.subList(1, res.size()));
+    				}
+    			}
+    		}
     		return null;
+    	}
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n;
     import java.io.File;
     import java.io.IOException;
     import java.io.InputStream;
     import java.net.MalformedURLException;
     import java.net.URL;
     import java.text.MessageFormat;
     import java.util.ArrayList;
     import java.util.Enumeration;
     import java.util.HashSet;
     import java.util.IllegalFormatException;
     import java.util.Iterator;
     import java.util.List;
     import java.util.Locale;
     import java.util.Properties;
     import java.util.Set;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     /**
      * <p>This class offers some methods to provide internationalization services
      * to other projects. All the methods are static.</p>
+     *
      * <p>The most useful method is {@link #getText(String) getText(key)} (and family),
      * which returns the translation associated
      * with the provided key. The class must be initialized before getText can be
      * used.</p>
+     *
      * <p>The typical usage sequence would be:</p>
      * <ul>
      * <li>Add some locale to the prefered locales list: <code>Messages.addLocale(new Locale("es"))</code></li>
      * <li>Add some resource file containing translations: <code>Messages.addResourceFamily("text", new File("."))</code></li>
      * <li>And finaly getText can be used: <code>Messages.getText("aceptar")</code></li>
      * </ul>
+     *
      * <p>The resource files are Java properties files, which contain <code>key=translation</code>
      * pairs, one
      * pair per line. These files must be encoded using iso-8859-1 encoding, and unicode escaped
      * sequences must be used to include characters outside the former encoding.
      * There are several ways to specify the property file to load, see the different
      * addResourceFamily methods for details.</p>
+     *
      * @author Cesar Martinez Izquierdo (cesar.martinez@iver.es)
+     *
      */
     public class Messages {
         private static class FamilyDescriptor {
             String family = null;
             ClassLoader loader = null;
             String callerName = null;
             public FamilyDescriptor(String family, ClassLoader loader, String callerName ) {
                 this.family  = family;
                 this.loader = loader;
                 this.callerName = callerName;
+            }
+        }
         private static Logger logger = LoggerFactory.getLogger("Messages");
         private static String _CLASSNAME = "org.gvsig.i18n.Messages";
         private static Locale currentLocale;
         /* Each entry will contain a hashmap with translations. Each hasmap
          * contains the translations for one language, indexed by the
          * translation key. The translations for language (i) in the preferred locales
          * list are contained in the position (i) of the localeResources list */
         private static ArrayList localeResources = new ArrayList();
         private static ArrayList preferredLocales = new ArrayList(); // contains the ordered list of prefered languages/locales (class Locale)
         private static Set notTranslatedKeys = new HashSet();
     	/* Set of resource families and classloaders used to load i18n resources. */
     	private static Set resourceFamilies = new HashSet();
     	private static Set classLoaders = new HashSet();
             private static List familyDescriptors = new ArrayList();
     	/*
     	 * The language considered the origin of translations, which will
     	 * (possibly) be stored in a property file without language suffix
     	 * (ie: text.properties instead of text_es.properties).
     	 */
     	private static String baseLanguage = "es";
     	private static Locale baseLocale = new Locale(baseLanguage);
     	/**
     	 * <p>Gets the localized message associated with the provided key.
     	 * If the key is not in the dictionary, return the key and register
     	 * the failure in the log.</p>
+    	 *
     	 * <p>The <code>callerName</code> parameter is only
     	 * used as a label when logging, so any String can be used. However, a
     	 * meaningful String should be used, such as the name of the class requiring
     	 * the translation services, in order to identify the source of the failure
     	 * in the log.</p>
+    	 *
     	 * @param key         An String which identifies the translation that we want to get.
     	 * @param callerName  A symbolic name given to the caller of this method, to
     	 *                    show it in the log if the key was not found
     	 * @return            an String with the message associated with the provided key.
     	 *                    If the key is not in the dictionary, return the key. If the key
     	 *                    is null, return null.
     	 */
     	public static String getText(String key, String callerName) {
     		if (key==null) {
     			return null;
+    		}
     		for (int numLocale=0; numLocale<localeResources.size(); numLocale++) {
     			// try to get the translation for any of the languagues in the preferred languages list
     			String translation = ((Properties)localeResources.get(numLocale)).getProperty(key);
     			if (translation!=null && !translation.equals("")) {
     				return translation;
+    			}
+    		}
                     addNotTranslatedKey(key, callerName, true);
     		return key;
+    	}
     	public static String getText(String key,  String[] arguments, String callerName) {
     		String translation = getText(key, callerName);
     		if (translation!=null && arguments!=null ) {
     			try {
     				translation = MessageFormat.format(translation, arguments);
+    			}
     			catch (IllegalFormatException ex) {
     				logger.error(callerName+" -- Error formating key: "+key+" -- "+translation);
+    			}
+    		}
     		return translation;
+    	}
     	public static String translate(String message, String[] args) {
     		String msg = message;
     		if (msg == null) {
     			return "";
+    		}
     		msg = getText(msg, args);
     		if (msg == null) {
     			msg = "_" + message.replace("_", " ");
+    		}
     		return msg;
+    	}
     	public static String translate(String message) {
     		String msg = message;
     		if (msg == null) {
     			return "";
+    		}
     		msg = getText(msg, (String[]) null);
     		if (msg == null || msg.startsWith("_")) {
     			msg = "_" + message.replace("_", " ");
+    		}
     		return msg;
+    	}
     	/**
     	 * <p>Gets the localized message associated with the provided key.
     	 * If the key is not in the dictionary or the translation is empty,
     	 * return the key and register the failure in the log.</p>
+    	 *
     	 * @param key     An String which identifies the translation that we want to get.
     	 * @return        an String with the message associated with the provided key.
     	 *                If the key is not in the dictionary or the translation is empty,
     	 *                return the key. If the key is null, return null.
     	 */
     	public static String getText(String key) {
     		return getText(key, _CLASSNAME);
+    	}
     	public static String getText(String key, String[] arguments) {
     		return getText(key, arguments, _CLASSNAME);
+    	}
     	/**
     	 * <p>Gets the localized message associated with the provided key.
     	 * If the key is not in the dictionary or the translation is empty,
     	 * it returns null and the failure is only registered in the log if
     	 * the param log is true.</p>
+    	 *
     	 * @param key	An String which identifies the translation that we want
     	 * 				to get.
     	 * @param log	Determines whether log a key failure or not
     	 * @return		an String with the message associated with the provided key,
     	 * 				or null if the key is not in the dictionary or the
     	 * 				translation is empty.
     	 */
     	public static String getText(String key, boolean log) {
     		return getText(key, _CLASSNAME, log);
+    	}
     	public static String getText(String key, String[] arguments, boolean log) {
     		String translation = getText(key, _CLASSNAME, log);
     		if (translation!=null && arguments!=null ) {
     			try {
     				translation = MessageFormat.format(translation, arguments);
     			} catch (IllegalFormatException ex) {
     				if (log) {
     					logger.error(_CLASSNAME+" -- Error formating key: "+key+" -- "+translation);
+    				}
+    			}
+    		}
     		return translation;
+    	}
     	/**
     	 * <p>Gets the localized message associated with the provided key.
     	 * If the key is not in the dictionary, it returns null and the failure
     	 * is only registered in the log if the param log is true.</p>
+    	 *
     	 * @param key         An String which identifies the translation that we want to get.
     	 * @param callerName  A symbolic name given to the caller of this method, to
     	 *                    show it in the log if the key was not found
     	 * @param log         Determines whether log a key failure or not
     	 * @return            an String with the message associated with the provided key,
     	 *                    or null if the key is not in the dictionary.
     	 */
     	public static String getText(String key, String callerName, boolean log) {
     		if (key==null) {
     			return null;
+    		}
     		for (int numLocale=0; numLocale<localeResources.size(); numLocale++) {
     			// try to get the translation for any of the languagues in the preferred languages list
     			String translation = ((Properties)localeResources.get(numLocale)).getProperty(key);
     			if (translation!=null && !translation.equals("")) {
     				return translation;
+    			}
+    		}
                     addNotTranslatedKey(key, callerName, log);
     		return null;
+    	}
     	public static String getText(String key, String[] arguments, String callerName, boolean log) {
     		String translation = getText(key, callerName, log);
     		if (translation!=null) {
     			try {
     				translation = MessageFormat.format(translation, arguments);
+    			}
     			catch (IllegalFormatException ex) {
     				if (log) {
     					logger.error(callerName+" -- Error formating key: "+key+" -- "+translation);
+    				}
+    			}
+    		}
     		return translation;
+    	}
     	/**
     	 * <p>Adds an additional family of resource files containing some translations.
     	 * A family is a group of files with a common baseName.
     	 * The file must be an iso-8859-1 encoded file, which can contain any unicode
     	 * character using unicode escaped sequences, and following the syntax:
     	 * <code>key1=value1
     	 * key2=value2</code>
     	 * where 'key1' is the key used to identify the string and must not
     	 * contain the '=' symbol, and 'value1' is the associated translation.</p>
     	 * <p<For example:</p>
     	 * <code>cancel=Cancelar
     	 * accept=Aceptar</code>
     	 * <p>Only one pair key-value is allowed per line.</p>
+    	 *
     	 * <p>The actual name of the resource file to load is determined using the rules
     	 * explained in the class java.util.ResourceBundle. Summarizing, for each language
     	 * in the specified preferred locales list it will try to load a file with
     	 *  the following structure: <code>family_locale.properties</code></p>
+    	 *
     	 * <p>For example, if the preferred locales list contains {"fr", "es", "en"}, and
     	 * the family name is "text", it will try to load the files "text_fr.properties",
     	 * "text_es.properties" and finally "text_en.properties".</p>
+    	 *
     	 * <p>Locales might be more specific, such us "es_AR"  (meaning Spanish from Argentina)
     	 * or "es_AR_linux" (meaning Linux system preferring Spanish from Argentina). In the
     	 * later case, it will try to load "text_es_AR_linux.properties", then
     	 * "text_es_AR.properties" if the former fails, and finally "text_es.properties".</p>
+    	 *
     	 * <p>The directory used to locate the resource file is determining by using the
     	 * getResource method from the provided ClassLoader.</p>
+    	 *
     	 * @param family    The family name (or base name) which is used to search
     	 *                  actual properties files.
     	 * @param loader    A ClassLoader which is able to find a property file matching
     	 * 					the specified family name and the preferred locales
     	 * @see             <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html">ResourceBundle</a>
     	 */
     	public static void addResourceFamily(String family, ClassLoader loader) {
     		addResourceFamily(family, loader, "");
+    	}
     	/**
     	 * <p>Adds an additional family of resource files containing some translations.
     	 * The search path to locate the files is provided by the dirList parameter.</p>
+    	 *
     	 * <p>See {@link addResourceFamily(String, ClassLoader)} for a discussion about the
     	 * format of the property files and the way to determine the candidat files
     	 * to load. Note that those methods are different in the way to locate the
     	 * candidat files. This method searches in the provided paths (<code>dirList</code>
     	 * parameter), while the referred method searches using the getResource method
     	 * of the provided ClassLoader.</p>
+    	 *
     	 * @param family    The family name (or base name) which is used to search
     	 *                  actual properties files.
     	 * @param dirList   A list of search paths to locate the property files
     	 * @throws MalformedURLException
     	 * @see             <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html">ResourceBundle</a>
     	 */
     	public static void addResourceFamily(String family, File[] dirList) throws MalformedURLException{
     		// use our own classloader
     		URL[] urls = new URL[dirList.length];
     			int i;
     			for (i=0; i<urls.length; i++) {
     				urls[i] = dirList[i].toURL();
+    			}
     		ClassLoader loader = new MessagesClassLoader(urls);
     		addResourceFamily(family, loader, "");
+    	}
     	/**
     	 * <p>Adds an additional family of resource files containing some translations.
     	 * The search path to locate the files is provided by the dir parameter.</p>
+    	 *
     	 * <p>See {@link addResourceFamily(String, ClassLoader)} for a discussion about the
     	 * format of the property files and the way to determine the candidat files
     	 * to load. Note that those methods are different in the way to locate the
     	 * candidat files. This method searches in the provided path (<code>dir</code>
     	 * parameter), while the referred method searches using the getResource method
     	 * of the provided ClassLoader.</p>
+    	 *
     	 * @param family    The family name (or base name) which is used to search
     	 *                  actual properties files.
     	 * @param dir       The search path to locate the property files
     	 * @throws MalformedURLException
     	 * @see             <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html">ResourceBundle</a>
     	 */
     	public static void addResourceFamily(String family, File dir) throws MalformedURLException{
     		// use our own classloader
     		URL[] urls = new URL[1];
     		urls[0] = dir.toURL();
     		ClassLoader loader = new MessagesClassLoader(urls);
     		addResourceFamily(family, loader, "");
+    	}
     	/**
     	 * <p>Adds an additional family of resource files containing some translations.
     	 * The search path is determined by the getResource method from the
     	 * provided ClassLoader.</p>
+    	 *
     	 * <p>This method is identical to {@link addResourceFamily(String, ClassLoader)},
     	 * except that it adds a <pode>callerName</code> parameter to show in the log.</p>
+    	 *
     	 * <p>See {@link addResourceFamily(String, ClassLoader)} for a discussion about the
     	 * format of the property files andthe way to determine the candidat files
     	 * to load.</p>
+    	 *
     	 * @param family      The family name (or base name) which is used to search
     	 *                    actual properties files.
     	 * @param loader      A ClassLoader which is able to find a property file matching
     	 * 					  the specified family name and the preferred locales
     	 * @param callerName  A symbolic name given to the caller of this method, to
     	 *                    show it in the log if there is an error
     	 * @see               <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html">ResourceBundle</a>
     	 */
     	public static void addResourceFamily(String family, ClassLoader loader, String callerName) {
     //		String currentKey;
     //		Enumeration keys;
     		Locale lang;
     //		Properties properties;
     		Properties translations;
     		int totalLocales = preferredLocales.size();
     		if (totalLocales == 0) {
     			// if it's empty, warn about that
     			logger.warn("There is not preferred languages list. Maybe the Messages class was not initialized");
+    		}
                     familyDescriptors.add( new FamilyDescriptor(family,loader,callerName));
     		resourceFamilies.add(family);
     		classLoaders.add(loader);
     		for (int numLocale=0; numLocale<totalLocales; numLocale++) { // for each language
     //			properties =  new Properties();
     			lang = (Locale) preferredLocales.get(numLocale);
     			translations = (Properties) localeResources.get(numLocale);
     			addResourceFamily(lang, translations, family, loader, callerName);
+    		}
+    	}
     	private static void addResourceFamily(Locale lang, Properties translations,
     			String family, ClassLoader loader, String callerName) {
                     logger.debug("addResourceFamily "+lang.toString()+", "+family+", "+loader.toString());
     		Properties properties = new Properties();
     		String langCode = lang.toString();
     		String resource = family.replace('.', '/') + "_" + langCode + ".properties";
                     URL resourceURL = loader.getResource(resource);
     		InputStream is = loader.getResourceAsStream(resource);
     		if( is==null && langCode.contains("_") ) {
     			try {
     				langCode = langCode.split("_")[0];
     				resource = family.replace('.', '/') + "_" + langCode + ".properties";
                                     resourceURL = loader.getResource(resource);
     				is = loader.getResourceAsStream(resource);
     				if( is==null ) {
     					resource = family.replace('.', '/') +  ".properties";
                                             resourceURL = loader.getResource(resource);
     					is = loader.getResourceAsStream(resource);
+    				}
     			} catch(Exception ex) {
     				// Do nothing, is are null and are handled later
+    			}
+    		}
     		if (is != null) {
     			try {
     				properties.load(is);
     			} catch (IOException e) {
+    			}
     		} else if (lang.equals(baseLocale)) {
     			// try also "text.properties" for the base language
     			is = loader.getResourceAsStream(family.replace('.', '/')
     					+ ".properties");
     			if (is != null) {
     				try {
     					properties.load(is);
     				} catch (IOException e) {
+    				}
+    			}
+    		}
                     if( resourceURL!=null && logger.isDebugEnabled() ) {
                         logger.debug("Load resources from '"+resourceURL.toString()+"' with classloader {"+loader.toString()+"}.");
+                    }
     		Enumeration keys = properties.keys();
     		while (keys.hasMoreElements()) {
     			String currentKey = (String) keys.nextElement();
     			if (!translations.containsKey(currentKey)) {
     				translations.put(currentKey, properties.getProperty(currentKey));
+    			}
+    		}
+    	}
     	/**
     	 * <p>Adds an additional family of resource files containing some translations.</p>
+    	 *
     	 * <p>This method is identical to {@link addResourceFamily(String, ClassLoader, String)},
     	 * except that it uses the caller's class loader.</p>
+    	 *
     	 * <p>See {@link addResourceFamily(String, ClassLoader)} for a discussion about the
     	 * format of the property files and the way to determine the candidat files
     	 * to load.</p>
+    	 *
     	 * @param family      The family name (or base name) which is used to search
     	 *                    actual properties files.
     	 * @param callerName  A symbolic name given to the caller of this method, to
     	 *                    show it in the log if there is an error. This is only used
     	 *                    to show
     	 *                    something meaningful in the log, so you can use any string
     	 * @see               <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/util/ResourceBundle.html">ResourceBundle</a>
     	 */
     	public static void addResourceFamily(String family, String callerName) {
     		addResourceFamily(family, Messages.class.getClassLoader(), callerName);
+    	}
     	/**
     	 * Returns an ArrayList containing the ordered list of prefered Locales
     	 * Each element of the ArrayList is a Locale object.
+    	 *
     	 * @return an ArrayList containing the ordered list of prefered Locales
     	 * Each element of the ArrayList is a Locale object.
     	 */
     	public static ArrayList getPreferredLocales() {
     		return preferredLocales;
+    	}
     	/**
     	 * <p>Sets the ordered list of preferred locales.
     	 * Each element of the ArrayList is a Locale object.</p>
+    	 *
     	 * <p>Note that calling this method does not load any translation, it just
     	 * adds the language to the preferred locales list, so this method must
     	 * be always called before the translations are loaded using
     	 * the addResourceFamily() methods.</p>
+    	 *
     	 * <p>It there was any language in the preferred locale list, the language
     	 * and its associated translations are deleted.</p>
+    	 *
+    	 *
     	 * @param preferredLocales an ArrayList containing Locale objects.
     	 * The ArrayList represents an ordered list of preferred locales
     	 */
     	public static void setPreferredLocales(ArrayList preferredLocalesList) {
                     logger.info("setPreferredLocales "+preferredLocalesList.toString());
     		// delete all existing locales
     		Iterator oldLocales = preferredLocales.iterator();
     		while (oldLocales.hasNext()) {
     			removeLocale((Locale) oldLocales.next());
+    		}
     		// add the new locales now
     		for (int numLocale=0; numLocale < preferredLocalesList.size(); numLocale++) {
     			addLocale((Locale) preferredLocalesList.get(numLocale));
+    		}
+    	}
             public static Locale getCurrentLocale() {
                 return currentLocale;
+            }
             /**
+             *
              * @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[]) {
                 logger.info("setCurrentLocale "+locale.toString());
                 resourceFamilies = new HashSet();
                 classLoaders = new HashSet();
                 localeResources = new ArrayList();
                 preferredLocales = new ArrayList();
                 notTranslatedKeys = new HashSet();
                 addLocale(locale);
                 for( int i=0 ; i<alternatives.length; i++ ) {
                     addLocale(alternatives[i]);
+                }
                 for( int curlocale=0; curlocale<preferredLocales.size(); curlocale++) {
                     for( int curfamily=0; curfamily<familyDescriptors.size(); curfamily++) {
                          FamilyDescriptor family = (FamilyDescriptor) familyDescriptors.get(curfamily);
                          addResourceFamily(
                                  (Locale) preferredLocales.get(curlocale),
                                  (Properties) localeResources.get(curlocale),
                                  family.family,
                                  family.loader,
                                  family.callerName);
+                    }
+                }
                 currentLocale = locale;
                 Locale.setDefault(locale);
+            }
     	/**
     	 * Adds a Locale at the end of the ordered list of preferred locales.
     	 * Note that calling this method does not load any translation, it just
     	 * adds the language to the preferred locales list, so this method must
     	 * be always called before the translations are loaded using
     	 * the addResourceFamily() methods.
+    	 *
     	 * @param lang   A Locale object specifying the locale to add
     	 */
     	public static void addLocale(Locale lang) {
     		if (!preferredLocales.contains(lang)) { // avoid duplicates
                         logger.info("addLocale "+lang.toString());
                         preferredLocales.add(lang); // add the lang to the ordered list of preferred locales
                         Properties dict = new Properties();
                         localeResources.add(dict); // add a hashmap which will contain the translation for this language
+    		}
+    	}
     	/**
     	 * Removes the specified Locale from the list of preferred locales and the
     	 * translations associated with this locale.
+    	 *
     	 * @param lang   A Locale object specifying the locale to remove
     	 * @return       True if the locale was in the preferred locales list, false otherwise
     	 */
     	public static boolean removeLocale(Locale lang) {
     		int numLocale = preferredLocales.indexOf(lang);
     		if (numLocale!=-1) { // we found the locale in the list
     			try {
     				preferredLocales.remove(numLocale);
     				localeResources.remove(numLocale);
+    			}
     			catch (IndexOutOfBoundsException ex) {
     				logger.warn(_CLASSNAME + "." + "removeLocale: " + ex.getLocalizedMessage(), ex);
+    			}
     			return true;
+    		}
     		return false;
+    	}
     	/**
     	 * Cleans the translation tables (removes all the translations from memory).
     	 */
     	public static void removeResources() {
     		for (int numLocale=0; numLocale<localeResources.size(); numLocale++) {
     			((Properties)localeResources.get(numLocale)).clear();
+    		}
+    	}
     	/**
     	 * The number of translation keys which have been loaded till now
     	 * (In other words: the number of available translation strings).
+    	 *
     	 * @param lang The language for which we want to know the number of translation keys
     	 * return The number of translation keys for the provided language.
     	 */
     	protected static int size(Locale lang) {
     		int numLocale = preferredLocales.indexOf(lang);
     		if (numLocale!=-1) {
     			return ((Properties)localeResources.get(numLocale)).size();
     		};
     		return 0;
+    	}
     	protected static Set keySet(Locale lang) {
     		int numLocale = preferredLocales.indexOf(lang);
     		if (numLocale!=-1) {
     			return ((Properties)localeResources.get(numLocale)).keySet();
     		} else {
     			return null;
+    		}
+    	}
     	/**
     	 * Checks if some locale has been added to the preferred locales
     	 * list, which is necessary before loading any translation because
     	 * only the translations for the preferred locales are loaded.
+    	 *
     	 * @return
     	 */
     	public static boolean hasLocales() {
     		return preferredLocales.size()>0;
+    	}
     	/**
     	 * Gets the base language, the language considered the origin of
     	 * translations, which will be (possibly) stored in a property
     	 * file without language suffix
     	 * (ie: text.properties instead of text_es.properties).
     	 */
     	public static String getBaseLanguage() {
     		return baseLanguage;
+    	}
     	/**
     	 * Sets the base language, the language considered the origin of
     	 * translations, which will be (possibly)
     	 * stored in a property file without language suffix
     	 * (ie: text.properties instead of text_es.properties).
+    	 *
     	 * @param lang The base language to be set
     	 */
     	public static void setBaseLanguage(String lang) {
     		baseLanguage = lang;
     		baseLocale = new Locale(baseLanguage);
+    	}
     	/*
     	 * Searches the subdirectories of the provided directory, finding
     	 * all the translation files, and constructing a list of available translations.
     	 * It reports different country codes or variants, if available.
     	 * For example, if there is an en_US translation and an en_GB translation, both
     	 * locales will be present in the Vector.
+    	 *
     	 * @return
     	 */
     	/**
+    	 *
     	 * @return A Vector containing the available locales. Each element is a Locale object
     	 */
     	/*public static Vector getAvailableLocales() {
     		return _availableLocales;
     	}*/
     	/**
+    	 *
     	 * @return A Vector containing the available languages. Each element is an String object
     	 */
     	/*public static Vector getAvailableLanguages() {
     		Vector availableLanguages = new Vector();
     		Locale lang;
     		Enumeration locales = _availableLocales.elements();
     		while (locales.hasMoreElements()) {
     			lang = (Locale) locales.nextElement();
     			availableLanguages.add(lang.getLanguage());
+    		}
     		return availableLanguages;
     	}*/
     	public static Properties getAllTexts(Locale lang) {
     		Properties texts = new Properties();
     		getAllTexts(lang, null, texts);
     		for (Iterator iterator = classLoaders.iterator(); iterator.hasNext();) {
     			getAllTexts(lang, (ClassLoader) iterator.next(), texts);
+    		}
     		return texts;
+    	}
     	private static void getAllTexts(Locale lang, ClassLoader classLoader,
     			Properties texts) {
     		ClassLoader loader = classLoader == null ? Messages.class
     				.getClassLoader() : classLoader;
     		for (Iterator iterator = resourceFamilies.iterator(); iterator
     				.hasNext();) {
     			String family = (String) iterator.next();
     			addResourceFamily(lang, texts, family, loader,
     					"Messages.getAllTexts");
+    		}
+    	}
             public static Properties getTranslations(Locale locale) {
     		Properties translations = new Properties();
                     for( int curfamily=0; curfamily<familyDescriptors.size(); curfamily++) {
                          FamilyDescriptor family = (FamilyDescriptor) familyDescriptors.get(curfamily);
                          addResourceFamily(
                                  locale,
                                  translations,
                                  family.family,
                                  family.loader,
                                  family.callerName);
+                    }
                     return translations;
+            }
             private static void addNotTranslatedKey(String key, String callerName, boolean log) {
                 if (!notTranslatedKeys.contains(key)) {
                     if( log ) {
                         logger.info("[" + callerName + "] Cannot find translation for key '" + key + "'.");
+                    }
                     notTranslatedKeys.add(key);
+                }
+            }
             public static List getNotTranslatedKeys() {
                 List l = new ArrayList(notTranslatedKeys);
                 return l;
+            }
+    }

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n;
     import org.gvsig.i18n.tools.impl.DefaultI18Manager;
     import org.gvsig.tools.ToolsLibrary;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.library.AbstractLibrary;
     import org.gvsig.tools.library.LibraryException;
     /**
      * This library is in charge of providing a richer translation manager than the
      * one used by default.
+     *
+     *
      * @author christian
+     *
      */
     public class MessagesLibrary extends AbstractLibrary {
     	public void doRegistration() {
     		super.doRegistration();
     		this.registerAsServiceOf(ToolsLibrary.class);
     		require(ToolsLocator.class);
+    	}
     	protected void doInitialize() throws LibraryException {
     		ToolsLocator.registerI18nManager(DefaultI18Manager.class);
+    	}
     	protected void doPostInitialize() throws LibraryException {
             // Nothing to do
+    	}
+    }

     <?xml version="1.0" encoding="ISO-8859-1"?>
     <!--
         gvSIG. Desktop Geographic Information System.
         Copyright (C) 2007-2013 gvSIG Association.
         This program is free software; you can redistribute it and/or
         modify it under the terms of the GNU General Public License
         as published by the Free Software Foundation; either version 3
         of the License, or (at your option) any later version.
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
         You should have received a copy of the GNU General Public License
         along with this program; if not, write to the Free Software
         Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
         MA  02110-1301, USA.
         For any additional information, do not hesitate to contact us
         at info AT gvsig.com, or visit our website www.gvsig.com.
     -->
     <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en-US" lang="en-US">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
     <title>org.gvsig.i18n package</title>
     </head>
     <body>
     <p>Provides classes which offer some methods to provide internationalization services
     to other projects. Currently, it only consist on the Messages class and the auxiliary
     MessagesClassLoader class.</p>
     </body>
     </html>

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n.templates;
     import java.util.Locale;
     /**
     * Bridge class to provide internationalization services to the library.
     * It uses the gvsig-i18n library as a backend, and includes its
     * necessary initialization.
+    *
     * @author Cesar Martinez Izquierdo
+    *
     */
     public class MessagesTemplate {
     	/**
     	 * Whether the class has been initialized
     	 */
     	private static boolean isInitialized = false;
     	/**
     	 * The name of the Java package containing this class
     	 */
     	private static final String packageName = MessagesTemplate.class.getPackage().getName();
     	/**
     	 * Loads the translations in the dictionary. It initializes the backend
     	 * gvsig-i18n library
+    	 *
     	 */
     	private static void init() {
     		if (!org.gvsig.i18n.Messages.hasLocales()) {
     			org.gvsig.i18n.Messages.addLocale(Locale.getDefault());
+    		}
     		org.gvsig.i18n.Messages.addResourceFamily(packageName+".resources.translations.text", MessagesTemplate.class.getClassLoader(), packageName);
+    	}
     	/**
     	 * Gets the translation associated with the provided translation key.
+    	 *
     	 * @param key The translation key which identifies the target text
     	 * @return The translation associated with the provided translation key.
     	 */
     	public static String getText(String key) {
     		if (isInitialized==false) {
     			init();
     			isInitialized = true;
+    		}
     		return org.gvsig.i18n.Messages.getText(key, packageName);
+    	}
+    }

     #Translations for language [fr]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Accepter
     Las_traducciones_no_pudieron_ser_cargadas=Les traductions ne peuvent pas \u00eatre charg\u00e9es.
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=Impossible de trouver la liste des langues pr\u00e9f\u00e9r\u00e9es. Vous avez peut-\u00eatre oubli\u00e9 d'installer la classe.
     No_se_encontro_la_traduccion_para=Impossible de trouver les traductions pour

     #Translations for language [de]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=OK
     Las_traducciones_no_pudieron_ser_cargadas=
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=
     No_se_encontro_la_traduccion_para=Konnte \u00dcbersetzung nicht finden f\u00fcr\:

     #Translations for language [eu]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Ados
     Las_traducciones_no_pudieron_ser_cargadas=Itzulpenak ezin izan dira kargatu
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=\=Ez da hobetsitako hizkuntzen zerrenda aurkitu. Agian klasea hasieratzea ahaztu zaizu
     No_se_encontro_la_traduccion_para=Ez da itzulpenik aurkitu honetarako\:

     #Translations for language [it]
     #Tue Nov 07 12:30:01 CET 2006
     aceptar=Accetta
     Las_traducciones_no_pudieron_ser_cargadas=
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=
     No_se_encontro_la_traduccion_para=Non si \u00e9 incontrata la traduzione per

     #Translations for language [es]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Aceptar
     Las_traducciones_no_pudieron_ser_cargadas=Las traducciones no pudieron ser cargadas
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=No hay lista de idiomas preferidos. Quiza olvido inicializar la clase
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=No hay lista de idiomas preferidos. Quiz\u00e1 olvid\u00f3 inicializar la clase.
     No_se_encontro_la_traduccion_para=No se encontr\u00f3 la traducci\u00f3n para

tags/org.gvsig.desktop-2.0.86/org.gvsig.desktop.compat.cdc/org.gvsig.i18n/src/main/resources/META-INF/services/org.gvsig.tools.library.Library
	1	org.gvsig.i18n.MessagesLibrary

     #Translations for language [en]
     #Wed Nov 08 12:31:46 CET 2006
     =\=\=\=\=\=\=
     <<<<<<<=text_en.properties
     >>>>>>>=1.6
     aceptar=Accept
     Las_traducciones_no_pudieron_ser_cargadas=Translations couldn't be loaded
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=There is no list of favorite languages probably you forgot initialice the class
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=There is not preferred languages list. Maybe the Messages class was not initiated
     No_se_encontro_la_traduccion_para=Cannot find translation for

     #Translations for language [gl]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Aceptar
     Las_traducciones_no_pudieron_ser_cargadas=As traducci\u00f3ns non se puideron cargar
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=Non se atopou a lista de idiomas preferidos.Quiz\u00e1s non se lembrou de inicializar a clase
     No_se_encontro_la_traduccion_para=Non se atopou a traducci\u00f3n para

     #Translations for language [ca]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Acceptar
     Las_traducciones_no_pudieron_ser_cargadas=Les traduccions no s'han pogut carregar
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=No s'ha trobat la llista d'idiomes preferits. Potser ha oblidat inicialitzar la classe
     No_se_encontro_la_traduccion_para=No s'ha trobat la traducci\u00f3 per a

     #Translations for language [pt]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Aceitar
     Las_traducciones_no_pudieron_ser_cargadas=
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=
     No_se_encontro_la_traduccion_para=N\u00e3o se encontrou a tradu\u00e7\u00e3o de

     #Translations for language [cs]
     #Mon Oct 30 09:38:21 CET 2006
     aceptar=Budi\u017e
     Las_traducciones_no_pudieron_ser_cargadas=
     No.hay.lista.de.idiomas.preferidos.quiza.olvido.inicializar.clase=
     No_hay_lista_de_idiomas_preferidos_quiza_olvido_inicializar_clase=
     No_se_encontro_la_traduccion_para=Nelze nal\u00e9zt p\u0159eklad pro

tags/org.gvsig.desktop-2.0.86/org.gvsig.desktop.compat.cdc/org.gvsig.i18n/src/test/java/org/gvsig/i18n/dataset1/text.properties
	1	#text.properties
	2	aceptar=Aceptar
	3	cancelar=Cancelar
	4	Cascada=Cascada
	5	cascada_enable=Debe haber al menos una ventana abierta
0	6

tags/org.gvsig.desktop-2.0.86/org.gvsig.desktop.compat.cdc/org.gvsig.i18n/src/test/java/org/gvsig/i18n/dataset1/text_en.properties
	1	#text_en.properties
	2	aceptar=OK
	3	cancelar=Cancel
	4	Cascada=Cascade
	5	ventana=Window
	6	otro=other
0	7

tags/org.gvsig.desktop-2.0.86/org.gvsig.desktop.compat.cdc/org.gvsig.i18n/src/test/java/org/gvsig/i18n/dataset1/text_fr.properties
	1	#text_fr.properties
	2	aceptar=Accepter
	3	Cascada=Cascade
	4	Configurar=Configurer
0	5

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
      * as published by the Free Software Foundation; either version 3
      * of the License, or (at your option) any later version.
+     *
      * This program is distributed in the hope that it will be useful,
      * but WITHOUT ANY WARRANTY; without even the implied warranty of
      * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      * GNU General Public License for more details.
+     *
      * You should have received a copy of the GNU General Public License
      * along with this program; if not, write to the Free Software
      * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
      * MA  02110-1301, USA.
+     *
      * For any additional information, do not hesitate to contact us
      * at info AT gvsig.com, or visit our website www.gvsig.com.
      */
     package org.gvsig.i18n;
     import java.io.File;
     import java.net.MalformedURLException;
     import java.util.ArrayList;
     import java.util.Locale;
     import junit.framework.TestCase;
     /**
      * @author cesar
+     *
      */
     public class TestMessages extends TestCase {
     	/*
     	 * @see TestCase#setUp()
     	 */
     	protected void setUp() throws Exception {
     		super.setUp();
+    	}
     	/*
     	 * @see TestCase#tearDown()
     	 */
     	protected void tearDown() throws Exception {
     		super.tearDown();
+    	}

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff