/[schmitzm]/trunk/src/skrueger/i8n/Translation.java
ViewVC logotype

Diff of /trunk/src/skrueger/i8n/Translation.java

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 243 by alfonx, Tue Jul 28 12:40:08 2009 UTC revision 1373 by alfonx, Wed Jan 19 12:59:51 2011 UTC
# Line 1  Line 1 
1  package skrueger.i8n;  /*******************************************************************************
2     * Copyright (c) 2009 Martin O. J. Schmitz.
3  import java.beans.PropertyChangeEvent;   *
4  import java.beans.PropertyChangeListener;   * This file is part of the SCHMITZM library - a collection of utility
5  import java.util.ArrayList;   * classes based on Java 1.6, focusing (not only) on Java Swing
6  import java.util.HashMap;   * and the Geotools library.
7  import java.util.List;   *
8  import java.util.Locale;   * The SCHMITZM project is hosted at:
9     * http://wald.intevation.org/projects/schmitzm/
10  import javax.swing.JComponent;   *
11  import javax.swing.JTable;   * This program is free software; you can redistribute it and/or
12     * modify it under the terms of the GNU Lesser General Public License
13  import org.apache.log4j.Logger;   * as published by the Free Software Foundation; either version 3
14     * of the License, or (at your option) any later version.
15  /**   *
16   * Represents a {@link HashMap} of translations. toString() returns the   * This program is distributed in the hope that it will be useful,
17   * appropriate translation   * but WITHOUT ANY WARRANTY; without even the implied warranty of
18   *   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19   * @author @author <a href="mailto:[email protected]">Stefan Alfons   * GNU General Public License for more details.
20   *         Kr&uuml;ger</a>   *
21   */   * You should have received a copy of the GNU Lesser General Public License (license.txt)
22     * along with this program; if not, write to the Free Software
23  public class Translation extends HashMap<String, String> {   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
24          public static final String LOCALECHANGE_PROPERTY = "localechange";   * or try this link: http://www.gnu.org/licenses/lgpl.html
25          public static final String NO_TRANSLATION = "NO TRANSLATION";   *
26          public static final String DEFAULT_KEY = "default";   * Contributors:
27          static final Logger log = Logger.getLogger(Translation.class);   *     Martin O. J. Schmitz - initial API and implementation
28          static String activeLang = "fr";   *     Stefan A. Tzeggai - additional utility classes
29     ******************************************************************************/
30          static protected List<PropertyChangeListener> listeners = new ArrayList<PropertyChangeListener>();  package skrueger.i8n;
31    
32          static {  import java.awt.event.ActionEvent;
33    import java.awt.event.ActionListener;
34                  // TODO default aus Locale auslesen und mit möglichen vergleichen...  import java.beans.PropertyChangeEvent;
35                  // mmm.. vor laden von atlasml immer DEFAULT_KEY, also hier nicht  import java.beans.PropertyChangeListener;
36    import java.io.Serializable;
37                  // Get default locale  import java.util.ArrayList;
38                  Locale locale = Locale.getDefault();  import java.util.HashMap;
39                  setActiveLang(locale.getLanguage());  import java.util.Iterator;
40          }  import java.util.List;
41    import java.util.Locale;
42          @Override  import java.util.Random;
43          /*  import java.util.Set;
44           * @comment To make a copy of a translation see methods toOneLine() and  import java.util.WeakHashMap;
45           * fromOneLine()  
46           */  import javax.swing.JComponent;
47          public Translation clone() {  
48                  return (Translation) super.clone();  import org.apache.log4j.Logger;
49          }  import org.geotools.util.WeakHashSet;
50    import org.opengis.util.InternationalString;
51          /**  
52           * Get the two-letter language sting that is active  import schmitzm.lang.ResourceProvider;
53           */  import schmitzm.lang.SortableVector;
54          public static String getActiveLang() {  import skrueger.geotools.Copyable;
55                  return activeLang;  
56          }  /**
57     * Represents a {@link HashMap} of translations. toString() returns the
58          /**   * appropriate translation. This class is mutable.
59           * Set up the {@link Translation}-system to use language. If a change is   *
60           * performed, events are fired to listeners. Nothing is done if the new   * @author <a href="mailto:[email protected]">Stefan Alfons Tzeggai</a>
61           * language equals the old language. The system's default locale is changed.   */
62           *  
63           * @param newLang  public class Translation extends HashMap<String, String> implements
64           *            The ISO Code of the new active language                  Copyable<Translation>, Serializable, Cloneable {
65           */  
66          public static void setActiveLang(String newLang) {          private static final long serialVersionUID = -347702744122305245L;
67                  setActiveLang(newLang, true);  
68          }          public static final String LOCALE_CHANGE_PROPERTY = "localechange";
69            public static final String ACTIVELANG_CHANGE_PROPERTY = "activelangchange";
70          /**          public static final String NO_TRANSLATION = "NO TRANSLATION";
71           * Set up the {@link Translation}-system to use language. If a change is          public static final String DEFAULT_KEY = "default";
72           * performed, events are fired to listeners. Nothing is done if the new          static final Logger LOGGER = Logger.getLogger(Translation.class);
73           * language equals the old language.  
74           *          /** A static field defining which language should be served **/
75           * @param newLang          static String activeLang = Locale.getDefault().getLanguage();
76           *            The ISO Code of the new active language  
77           *          /**
78           * @param setDefaultLocale           * A {@link WeakHashSet} of {@link PropertyChangeListener} that will be
79           *            Shall the system's default locale be changed?           * informed if the acitveLang has been changed with a setActiveLang(..,true
80           */           * or false).
81          public static void setActiveLang(String newLang, boolean setDefaultLocale) {           */
82                  if (getActiveLang().equals(newLang)) {          static protected WeakHashSet<PropertyChangeListener> listenersActiveLangChange = new WeakHashSet<PropertyChangeListener>(
83                          return;                          PropertyChangeListener.class);
84                  }  
85            /**
86                  if (!I8NUtil.isValidISOLangCode(newLang)) {           * A {@link WeakHashSet} of {@link PropertyChangeListener} that will be
87                          throw new IllegalArgumentException("'" + newLang           * informed if the Locale has been changed due to a setActiveLang(..,true)
88                                          + "' is not a valid ISO language code.");           */
89                  }          static protected WeakHashSet<PropertyChangeListener> listenersLocaleChange = new WeakHashSet<PropertyChangeListener>(
90                            PropertyChangeListener.class);
91                  Locale newLocale = new Locale(newLang);  
92                  if (setDefaultLocale)          /**
93                          Locale.setDefault(newLocale);           * A {@link WeakHashSet} of {@link PropertyChangeListener} that will be
94             * informed if any of the translations changed. TODO: Should be registerable
95                  /**           * for specific languages
96                   * Setting default locale for Swing JComponents to work around bug           */
97                   * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4884480          private final WeakHashSet<ActionListener> changeListeners = new WeakHashSet<ActionListener>(
98                   */                          ActionListener.class);
99                  JComponent.setDefaultLocale(newLocale);  
100            static {
101                  Translation.activeLang = newLang;                  // Get default locale
102                    Locale locale = Locale.getDefault();
103                  fireLocaleChangeEvents();                  setActiveLang(locale.getLanguage());
104            }
105                  log.info("skrueger.i8n.Translation switched ActiveLang to " + newLang);  
106          }          @Override
107            /**
108          /**           * implemented using #toOneLine and #fromOneLine
109           * Initializes a new {@link Translation} with a default translation if a           */
110           * simple text is passed. If a "oneLine" text is parsed, it is interpreted.          public Translation clone() {
111           * Other translations may be added later - this is a HashMap<br/>                  Translation clone = new Translation();
112           *                  clone.fromOneLine(toOneLine());
113           * @param defaultTranslation                  return clone;
114           *          }
115           * @see public Translation(List<String> languages, String  
116           *      defaultTranslation) {          /**
117           *           * Get the two-letter language sting that is active
118           */           */
119          public Translation(String defaultTranslation) {          public static String getActiveLang() {
120                    return activeLang;
121                  fromOneLine(defaultTranslation);          }
122    
123          }          /**
124             * Set up the {@link Translation}-system to use language. If a change is
125          /**           * performed, events are fired to listeners. Nothing is done if the new
126           * Initializes a new {@link Translation}, an uses the given String to           * language equals the old language. The system's default {@link Locale} is
127           * initialize the {@link Translation} for all languages codes passed.           * changed.
128           *           *
129           * The translations can be changed later           * @param newLang
130           */           *            The ISO Code of the new active language
131          public Translation(List<String> languages, String defaultTranslation) {           */
132                  // put(DEFAULT_KEY, defaultTranslation);          public static void setActiveLang(String newLang) {
133                  if (languages == null) {                  setActiveLang(newLang, true);
134                          put(DEFAULT_KEY, defaultTranslation);          }
135                  } else  
136                          for (String code : languages) {          /**
137                                  if (code.equals(getActiveLang())) {           * Set up the {@link Translation}-system to use language. If a change is
138                                          put(code, defaultTranslation);           * performed, events are fired to listeners. Nothing is done if the new
139                                  }           * language equals the old language.
140                          }           *
141          }           * @param newLang
142             *            The ISO Code of the new active language
143          /**           *
144           * Sometimes Translations are optional, like for keywords.           * @param setDefaultLocale
145           */           *            Shall the system's default locale be changed?
146          public Translation() {           */
147          }          public static void setActiveLang(String newLang, boolean setDefaultLocale) {
148                    if (getActiveLang().equals(newLang)) {
149          /**                          return;
150           * Fills the {@link Translation} with the values coded into the String                  }
151           * Format of {@link String} is: "de{Baum}en{tree}"  
152           * <p>                  if (!I8NUtil.isValidISOLangCode(newLang)) {
153           * <ul>  
154           * <li>If <code>oneLineCoded</code> is empty or null, NO TRANSLATION is set.                          if (!I8NUtil.isPropertiesLanguage(newLang)) {
155           * <li>If format can't be recognized, the {@link String} is interpreted as                                  throw new IllegalArgumentException(
156           * the translation in the <code>{@value #DEFAULT_KEY}</code> language                                                  "'"
157           *                                                                  + newLang
158           * @author Stefan Alfons Krüger                                                                  + "' is not a valid ISO language code, nor is it a valid userdefined Properties code.");
159           */                          }
160          public void fromOneLine(final String oneLineCoded) {  
161                  clear();                  }
162                  if ((oneLineCoded == null) || (oneLineCoded.equals(""))) {  
163                          put(DEFAULT_KEY, "");                  Translation.activeLang = newLang;
164                          return;                  fireActiveLangChangeEvents();
165                  }  
166                    Locale newLocale = new Locale(newLang);
167                  if (oneLineCoded.indexOf("}") == -1) {                  if (setDefaultLocale) {
168                          // log.warn("The String '"+oneLineCoded+"' is not in oneLine coded => put(DEFAULT_KEY,oneLineCoded);");  
169                          put(DEFAULT_KEY, oneLineCoded);                          setDefaultLocale(newLocale);
170                  }  
171                            LOGGER.info(Translation.class.getName()
172                  String eatUp = oneLineCoded;                                          + " switched ActiveLang and Locale to " + newLang);
173                  while (eatUp.indexOf("}") != -1) {                  } else {
174                          String substring = eatUp.substring(0, eatUp.indexOf("}"));                          LOGGER.info(Translation.class.getName()
175                                            + " switched ActiveLang to " + newLang);
176                          // log.debug("substring = "+substring);                  }
177                          String key = substring.substring(0, substring.indexOf("{"));  
178                          String value = substring.substring(substring.indexOf("{") + 1,          }
179                                          substring.length());  
180                          // log.debug("key="+key);          /**
181                          // log.debug("value="+value);           * Initializes a new {@link Translation} with a default translation if a
182                          put(key, value);           * simple text is passed. If a "oneLine" text is parsed, it is interpreted.
183                          eatUp = eatUp.substring(eatUp.indexOf("}") + 1);           * Other translations may be added later - this is a HashMap<br/>
184                  }           *
185          }           * @param defaultTranslation
186             *
187          /**           * @see public Translation(List<String> languages, String
188           * Exports the Translations to a String of the Format: "de{Baum}en{tree}"           *      defaultTranslation) {
189           *           *
190           * @author Stefan Alfons Krüger           */
191           */          public Translation(String defaultTranslation) {
192          public String toOneLine() {  
193                  return I8NUtil.toOneLine(this);                  fromOneLine(defaultTranslation);
194          }  
195            }
196          /**  
197           * Returns the right translation by using the {@link #activeLang} field. If          /**
198           * no translation is set, an ugly String {@link #NO_TRANSLATION} will re           * Initializes a new {@link Translation}, an uses the given String to
199           * returned. This might be changed for the final release. If the correct           * initialize the {@link Translation} for all languages codes passed. The
200           * language was not found, any entry in the {@link Translation}           * translations can be changed later. This class is not immutable.
201           * {@link HashMap} will be returned, that contains more than an empty           *
202           * string.           * @param languages
203           */           *            if empty or null, the given default {@link Translation} till
204          @Override           *            be stored under a special key {@link #DEFAULT_KEY}
205          public String toString() {           *
206                  if (get(activeLang) != null) {           *
207                          return get(activeLang);           */
208                  }          public Translation(List<String> languages, String defaultTranslation) {
209                  // ****************************************************************************                  if (languages == null || languages.isEmpty()) {
210                  // MS: The ISDSS needs the concept of the default lang!! So I took the                          put(DEFAULT_KEY, defaultTranslation);
211                  // following in again!!                  } else
212                  // ****************************************************************************                          for (String code : languages) {
213                  // else return "";                                  put(code, defaultTranslation);
214                  // //****************************************************************************                          }
215                  // // The following is commented out.. the concept of the default lang          }
216                  // seems to be bad....  
217                  // //****************************************************************************          /**
218                  // MS:           * Sometimes Translations are optional, like for keywords.
219                  else {           */
220                          if (get(DEFAULT_KEY) != null) {          public Translation() {
221                                  // log.debug("default lang returned, cuz the translation to "+activeLang+" was not found. Schmeiss raus martin, wenn du das mit der default trans geklärt hast.");          }
222                                  return get(DEFAULT_KEY);  
223                          }          /**
224             * Fills the {@link Translation} with the values coded into the String
225                          // log.debug("return first best <> '' ");           * Format of {@link String} is: "de{Baum}en{tree}"
226                          if (size() > 0)           * <p>
227                                  for (String s : values()) {           * <ul>
228                                          if ((s != null) && (s.trim().length() > 0))           * <li>If <code>oneLineCoded</code> is empty or null, NO TRANSLATION is set.
229                                                  return s;           * <li>If format can't be recognized, the {@link String} is interpreted as
230                                  }           * the translation in the <code>{@value #DEFAULT_KEY}</code> language
231                  }           *
232  //              log.warn("No translation found!");           * @author Stefan Alfons Tzeggai
233                  return NO_TRANSLATION;           */
234          }          public void fromOneLine(final String oneLineCoded) {
235    
236          /**                  clear();
237           * Copy this {@link Translation} to another {@link Translation} e.g. for  
238           * editing                  try {
239           *  
240           * @return the destination {@link Translation}                          if ((oneLineCoded == null) || (oneLineCoded.equals(""))) {
241           */                                  put(DEFAULT_KEY, "");
242          public Translation copy(Translation backup) {                                  return;
243                  if (backup == null)                          }
244                          throw new IllegalArgumentException(  
245                                          "Target translation may not be null.");                          if (oneLineCoded.indexOf("}") == -1) {
246                  for (String s : keySet()) {                                  // log.warn("The String '"+oneLineCoded+"' is not in oneLine coded => put(DEFAULT_KEY,oneLineCoded);");
247                          backup.put(s, get(s));                                  put(DEFAULT_KEY, oneLineCoded);
248                  }                          }
249                  return backup;  
250          }                          String eatUp = oneLineCoded;
251                            while (eatUp.indexOf("}") != -1) {
252          /**                                  String substring = eatUp.substring(0, eatUp.indexOf("}"));
253           * {@link PropertyChangeListener} can be registered to be informed when the  
254           * {@link Locale} changed.                                  // log.debug("substring = "+substring);
255           *                                  String key = substring.substring(0, substring.indexOf("{"));
256           * @param propertyChangeListener                                  String value = substring.substring(substring.indexOf("{") + 1,
257           */                                                  substring.length());
258          public static void addLocaleChangeListener(                                  // log.debug("key="+key);
259                          PropertyChangeListener propertyChangeListener) {                                  // log.debug("value="+value);
260                  listeners.add(propertyChangeListener);                                  put(key, value);
261          }                                  eatUp = eatUp.substring(eatUp.indexOf("}") + 1);
262                            }
263          /**                  } catch (Exception e) {
264           * Informs all registered {@link PropertyChangeListener}s about a change of                          LOGGER.warn("Error while reading the oneLineCode '" + oneLineCoded
265           * the the {@link Locale}.                                          + "'", e);
266           */                          LOGGER.warn("Translation will be empty!");
267          public static void fireLocaleChangeEvents() {                  }
268                  PropertyChangeEvent pce = new PropertyChangeEvent(new Translation(          }
269                                  new ArrayList<String>(), "fakeSource"), LOCALECHANGE_PROPERTY,  
270                                  null, getActiveLang());          /**
271                  for (PropertyChangeListener pcl : listeners) {           * Exports the Translations to a String of the Format: "de{Baum}en{tree}"
272                          if (pcl != null)           *
273                                  pcl.propertyChange(pce);           * @author Stefan Alfons Tzeggai
274                  }           */
275          }          public String toOneLine() {
276                    return I8NUtil.toOneLine(this);
277  }          }
278    
279            /**
280             * Returns the correct translation by using the {@link #activeLang} field.
281             * If no translation is set, an ugly String {@link #NO_TRANSLATION} will re
282             * returned. This might be changed for the final release. If the correct
283             * language was not found, any entry in the {@link Translation}
284             * {@link HashMap} will be returned, that contains more than an empty
285             * string.
286             */
287            @Override
288            public String toString() {
289                    final String string = get(activeLang);
290                    if (string != null) {
291                            return get(activeLang);
292                    }
293                    // ****************************************************************************
294                    // MS: The ISDSS needs the concept of the default lang!! So I took the
295                    // following in again!!
296                    // ****************************************************************************
297                    // else return "";
298                    // //****************************************************************************
299                    // // ST: The following is commented out.. the concept of the default
300                    // lang
301                    // seems to be bad....
302                    // //****************************************************************************
303                    // MS:
304                    else {
305                            if (get(DEFAULT_KEY) != null) {
306                                    return get(DEFAULT_KEY);
307                            }
308    
309                            // log.debug("return first best <> '' ");
310                            if (size() > 0)
311                                    for (String s : values()) {
312                                            if ((s != null) && (s.trim().length() > 0))
313                                                    return s;
314                                    }
315                    }
316                    // log.warn("No translation found!");
317                    return NO_TRANSLATION;
318            }
319    
320            /**
321             * {@link PropertyChangeListener} can be registered to be informed when the
322             * {@link Locale} changed.<br>
323             * The listeners are kept in a {@link WeakHashMap}, so you have to keep a
324             * reference to the listener or it will be removed!
325             *
326             * @param propertyChangeListener
327             *            A {@link PropertyChangeListener} that will be called when
328             *            {@link #setActiveLang(String)} changes the language.
329             */
330            public static void addLocaleChangeListener(
331                            PropertyChangeListener propertyChangeListener) {
332                    listenersLocaleChange.add(propertyChangeListener);
333            }
334    
335            /**
336             * {@link PropertyChangeListener} can be registered to be informed when the
337             * {@link Locale} changed.<br>
338             * The listeners are kept in a {@link WeakHashMap}, so you have to keep a
339             * reference to the listener or it will be removed!
340             *
341             * @param propertyChangeListener
342             *            A {@link PropertyChangeListener} that will be called when
343             *            {@link #setActiveLang(String)} changes the language.
344             */
345            public static boolean removeLocaleChangeListener(
346                            PropertyChangeListener propertyChangeListener) {
347                    return listenersLocaleChange.remove(propertyChangeListener);
348            }
349    
350            /**
351             * {@link PropertyChangeListener} can be registered to be informed when the
352             * {@link Locale} changed.<br>
353             * The listeners are kept in a {@link WeakHashMap}, so you have to keep a
354             * reference to the listener or it will be removed!
355             *
356             * @param propertyChangeListener
357             *            A {@link PropertyChangeListener} that will be called when
358             *            {@link #setActiveLang(String)} changes the language.
359             */
360            public static void addActiveLangChangeListener(
361                            PropertyChangeListener propertyChangeListener) {
362                    listenersActiveLangChange.add(propertyChangeListener);
363            }
364    
365            /**
366             * {@link PropertyChangeListener} can be registered to be informed when the
367             * {@link Locale} changed.<br>
368             * The listeners are kept in a {@link WeakHashMap}, so you have to keep a
369             * reference to the listener or it will be removed!
370             *
371             * @param propertyChangeListener
372             *            A {@link PropertyChangeListener} that will be called when
373             *            {@link #setActiveLang(String)} changes the language.
374             */
375            public static boolean removeActiveLangListener(
376                            PropertyChangeListener propertyChangeListener) {
377                    return listenersActiveLangChange.remove(propertyChangeListener);
378            }
379    
380            /**
381             * Informs all registered {@link PropertyChangeListener}s about a change of
382             * type LOCALE_CHANGE_PROPERTY the the {@link Locale}.
383             */
384            public static void fireLocaleChangeEvents() {
385                    PropertyChangeEvent pce = new PropertyChangeEvent(new Translation(
386                                    new ArrayList<String>(), "fakeSource"), LOCALE_CHANGE_PROPERTY,
387                                    null, getActiveLang());
388                    for (PropertyChangeListener pcl : listenersLocaleChange) {
389                            if (pcl != null)
390                                    pcl.propertyChange(pce);
391                    }
392            }
393    
394            /**
395             * Informs all registered {@link PropertyChangeListener}s about a change of
396             * type ACTIVELANG_CHANGE_PROPERTY the the {@link Locale}.
397             */
398            public static void fireActiveLangChangeEvents() {
399                    PropertyChangeEvent pce = new PropertyChangeEvent(new Translation(
400                                    new ArrayList<String>(), "fakeSource"),
401                                    ACTIVELANG_CHANGE_PROPERTY, null, getActiveLang());
402                    for (PropertyChangeListener pcl : listenersActiveLangChange) {
403                            if (pcl != null)
404                                    pcl.propertyChange(pce);
405                    }
406            }
407    
408            /**
409             * The listeneras are stored in a {@link WeakHashSet}! So you HAVE TO KEEP a
410             * reference as long as you need the listener.
411             */
412            public void addTranslationChangeListener(ActionListener actionListener) {
413                    if (changeListeners.add(actionListener)) {
414                            // LOGGER
415                            // .debug("registering a new translationChangeActionListener in the WeakHashSet");
416                    }
417            }
418    
419            /**
420             * The listeneras are stored in a {@link WeakHashSet}! You don't have to
421             * remove the listener, as long as you throw away the reference to the
422             * listener.
423             */
424            public boolean removeTranslationChangeListener(ActionListener actionListener) {
425                    return changeListeners.remove(actionListener);
426            }
427    
428            public void fireTranslationChangedEvents(String lang) {
429                    ActionEvent ae = new ActionEvent(this, new Random().nextInt(), lang);
430    
431                    final Iterator<ActionListener> iterator = changeListeners.iterator();
432                    while (iterator.hasNext()) {
433                            ActionListener al = iterator.next();
434                            al.actionPerformed(ae);
435                    }
436            }
437    
438            @Override
439            public String put(String lang, String value) {
440                    String result = super.put(lang, value);
441                    fireTranslationChangedEvents(lang);
442                    return result;
443            }
444    
445            public void fromOneLine(InternationalString iString) {
446                    if (iString != null)
447                            fromOneLine(iString.toString());
448                    else
449                            fromOneLine((String) null);
450            }
451    
452            /**
453             * Copy this {@link Translation} to another {@link Translation} e.g. for
454             * editing and return the target.
455             *
456             * @return the destination {@link Translation}
457             */
458            @Override
459            public Translation copyTo(Translation translation2) {
460                    if (translation2 == null)
461                            return copy();
462    
463                    translation2.fromOneLine(toOneLine());
464                    return translation2;
465            }
466    
467            @Override
468            public Translation copy() {
469                    return copyTo(new Translation());
470            }
471    
472            /**
473             * Checks if the {@link String}s stored in the {@link Translation} are all
474             * valid.
475             *
476             * @return <code>true</code> if all good
477             */
478            public static boolean checkValid(Translation translationToCheck) {
479    
480                    for (String l : translationToCheck.values()) {
481    
482                            if (l.contains("{") || l.contains("}")) {
483    
484                                    return false;
485                            }
486                    }
487                    return true;
488            }
489    
490            /**
491             * Goes through the available languages of the FIRST registered
492             * {@link ResourceProvider} and set the active locale to the fist match.
493             *
494             * @param fireChangeEvent
495             *            if <code>true</code>, a Translation.fireLocaleChangeEvents()
496             *            is issued.
497             *
498             * @return
499             */
500            public static boolean setFirstmatchingLanguage(List<String> languages,
501                            boolean fireChangeEvent) {
502    
503                    SortableVector<ResourceProvider> registeredResourceProvider = ResourceProvider
504                                    .getRegisteredResourceProvider();
505                    Set<Locale> available = ResourceProvider.getAvailableLocales(
506                                    registeredResourceProvider.get(0), true);
507    
508                    for (String l : languages) {
509                            for (Locale loc : available) {
510                                    if (loc.getLanguage().equals(l)) {
511                                            Translation.setActiveLang(l);
512                                            if (fireChangeEvent)
513                                                    Translation.fireLocaleChangeEvents();
514                                            return true;
515                                    }
516                            }
517                    }
518    
519                    return false;
520    
521            }
522    
523            /**
524             * Returns the translation in a requested language
525             */
526            public String toString(String lang) {
527                    return get(lang);
528            }
529    
530            /**
531             * Will set the default Locale (if not already equal) and fire Locale change
532             * events.
533             *
534             * @param if <code>null</code> will do nothing.
535             */
536            public static void setDefaultLocale(Locale locale) {
537    
538                    if (locale == null)
539                            return;
540    
541                    if (I8NUtil.isPropertiesLanguage(locale.getLanguage())) {
542                            locale = I8NUtil.propLocales.get(locale.getLanguage())
543                                            .getParentLocale();
544                    }
545    
546                    if (Locale.getDefault().equals(locale))
547                            return;
548                    Locale.setDefault(locale);
549                    /**
550                     * Setting default locale for Swing JComponents to work around bug
551                     * http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4884480
552                     */
553                    JComponent.setDefaultLocale(locale);
554    
555                    fireLocaleChangeEvents();
556            }
557    
558    }
Legend:
Removed from v.243  
changed lines
  Added in v.1373
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26