package com.opensymphony.workflow.designer;import java.net.URL;import java.util.*;import javax.swing.*;/** * Central repository for all Actions. * On startup, the application is responsible for registering all actions via the {@link #register(java.lang.String, javax.swing.Action)} * method. Once this is done, any action can be retrieved via the {@link #get(java.lang.String)} method. * The action manager will look for an actions.properties file in the same package, and will read all properties * specified in it for a given action. * <p> * The benefit of specifying actions in the external file is that actions themselves need not be aware of their textual or * graphic representation or key bindings. */public final class ActionManager{	private static final String OS_NAME_STRING = System.getProperty("os.name").replace(' ', '_').toLowerCase();  private static final String SMALL_GRAY_ICON = "smallGrayIcon";  private static final String DISPLAYED_MNEMONIC_INDEX = "mnemonicIndex";  private static final ActionManager INSTANCE = new ActionManager();  private final Map actions;  private ResourceBundle bundle;  private ActionManager()  {    this.actions = new HashMap(50);    bundle = ResourceBundle.getBundle("com.opensymphony.workflow.designer.actions");  }  /**   * Register an action.   * @param id The action id denotes the set of properties that will be read for the action   * @param action The action instance to bind to the specified id.   * @return The action, once it has been initialised. If the id is not specified in the   * properties file, then null is returned.   * @throws NullPointerException if the specified action is null   */  public static Action register(String id, Action action)  {    if(action == null)      throw new NullPointerException("Registered actions must not be null.");		boolean exists = ActionReader.readAndPutValues(action, INSTANCE.bundle, id);		if(!exists) return null;    Object oldValue = INSTANCE.actions.put(id, action);    if(oldValue != null)			System.out.println("WARNING: Duplicate action id: " + id);    return action;  }	/**	 * Remove a registered action	 * @param id the action id	 * @return The removed action, if it existed.	 */	public static Action deregister(String id)	{		return (Action)INSTANCE.actions.remove(id);	}  /**   * Get a previously registered action   * @param id The action id   * @return The action bound to the specified id, or null if no action is bound.   */  public static Action get(String id)  {    Action action = (Action)(INSTANCE.actions.get(id));    if(null == action)    {			System.out.println("ERROR: No action found for id: " + id);      return null;    }    return action;  }  /**   * Retrieves and answers the small icon for the given <code>id</code>.   */  public static Icon getIcon(String id)  {    Action action = get(id);    if(action == null)      return null;    return (Icon)action.getValue(Action.SMALL_ICON);  }  /**   * Alias a particular id to another one.   * This allows one action to be bound to multiple keys.   * @param newKey The new alias to bind to.   * @param oldKey The old id to bind to.   */	public static void alias(String newKey, String oldKey)	{		Object oldValue = INSTANCE.actions.put(newKey, INSTANCE.actions.get(oldKey));		if(oldValue != null)			System.out.println("WARNING: Duplicate action id: " + newKey);	}  private static class ActionReader  {    private static final String LABEL = "label";    private static final char MNEMONIC_MARKER = '&';    private static final String DOT_STRING = "...";    private static final String SHORT_DESCRIPTION = "tooltip";    private static final String LONG_DESCRIPTION = "helptext";    private static final String ICON = "icon";    private static final String GRAY_ICON = ICON + ".gray";    private static final String ACCELERATOR = "accelerator";		private static final String COMMAND = "command";		private String id;		private String name;		private Integer mnemonic;		private Integer aMnemonicIndex;		private String shortDescription;		private String longDescription;		private ImageIcon icon;		private ImageIcon grayIcon;		private KeyStroke accelerator;		private String command;		private boolean exists = true;    /**     * Reads properties for <code>id</code> in <code>bundle</code>.     */    static void readValues(ResourceBundle bundle, String id)    {      new ActionReader(bundle, id);    }    /**     * Reads properties for <code>id</code> in <code>bundle</code> and     * sets the approriate values in the given <code>action</code>.     */		static boolean readAndPutValues(Action action, ResourceBundle bundle, String id)    {      ActionReader reader = new ActionReader(bundle, id);			if(!reader.actionExists()) return false;      reader.putValues(action);			return true;    }    private ActionReader(ResourceBundle bundle, String id)    {			String iconPath = getString(bundle, id + '.' + ICON, null);			if(getString(bundle, id + "." + LABEL, null) == null && iconPath == null)			{				exists = false;				return;			}      this.id = id;      String nameWithMnemonic = getString(bundle, id + "." + LABEL, id);      int index = mnemonicIndex(nameWithMnemonic);      name = stripName(nameWithMnemonic, index);      mnemonic = stripMnemonic(nameWithMnemonic, index);      aMnemonicIndex = new Integer(index);      shortDescription = getString(bundle, id + '.' + SHORT_DESCRIPTION, defaultShortDescription(name));      longDescription = getString(bundle, id + '.' + LONG_DESCRIPTION, name);			URL iconURL = iconPath != null ? getClass().getClassLoader().getResource(iconPath) : null;			if(iconURL == null && iconPath != null)			{				System.out.println("WARNING Invalid icon " + iconPath + " specified in actions.properties for action '" + name + "'");				icon = null;			}			else			{				icon = (iconPath == null) ? null : new ImageIcon(iconURL);			}      String grayIconPath = getString(bundle, id + '.' + GRAY_ICON, null);      grayIcon = (grayIconPath == null) ? null : new ImageIcon(getClass().getClassLoader().getResource(grayIconPath));			String shortcut = getString(bundle, id + '.' + ACCELERATOR + '.' + OS_NAME_STRING, null);			if(shortcut == null)			{				shortcut = getString(bundle, id + '.' + ACCELERATOR, null);			}      accelerator = getKeyStroke(shortcut);			command = getString(bundle, id + '.' + COMMAND, null);		}		public boolean actionExists()		{			return exists;    }    /**     * Put the ActionReader's properties as values in the Action.     */    private void putValues(Action action)    {      action.putValue(Action.NAME, name);      action.putValue(Action.SHORT_DESCRIPTION, shortDescription);      action.putValue(Action.LONG_DESCRIPTION, longDescription);			if(icon != null)        action.putValue(Action.SMALL_ICON, icon);			if(grayIcon != null)        action.putValue(ActionManager.SMALL_GRAY_ICON, grayIcon);			if(accelerator != null)        action.putValue(Action.ACCELERATOR_KEY, accelerator);			if(mnemonic != null)      action.putValue(Action.MNEMONIC_KEY, mnemonic);			if(command != null)				action.putValue(Action.ACTION_COMMAND_KEY, command);      action.putValue(ActionManager.DISPLAYED_MNEMONIC_INDEX, aMnemonicIndex);    }    private int mnemonicIndex(String nameWithMnemonic)    {      return nameWithMnemonic.indexOf(MNEMONIC_MARKER);    }    private String stripName(String nameWithMnemonic, int mnemonicIndex)    {      return mnemonicIndex == -1 ? nameWithMnemonic : nameWithMnemonic.substring(0, mnemonicIndex) + nameWithMnemonic.substring(mnemonicIndex + 1);    }    private Integer stripMnemonic(String nameWithMnemonic, int mnemonicIndex)    {      return mnemonicIndex == -1 ? null : new Integer(nameWithMnemonic.charAt(mnemonicIndex + 1));    }    private String defaultShortDescription(String nameWithDots)    {      return nameWithDots.endsWith(DOT_STRING) ? (nameWithDots.substring(0, nameWithDots.length() - DOT_STRING.length())) : nameWithDots;    }		private KeyStroke getKeyStroke(String accelerator)    {			if(accelerator == null)      {        return null;      }      else      {				KeyStroke keyStroke = KeyStroke.getKeyStroke(accelerator);        if(keyStroke == null)					System.out.println("WARNING: Action " + id + " has an invalid accelerator " + accelerator);        return keyStroke;      }    }    private String getString(ResourceBundle bundle, String key, String defaultString)    {      try      {        return bundle.getString(key);      }      catch(MissingResourceException e)      {        return defaultString;      }    }  }}