Back to index...

	/*
	* Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package sun.tools.jconsole;

	import java.awt.event.KeyEvent;
	import java.lang.reflect.Field;
	import java.lang.reflect.Modifier;
	import java.text.MessageFormat;
	import java.util.Collections;
	import java.util.IdentityHashMap;
	import java.util.Map;
	import java.util.MissingResourceException;
	import java.util.ResourceBundle;

	/**
	* Toolkit that provides resource support for JConsole.
	*/
	public final class Resources {
	private static Map<String, Integer> MNEMONIC_LOOKUP = Collections
	.synchronizedMap(new IdentityHashMap<String, Integer>());

	private Resources() {
	throw new AssertionError();
	}

	/**
	* Convenience method for {@link MessageFormat#format(String, Object...)}.
	*
	* @param pattern the pattern
	* @param objects the arguments for the pattern
	*
	* @return a formatted string
	*/
	public static String format(String pattern, Object... arguments) {
	return MessageFormat.format(pattern, arguments);
	}

	/**
	* Returns the mnemonic for a message.
	*
	* @param message the message
	*
	* @return the mnemonic <code>int</code>
	*/
	public static int getMnemonicInt(String message) {
	Integer integer = MNEMONIC_LOOKUP.get(message);
	if (integer != null) {
	return integer.intValue();
	}
	return 0;
	}

	/**
	* Initializes all non-final public static fields in the given class with
	* messages from a {@link ResourceBundle}.
	*
	* @param clazz the class containing the fields
	*/
	public static void initializeMessages(Class<?> clazz, String rbName) {
	ResourceBundle rb = null;
	try {
	rb = ResourceBundle.getBundle(rbName);
	} catch (MissingResourceException mre) {
	// fall through, handled later
	}
	for (Field field : clazz.getFields()) {
	if (isWritableField(field)) {
	String key = field.getName();
	String message = getMessage(rb, key);
	int mnemonicInt = findMnemonicInt(message);
	message = removeMnemonicAmpersand(message);
	message = replaceWithPlatformLineFeed(message);
	setFieldValue(field, message);
	MNEMONIC_LOOKUP.put(message, mnemonicInt);
	}
	}
	}

	private static boolean isWritableField(Field field) {
	int modifiers = field.getModifiers();
	return Modifier.isPublic(modifiers) && Modifier.isStatic(modifiers)
	&& !Modifier.isFinal(modifiers);
	}

	/**
	* Returns the message corresponding to the key in the bundle or a text
	* describing it's missing.
	*
	* @param rb the resource bundle
	* @param key the key
	*
	* @return the message
	*/
	private static String getMessage(ResourceBundle rb, String key) {
	if (rb == null) {
	return "missing resource bundle";
	}
	try {
	return rb.getString(key);
	} catch (MissingResourceException mre) {
	return "missing message for key = \"" + key
	+ "\" in resource bundle ";
	}
	}

	private static void setFieldValue(Field field, String value) {
	try {
	field.set(null, value);
	} catch (IllegalArgumentException \| IllegalAccessException e) {
	throw new Error("Unable to access or set message for field " + field.getName());
	}
	}

	/**
	* Returns a {@link String} where all <code>\n</code> in the <text> have
	* been replaced with the line separator for the platform.
	*
	* @param text the to be replaced
	*
	* @return the replaced text
	*/
	private static String replaceWithPlatformLineFeed(String text) {
	return text.replace("\n", System.getProperty("line.separator"));
	}

	/**
	* Removes the mnemonic identifier (<code>&</code>) from a string unless
	* it's escaped by <code>&&</code> or placed at the end.
	*
	* @param message the message
	*
	* @return a message with the mnemonic identifier removed
	*/
	private static String removeMnemonicAmpersand(String message) {
	StringBuilder s = new StringBuilder();
	for (int i = 0; i < message.length(); i++) {
	char current = message.charAt(i);
	if (current != '&' \|\| i == message.length() - 1
	\|\| message.charAt(i + 1) == '&') {
	s.append(current);
	}
	}
	return s.toString();
	}

	/**
	* Finds the mnemonic character in a message.
	*
	* The mnemonic character is the first character followed by the first
	* <code>&</code> that is not followed by another <code>&</code>.
	*
	* @return the mnemonic as an <code>int</code>, or <code>0</code> if it
	* can't be found.
	*/
	private static int findMnemonicInt(String s) {
	for (int i = 0; i < s.length() - 1; i++) {
	if (s.charAt(i) == '&') {
	if (s.charAt(i + 1) != '&') {
	return lookupMnemonicInt(s.substring(i + 1, i + 2));
	} else {
	i++;
	}
	}
	}
	return 0;
	}

	/**
	* Lookups the mnemonic for a key in the {@link KeyEvent} class.
	*
	* @param c the character to lookup
	*
	* @return the mnemonic as an <code>int</code>, or <code>0</code> if it
	* can't be found.
	*/
	private static int lookupMnemonicInt(String c) {
	try {
	return KeyEvent.class.getDeclaredField("VK_" + c.toUpperCase())
	.getInt(null);
	} catch (IllegalArgumentException \| IllegalAccessException
	\| NoSuchFieldException \| SecurityException e) {
	// Missing VK is okay
	return 0;
	}
	}
	}

Back to index...