View Javadoc
1   /*
2    * Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.  Oracle designates this
8    * particular file as subject to the "Classpath" exception as provided
9    * by Oracle in the LICENSE file that accompanied this code.
10   *
11   * This code is distributed in the hope that it will be useful, but WITHOUT
12   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14   * version 2 for more details (a copy is included in the LICENSE file that
15   * accompanied this code).
16   *
17   * You should have received a copy of the GNU General Public License version
18   * 2 along with this work; if not, write to the Free Software Foundation,
19   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20   *
21   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22   * or visit www.oracle.com if you need additional information or have any
23   * questions.
24   */
25  
26  package sun.tools.jconsole;
27  
28  import java.awt.event.KeyEvent;
29  import java.lang.reflect.Field;
30  import java.lang.reflect.Modifier;
31  import java.text.MessageFormat;
32  import java.util.Collections;
33  import java.util.IdentityHashMap;
34  import java.util.Map;
35  import java.util.MissingResourceException;
36  import java.util.ResourceBundle;
37  
38  /**
39   * Toolkit that provides resource support for JConsole.
40   */
41  public final class Resources {
42      private static Map<String, Integer> MNEMONIC_LOOKUP = Collections
43              .synchronizedMap(new IdentityHashMap<String, Integer>());
44  
45      private Resources() {
46          throw new AssertionError();
47      }
48  
49      /**
50       * Convenience method for {@link MessageFormat#format(String, Object...)}.
51       *
52       * @param pattern the pattern
53       * @param objects the arguments for the pattern
54       *
55       * @return a formatted string
56       */
57      public static String format(String pattern, Object... arguments) {
58              return MessageFormat.format(pattern, arguments);
59      }
60  
61      /**
62       * Returns the mnemonic for a message.
63       *
64       * @param message the message
65       *
66       * @return the mnemonic <code>int</code>
67       */
68      public static int getMnemonicInt(String message) {
69          Integer integer = MNEMONIC_LOOKUP.get(message);
70          if (integer != null) {
71              return integer.intValue();
72          }
73          return 0;
74      }
75  
76      /**
77       * Initializes all non-final public static fields in the given class with
78       * messages from a {@link ResourceBundle}.
79       *
80       * @param clazz the class containing the fields
81       */
82      public static void initializeMessages(Class<?> clazz, String rbName) {
83          ResourceBundle rb = null;
84          try {
85              rb = ResourceBundle.getBundle(rbName);
86          } catch (MissingResourceException mre) {
87              // fall through, handled later
88          }
89          for (Field field : clazz.getFields()) {
90              if (isWritableField(field)) {
91                  String key = field.getName();
92                  String message = getMessage(rb, key);
93                  int mnemonicInt = findMnemonicInt(message);
94                  message = removeMnemonicAmpersand(message);
95                  message = replaceWithPlatformLineFeed(message);
96                  setFieldValue(field, message);
97                  MNEMONIC_LOOKUP.put(message, mnemonicInt);
98              }
99          }
100     }
101 
102     private static boolean isWritableField(Field field) {
103         int modifiers = field.getModifiers();
104         return Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)
105                 && !Modifier.isFinal(modifiers);
106     }
107 
108     /**
109      * Returns the message corresponding to the key in the bundle or a text
110      * describing it's missing.
111      *
112      * @param rb the resource bundle
113      * @param key the key
114      *
115      * @return the message
116      */
117     private static String getMessage(ResourceBundle rb, String key) {
118         if (rb == null) {
119             return "missing resource bundle";
120         }
121         try {
122             return rb.getString(key);
123         } catch (MissingResourceException mre) {
124             return "missing message for key = \"" + key
125                     + "\" in resource bundle ";
126         }
127     }
128 
129     private static void setFieldValue(Field field, String value) {
130         try {
131             field.set(null, value);
132         } catch (IllegalArgumentException | IllegalAccessException e) {
133             throw new Error("Unable to access or set message for field " + field.getName());
134         }
135     }
136 
137     /**
138      * Returns a {@link String} where all <code>\n</code> in the <text> have
139      * been replaced with the line separator for the platform.
140      *
141      * @param text the to be replaced
142      *
143      * @return the replaced text
144      */
145     private static String replaceWithPlatformLineFeed(String text) {
146         return text.replace("\n", System.getProperty("line.separator"));
147     }
148 
149     /**
150      * Removes the mnemonic identifier (<code>&</code>) from a string unless
151      * it's escaped by <code>&&</code> or placed at the end.
152      *
153      * @param message the message
154      *
155      * @return a message with the mnemonic identifier removed
156      */
157     private static String removeMnemonicAmpersand(String message) {
158         StringBuilder s = new StringBuilder();
159         for (int i = 0; i < message.length(); i++) {
160             char current = message.charAt(i);
161             if (current != '&' || i == message.length() - 1
162                     || message.charAt(i + 1) == '&') {
163                 s.append(current);
164             }
165         }
166         return s.toString();
167     }
168 
169     /**
170      * Finds the mnemonic character in a message.
171      *
172      * The mnemonic character is the first character followed by the first
173      * <code>&</code> that is not followed by another <code>&</code>.
174      *
175      * @return the mnemonic as an <code>int</code>, or <code>0</code> if it
176      *         can't be found.
177      */
178     private static int findMnemonicInt(String s) {
179         for (int i = 0; i < s.length() - 1; i++) {
180             if (s.charAt(i) == '&') {
181                 if (s.charAt(i + 1) != '&') {
182                     return lookupMnemonicInt(s.substring(i + 1, i + 2));
183                 } else {
184                     i++;
185                 }
186             }
187         }
188         return 0;
189     }
190 
191     /**
192      * Lookups the mnemonic for a key in the {@link KeyEvent} class.
193      *
194      * @param c the character to lookup
195      *
196      * @return the mnemonic as an <code>int</code>, or <code>0</code> if it
197      *         can't be found.
198      */
199     private static int lookupMnemonicInt(String c) {
200         try {
201             return KeyEvent.class.getDeclaredField("VK_" + c.toUpperCase())
202                     .getInt(null);
203         } catch (IllegalArgumentException | IllegalAccessException
204                 | NoSuchFieldException | SecurityException e) {
205             // Missing VK is okay
206             return 0;
207         }
208     }
209 }