/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.gui;import java.io.*;import java.util.*;import java.awt.*;/** * This class extends ResourceBundle and adds methods to retrieve types of * resources commonly used in GUIs.  Additionally, it adds extensibility * by allowing ResourceParser objects to be registered to parse other * resource types. **/public class GUIResourceBundle extends ResourceBundle {    // The root object.  Required to parse certain resource types like Commands    Object root;               // The resource bundle that actually contains the textual resources    // This class is a wrapper around this bundle    ResourceBundle bundle;    /** Create a GUIResourceBundle wrapper around a specified bundle */    public GUIResourceBundle(Object root, ResourceBundle bundle) {	this.root = root;	this.bundle = bundle;    }    /**     * Load a named bundle and create a GUIResourceBundle around it.  This      * constructor takes advantage of the internationalization features of     * the ResourceBundle.getBundle() method.     **/    public GUIResourceBundle(Object root, String bundleName)	throws MissingResourceException    {	this.root = root;	this.bundle = ResourceBundle.getBundle(bundleName);    }    /**     * Create a PropertyResourceBundle from the specified stream and then     * create a GUIResourceBundle wrapper for it     **/    public GUIResourceBundle(Object root, InputStream propertiesStream)        throws IOException    {	this.root = root;	this.bundle = new PropertyResourceBundle(propertiesStream);    }    /**     * Create a PropertyResourceBundle from the specified properties file and     * then create a GUIResourceBundle wrapper for it.     **/    public GUIResourceBundle(Object root, File propertiesFile)         throws IOException    {	this(root, new FileInputStream(propertiesFile));    }    /** This is one of the abstract methods of ResourceBundle */    public Enumeration getKeys() { return bundle.getKeys(); }    /** This is the other abstract method of ResourceBundle */    protected Object handleGetObject(String key)	throws MissingResourceException    {	return bundle.getObject(key);  // simply defer to the wrapped bundle    }        /** This is a property accessor method for our root object */    public Object getRoot() { return root; }    /**      * This method is like the inherited getString() method, except that      * when the named resource is not found, it returns the specified default      * instead of throwing an exception      **/    public String getString(String key, String defaultValue) {	try { return bundle.getString(key); }	catch(MissingResourceException e) { return defaultValue; }    }    /**     * Look up the named resource and parse it as a list of strings separated     * by spaces, tabs, or commas.     **/    public java.util.List getStringList(String key)	throws MissingResourceException    {	String s = getString(key);	StringTokenizer t = new StringTokenizer(s, ", \t", false);	ArrayList list = new ArrayList();	while(t.hasMoreTokens()) list.add(t.nextToken());	return list;    }    /** Like above, but return a default instead of throwing an exception */    public java.util.List getStringList(String key,					java.util.List defaultValue) {	try { return getStringList(key); }	catch(MissingResourceException e) { return defaultValue; }    }    /** Look up the named resource and try to interpret it as a boolean. */    public boolean getBoolean(String key) throws MissingResourceException {	String s = bundle.getString(key);	s = s.toLowerCase();	if (s.equals("true")) return true;	else if (s.equals("false")) return false;	else if (s.equals("yes")) return true;	else if (s.equals("no")) return false;	else if (s.equals("on")) return true;	else if (s.equals("off")) return false;	else {	    throw new MalformedResourceException("boolean", key);	}    }    /** As above, but return the default instead of throwing an exception */    public boolean getBoolean(String key, boolean defaultValue) {	try { return getBoolean(key); }	catch(MissingResourceException e) {	    if (e instanceof MalformedResourceException)		System.err.println("WARNING: " + e.getMessage());	    return defaultValue;	}    }    /** Like getBoolean(), but for integers */    public int getInt(String key) throws MissingResourceException {	String s = bundle.getString(key);		try {	    // Use decode() instead of parseInt() so we support octal	    // and hexadecimal numbers	    return Integer.decode(s).intValue();	} catch (NumberFormatException e) {	    throw new MalformedResourceException("int", key);	}    }    /** As above, but with a default value */    public int getInt(String key, int defaultValue) {	try { return getInt(key); }	catch(MissingResourceException e) {	    if (e instanceof MalformedResourceException)		System.err.println("WARNING: " + e.getMessage());	    return defaultValue;	}    }    /** Return a resource of type double */    public double getDouble(String key) throws MissingResourceException {	String s = bundle.getString(key);		try {	    return Double.parseDouble(s);	} catch (NumberFormatException e) {	    throw new MalformedResourceException("double", key);	}    }    /** As above, but with a default value */    public double getDouble(String key, double defaultValue) {	try { return getDouble(key); }	catch(MissingResourceException e) {	    if (e instanceof MalformedResourceException)		System.err.println("WARNING: " + e.getMessage());	    return defaultValue;	}    }    /** Look up the named resource and convert to a Font */    public Font getFont(String key) throws MissingResourceException {	// Font.decode() always returns a Font object, so we can't check	// whether the resource value was well-formed or not.	return Font.decode(bundle.getString(key));    }    /** As above, but with a default value */    public Font getFont(String key, Font defaultValue) {	try { return getFont(key); }	catch (MissingResourceException e) { return defaultValue; }    }    /** Look up the named resource, and convert to a Color */    public Color getColor(String key) throws MissingResourceException {	try {	    return Color.decode(bundle.getString(key));	}	catch (NumberFormatException e) { 	    // It would be useful to try to parse color names here as well	    // as numeric color specifications	    throw new MalformedResourceException("Color", key);	}    }    /** As above, but with a default value */    public Color getColor(String key, Color defaultValue) {	try { return getColor(key); }	catch(MissingResourceException e) {	    if (e instanceof MalformedResourceException)		System.err.println("WARNING: " + e.getMessage());	    return defaultValue;	}    }    /** A hashtable for mapping resource types to resource parsers */    static HashMap parsers = new HashMap();    /** An extension mechanism: register a parser for new resource types */    public static void registerResourceParser(ResourceParser parser) {	// Ask the ResourceParser what types it can parse	Class[] supportedTypes = parser.getResourceTypes();	// Register it in the hashtable for each of those types	for(int i = 0; i < supportedTypes.length; i++)	    parsers.put(supportedTypes[i], parser);    }    /** Look up a ResourceParser for the specified resource type */    public static ResourceParser getResourceParser(Class type) {	return (ResourceParser) parsers.get(type);    }    /**     * Look for a ResourceParser for the named type, and if one is found,      * ask it to parse and return the named resource      **/    public Object getResource(String key, Class type)	throws MissingResourceException    {	// Get a parser for the specified type	ResourceParser parser = (ResourceParser)parsers.get(type);	if (parser == null) 	    throw new MissingResourceException(                  "No ResourceParser registered for " +		  type.getName() + " resources",		  type.getName(), key);		try {  // Ask the parser to parse the resource	    return parser.parse(this, key, type);	}	catch(MissingResourceException e) {	    throw e;  // Rethrow MissingResourceException exceptions	}	catch(Exception e) {	    // If any other type of exception occurs, convert it to	    // a MalformedResourceException	    String msg = "Malformed " + type.getName() + " resource: " +		key + ": " + e.getMessage();	    throw new MalformedResourceException(msg, type.getName(), key);	}    }    /**     * Like the 2-argument version of getResource, but return a default value     * instead of throwing a MissingResourceException     **/    public Object getResource(String key, Class type, Object defaultValue) {	try {  return getResource(key, type); }	catch (MissingResourceException e) {	    if (e instanceof MalformedResourceException)		System.err.println("WARNING: " + e.getMessage());	    return defaultValue;	}    }}