Thread: [Japi-cvs] SF.net SVN: japi: [187] libs/swing-action/trunk

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 187
          http://svn.sourceforge.net/japi/?rev=187&view=rev
Author:   christianhujer
Date:     2006-10-14 05:49:23 -0700 (Sat, 14 Oct 2006)

Log Message:
-----------
Copied action classes from historic to swing-action subproject.

Added Paths:
-----------
    libs/swing-action/trunk/src/
    libs/swing-action/trunk/src/net/
    libs/swing-action/trunk/src/net/sf/
    libs/swing-action/trunk/src/net/sf/japi/
    libs/swing-action/trunk/src/net/sf/japi/swing/
    libs/swing-action/trunk/src/net/sf/japi/swing/ActionFactory.java
    libs/swing-action/trunk/src/net/sf/japi/swing/ActionMethod.java
    libs/swing-action/trunk/src/net/sf/japi/swing/ActionProvider.java
    libs/swing-action/trunk/src/net/sf/japi/swing/DisposeAction.java
    libs/swing-action/trunk/src/net/sf/japi/swing/DummyAction.java
    libs/swing-action/trunk/src/net/sf/japi/swing/NamedActionMap.java
    libs/swing-action/trunk/src/net/sf/japi/swing/ReflectionAction.java
    libs/swing-action/trunk/src/net/sf/japi/swing/ToggleAction.java

Copied: libs/swing-action/trunk/src/net/sf/japi/swing/ActionFactory.java (from rev 181, historic/trunk/src/app/net/sf/japi/swing/ActionFactory.java)
===================================================================

--- libs/swing-action/trunk/src/net/sf/japi/swing/ActionFactory.java	                        (rev 0)
+++ libs/swing-action/trunk/src/net/sf/japi/swing/ActionFactory.java	2006-10-14 12:49:23 UTC (rev 187)
@@ -0,0 +1,1099 @@
+/* JAPI - (Yet another (hopefully) useful) Java API
+ *
+ * Copyright (C) 2004-2006 Christian Hujer
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program 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 for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+ * 02111-1307, USA.
+ */
+
+package net.sf.japi.swing;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.lang.reflect.Field;
+import java.text.MessageFormat;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.ResourceBundle;
+import static java.util.ResourceBundle.getBundle;
+import java.util.WeakHashMap;
+import java.util.ArrayList;
+import java.util.prefs.Preferences;
+import static java.util.prefs.Preferences.userNodeForPackage;
+import javax.swing.AbstractAction;
+import javax.swing.Action;
+import static javax.swing.Action.ACCELERATOR_KEY;
+import static javax.swing.Action.LONG_DESCRIPTION;
+import static javax.swing.Action.MNEMONIC_KEY;
+import static javax.swing.Action.NAME;
+import static javax.swing.Action.SHORT_DESCRIPTION;
+import static javax.swing.Action.SMALL_ICON;
+import javax.swing.ActionMap;
+import javax.swing.Icon;
+import javax.swing.JCheckBox;
+import javax.swing.JLabel;
+import javax.swing.JMenu;
+import javax.swing.JMenuBar;
+import javax.swing.JMenuItem;
+import javax.swing.JOptionPane;
+import javax.swing.JToolBar;
+import javax.swing.JPopupMenu;
+import static javax.swing.KeyStroke.getKeyStroke;
+import org.jetbrains.annotations.NonNls;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import static net.sf.japi.swing.IconManager.getDefaultIconManager;
+import static net.sf.japi.swing.ReflectionAction.REFLECTION_MESSAGE_PROVIDER;
+import static net.sf.japi.swing.ReflectionAction.REFLECTION_TARGET;
+import static net.sf.japi.swing.ToggleAction.REFLECTION_PROPERTY_NAME;
+
+/** Class for creating and initializing {@link Action}s that are localized, user configurable and may invoke their final methods using Reflection;
+ * also handles extremely much useful stuff for i18n/l10n.
+ * It is meant as a general service for creating Action objects that have some comfort for the programmer in several aspects:
+ * <ul>
+ *  <li>Allow zero or more ResourceBundles to be used when creating Actions</li>
+ *  <li>Allow zero or more UserPreferences to be used when creating Actions</li>
+ *  <li>Manage an ActionMap to which created Actions are automatically added</li>
+ * </ul>
+ * You may choose to use one or more ActionFactories, depending on the size of your application.
+ * You may use to spread Action configuration information accross one or more ResourceBundles and one or more Preferences, as you wish.
+ * When looking for values, the Preferences are queried first, in addition order, after that the ResourceBundles, again in addition order, until
+ * a value was found. The behaviour when no value was found is undefined.
+ * <h3>Usage</h3>
+ * The recommended usage is to
+ * <ol>
+ *  <li>
+ *      create and initialize an ActionFactory similar as the following example code, put it somewhere at the start of your program:
+ * <pre>
+ * ActionFactory myActionFactory = ActionFactory.getFactory("MyApplication");
+ * myActionFactory.addBundle("com.mycompany.mypackage.myresource"); // not always required
+ * myActionFactory.addPref(MyClass.class);
+ * </pre>
+ *  </li>
+ *  <li>
+ *      then use the ActionFactory from anywhere within the application like this:
+ * <pre>
+ * ActionFactory myActionFactory = ActionFactory.getFactory("MyApplication");
+ * Action myAction = myActionFactory.createAction("load", this);
+ * </pre>
+ *  </li>
+ * </ol>
+ * <p>
+ *  All actions created or initialized by an instance of this class are optionally put into that instance's {@link ActionMap}.
+ *  If they are stored, you can use that map for later retrieval.
+ * </p>
+ * <h4>Usage Notes: Factory Name</h4>
+ * <ul>
+ *  <li>
+ *      The factory name is used to try to load a resource bundle when a bundle is created.
+ *      The factory name is used as package name for the bundle, the bundle name itself is "action".
+ *      Example: When calling <code>ActionFactory.getFactory("net.sf.japi.swing");</code> for the first time, it is tried to load a
+ *      {@link ResourceBundle} named <code>net.sf.japi.swing.actions</code> for that <code>ActionFactory</code>.
+ *      This automatism has been implemented to save you from the need of initializing an ActionFactory before use.
+ *  </li>
+ * </ul>
+ * <h4>Usage Notes: Action Key / Action Name</h4>
+ * The key you supply as first argument of {@link #createAction(boolean, String, Object)} determines several things:
+ * <ul>
+ *  <li>The base name for the different keys in the preferences / resource bundle and other known Action Keys:
+ *      <table border="1">
+ *          <tr><th>What</th><th>Preferences / Bundle key</th><th>Action key if stored in an action</th></tr>
+ *          <tr><td>An (somewhat unique) ID</td><td>(<var>basename</var> itself)</td><td>{@link #ACTION_ID}</td></tr>
+ *          <tr><td>The icon</td><td><code><var>basename</var> + ".icon"</code></td><td>{@link Action#SMALL_ICON}</td></tr>
+ *          <tr><td>The tooltip help</td><td><code><var>basename</var> + ".shortdescription"</code></td><td>{@link Action#SHORT_DESCRIPTION}</td></tr>
+ *          <tr><td>The long help</td><td><code><var>basename</var> + ".longdescription"</code></td><td>{@link Action#LONG_DESCRIPTION}</td></tr>
+ *          <tr><td>The text label</td><td><code><var>basename</var> + ".text"</code></td><td>{@link Action#NAME}</td></tr>
+ *          <tr><td>The keyboard accelerator</td><td><code><var>basename</var> + ".accel"</code></td><td>{@link Action#ACCELERATOR_KEY}</td></tr>
+ *          <tr><td>The alternate keyboard accelerator</td><td><code><var>basename</var> + ".accel2"</code></td><td>{@link #ACCELERATOR_KEY_2}</td></tr>
+ *          <tr><td>The mnemonic</td><td><code><var>basename</var> + ".mnemonic"</code></td><td>{@link Action#MNEMONIC_KEY}</td></tr>
+ *          <tr><td>The method name</td><td></td><td>{@link ReflectionAction#REFLECTION_METHOD_NAME}</td></tr>
+ *          <tr><td>The method</td><td></td><td>{@link ReflectionAction#REFLECTION_METHOD}</td></tr>
+ *          <tr><td>The boolean property name</td><td></td><td>{@link ToggleAction#REFLECTION_PROPERTY_NAME}</td></tr>
+ *          <tr><td>The target instance</td><td></td><td>{@link ReflectionAction#REFLECTION_TARGET}</td></tr>
+ *          <tr><td>Exception handler dialogs</td><td><code><var>basename</var> + ".exception." + <var>exception class name</var> + ...</code><br/>The message can be formatted with 1 parameter that will be the localized message of the thrown exception.</td><td>n/a</td></tr>
+ *      </table>
+ *  </li>
+ * </ul>
+ * <p>Some methods are not related to actions, yet take base keys:</p>
+ * <ul>
+ *  <li>The methods for dialogs, e.g. {@link #showMessageDialog(Component, String, Object...)}:
+ *      <table border="1">
+ *          <tr><th>What</th><th>Preferences / Bundle key</th></tr>
+ *          <tr><td>Dialog title</td><td><code><var>basename</var> + ".title"</code></td></tr>
+ *          <tr><td>Dialog message</td><td><code><var>basename</var> + ".message"</code></td></tr>
+ *          <tr><td>Dialog messagetype </td><td><code><var>basename</var> + ".messagetype"</code><br/>The message type should be one of the message types defined in {@link JOptionPane}, e.g. {@link JOptionPane#PLAIN_MESSAGE}.</td></tr>
+ *      </table>
+ *  </li>
+ * </ul>
+ * <h4>Final Notes</h4>
+ * <ul>
+ *  <li>
+ *      If by having read all this you think it might often be a good idea to use a package name as a factory name: this is completely right and the
+ *      most common way of using an ActionFactory.
+ *  </li>
+ *  <li>
+ *      If you think you're too lazy to hold your own ActionFactory reference and instead more often call {@link #getFactory(String)}, just go ahead
+ *      and do so.
+ *      Looking up created ActionFactories is extremely fast, and of course they are initialized exactly once, not more.
+ *  </li>
+ * </ul>
+ * @see AbstractAction
+ * @see Action
+ * @see Preferences
+ * @see ResourceBundle
+ * @todo think about toolbar interaction
+ * @todo think about toolbar configuration
+ * @todo eventually rename this ActionBuilder and provide an ActionBuilderFactory.
+ * @todo whether a dialog is a onetime dialog should be a property and user configurable
+ * @author <a href="mailto:ch...@ri...">Christian Hujer</a>
+ */
+public final class ActionFactory {
+
+    /** The key used for storing a somewhat unique id for this Action. */
+    @NotNull public static final String ACTION_ID = "ActionID";
+
+    /** The key used for storing an alternative accelerator for this Action.
+     * Currently unused.
+     */
+    @NotNull public static final String ACCELERATOR_KEY_2 = "AcceleratorKey2";
+
+    /** The ActionFactories. */
+    @NotNull private static final Map<String, ActionFactory> FACTORIES = new WeakHashMap<String, ActionFactory>();
+
+    /** The parent ActionFactories. */
+    @NotNull private final List<ActionFactory> parents = new LinkedList<ActionFactory>();
+
+    /** The ResourceBundles to look for.
+     * Type: ResourceBundle
+     */
+    @NotNull private final List<ResourceBundle> bundles = new LinkedList<ResourceBundle>();
+
+    /** The Preferences to look for.
+     * Type: Preferences
+     */
+    @NotNull private final List<Preferences> prefs = new LinkedList<Preferences>();
+
+    /** The ActionMap to which created Actions are automatically added. */
+    @NotNull private final ActionMap actionMap = new NamedActionMap();
+
+    private List<ActionProvider> actionProviders = new ArrayList<ActionProvider>();
+
+    /** Get an ActionFactory.
+     * If there is no ActionFactory with name <var>key</var>, a new ActionFactory is created and stored.
+     * Future invocations of this method will constantly return that ActionFactory unless the key is garbage collected.
+     * If you must prevent the key from being garbage collected (and with it the ActionFactory), you may internalize the key ({@link String#intern()}).
+     * A good name for a key is the application or package name.
+     * The <code><var>key</var></code> may be a package name, in which case it is tried to load a {@link ResourceBundle} named "action" from that
+     * package and add it ({@link #addBundle(ResourceBundle)}); nothing special happens if that fails.
+     * @param key name of ActionFactory (which even may be <code>null</code> if you are too lazy to invent a key)
+     * @return ActionFactory for given key. The factory is created in case it didn't already exist.
+     */
+    @NotNull public static ActionFactory getFactory(@Nullable final String key) {
+        ActionFactory factory = FACTORIES.get(key);
+        if (factory == null) {
+            factory = new ActionFactory();
+            FACTORIES.put(key, factory);
+            try {
+                factory.addBundle(key + ".action");
+            } catch (final MissingResourceException e) {
+                /* ignore */
+            }
+            // eventually initialize factory here
+        }
+        return factory;
+    }
+
+    /** Add a ResourceBundle to the list of used bundles.
+     * @param baseName the base name of the resource bundle, a fully qualified class name
+     * @see ResourceBundle#getBundle(String)
+     */
+    public void addBundle(@NotNull final String baseName) {
+        //noinspection ConstantConditions
+        if (baseName == null) {
+            throw new NullPointerException("null bundle name not allowed");
+        }
+        @NotNull final ResourceBundle newBundle = getBundle(baseName);
+        addBundle(newBundle);
+        @Nullable final String additionalBundles = newBundle.getString("ActionFactory.additionalBundles");
+        if (additionalBundles != null) {
+            for (final String additionalBundle : additionalBundles.split("\\s+")) {
+                addBundle(additionalBundle);
+            }
+        }
+    }
+
+    /** Method to find the JMenuItem for a specific Action.
+     * @param menuBar JMenuBar to search
+     * @param action Action to find JMenuItem for
+     * @return JMenuItem for action or <code>null</code> if none found
+     * @throws NullPointerException if <var>action</var> or <var>menuBar</var> is <code>null</code>
+     */
+    @Nullable public static JMenuItem find(@NotNull final JMenuBar menuBar, @NotNull final Action action) {
+        //noinspection ConstantConditions
+        if (menuBar == null) {
+            throw new NullPointerException("null JMenuBar not allowed");
+        }
+        //noinspection ConstantConditions
+        if (action == null) {
+            throw new NullPointerException("null Action not allowed");
+        }
+        for (int i = 0; i < menuBar.getMenuCount(); i++) {
+            final JMenu menu = menuBar.getMenu(i);
+            if (menu.getAction() == action) {
+                return menu;
+            } else {
+                final JMenuItem ret = find(menu, action);
+                if (ret != null) {
+                    return ret;
+                }
+            }
+        }
+        return null;
+    }
+
+    /** Method to find the JMenuItem for a specific Action.
+     * @param menu JMenu to search
+     * @param action Action to find JMenuItem for
+     * @return JMenuItem for action or <code>null</code> if none found
+     * @throws NullPointerException if <var>menu</var> or <var>action</var> is <code>null</code>
+     */
+    @Nullable public static JMenuItem find(@NotNull final JMenu menu, @NotNull final Action action) {
+        for (int i = 0; i < menu.getItemCount(); i++) {
+            final JMenuItem item = menu.getItem(i);
+            if (item == null) {
+                // Ignore Separators
+            } else if (item.getAction() == action) {
+                return item;
+            } else if (item instanceof JMenu) {
+                final JMenuItem ret = find((JMenu) item, action);
+                if (ret != null) {
+                    return ret;
+                }
+            }
+        }
+        return null;
+    }
+
+    /** Create an ActionFactory.
+     * This constructor is private to force users to use the method {@link #getFactory(String)} for recycling ActionFactories and profit of easy
+     * access to the same ActionFactory from within the whole application without passing around ActionFactory references.
+     */
+    private ActionFactory() {
+    }
+
+    /** Get the ActionMap.
+     * @return ActionMap
+     */
+    @NotNull public ActionMap getActionMap() {
+        return actionMap;
+    }
+
+    /** Add a ResourceBundle to the list of used bundles.
+     * @param bundle ResourceBundle to add
+     * @throws NullPointerException if <code>bundle == null</code>
+     */
+    public void addBundle(@NotNull final ResourceBundle bundle) throws NullPointerException {
+        //noinspection ConstantConditions
+        if (bundle == null) {
+            throw new NullPointerException("null ResourceBundle not allowed");
+        }
+        if (!bundles.contains(bundle)) {
+            // insert first because new bundles override old bundles
+            bundles.add(0, bundle);
+        }
+    }
+
+    /** Add a parent to the list of used parents.
+     * @param parent Parent to use if lookups failed in this ActionFactory
+     * WARNING: Adding a descendents as parents of ancestors or vice versa will result in endless recursion and thus stack overflow!
+     * @throws NullPointerException if <code>parent == null</code>
+     */
+    public void addParent(@NotNull final ActionFactory parent) throws NullPointerException {
+        //noinspection ConstantConditions
+        if (parent == null) {
+            throw new NullPointerException("null ActionFactory not allowed");
+        }
+        parents.add(parent);
+    }
+
+    /** Add a Preferences to the list of used preferences.
+     * @param pref Preferences to add
+     * @throws NullPointerException if <code>pref == null</code>
+     */
+    public void addPref(@NotNull final Preferences pref) throws NullPointerException {
+        //noinspection ConstantConditions
+        if (pref == null) {
+            throw new NullPointerException("null ResourceBundle not allowed");
+        }
+        if (!prefs.contains(pref)) {
+            prefs.add(pref);
+        }
+    }
+
+    /** Add a Preferences to the list of used preferences.
+     * @param clazz the class whose package a user preference node is desired
+     * @see Preferences#userNodeForPackage(Class)
+     * @throws NullPointerException if <code>clazz == null</code>
+     */
+    public void addPref(@NotNull final Class<?> clazz) {
+        //noinspection ConstantConditions
+        if (clazz == null) {
+            throw new NullPointerException("null Class not allowed");
+        }
+        addPref(userNodeForPackage(clazz));
+    }
+
+    /** Creates actions.
+     * This is a loop variant of {@link #createAction(boolean,String)}.
+     * The actions created can be retrieved using {@link #getAction(String)} or via the ActionMap returned by {@link #getActionMap()}.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param keys Keys of actions to create
+     * @return Array with created actions
+     * @throws NullPointerException in case keys is or contains <code>null</code>
+     */
+    public Action[] createActions(final boolean store, @NotNull final String... keys) throws NullPointerException {
+        final Action[] actions = new Action[keys.length];
+        for (int i = 0; i < keys.length; i++) {
+            actions[i] = createAction(store, keys[i]);
+        }
+        return actions;
+    }
+
+    /** Create an Action.
+     * The created Action is automatically stored together with all other Actions created by this Factory instance in an ActionMap, which you can
+     * retreive using {@link #getActionMap()}.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param key Key for Action, which is used as basename for access to Preferences and ResourceBundles and as ActionMap key (may not be
+     * <code>null</code>)
+     * @return created Action, which is a dummy in the sense that its {@link Action#actionPerformed(ActionEvent)} method does not do anything
+     * @throws NullPointerException in case <var>key</var> was <code>null</code>
+     * @see #createAction(boolean,String,Object)
+     * @see #createToggle(boolean,String,Object)
+     * @see #initAction(boolean,Action,String)
+     */
+    public Action createAction(final boolean store, @NotNull final String key) throws NullPointerException {
+        // initAction() checks for null key
+        return initAction(store, new DummyAction(), key);
+    }
+
+    /** Initialize an Action.
+     * This is a convenience method for Action users which want to use the services provided by this {@link ActionFactory} class but need more
+     * sophisticated Action objects they created on their own.
+     * So you can simply create an Action and pass it to this Initialization method to fill its data.
+     * The initialized Action is automatically stored together with all other Actions created by this Factory instance in an ActionMap, which you can
+     * retreive using {@link #getActionMap()}.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param action Action to fill
+     * @param key Key for Action, which is used as basename for access to Preferences and ResourceBundles and as ActionMap key (may not be <code>null</code>)
+     * @return the supplied Action object (<var>action</var>) is returned for convenience
+     * @throws NullPointerException in case <var>key</var> was <code>null</code>
+     */
+    @SuppressWarnings({"NestedAssignment"})
+    public Action initAction(final boolean store, @NotNull final Action action, @NotNull final String key) throws NullPointerException {
+        if (key == null) { throw new NullPointerException("null key for Action initialization not allowed."); }
+        action.putValue(ACTION_ID, key);
+        String value;
+        if ((value = getString(key + ".text"            )) != null) { action.putValue(NAME,              value); }
+        if ((value = getString(key + ".shortdescription")) != null) { action.putValue(SHORT_DESCRIPTION, value); }
+        if ((value = getString(key + ".longdescription" )) != null) { action.putValue(LONG_DESCRIPTION,  value); }
+        if ((value = getString(key + ".accel"           )) != null) { action.putValue(ACCELERATOR_KEY,   getKeyStroke(value)); }
+        if ((value = getString(key + ".accel2"          )) != null) { action.putValue(ACCELERATOR_KEY_2, getKeyStroke(value)); }
+        if ((value = getString(key + ".mnemonic"        )) != null) { action.putValue(MNEMONIC_KEY,      getKeyStroke(value).getKeyCode()); }
+        if ((value = getString(key + ".icon"            )) != null) {
+            final Icon image = getDefaultIconManager().getIcon(value);
+            if (image != null) { action.putValue(SMALL_ICON, image); }
+        }
+        action.putValue(REFLECTION_MESSAGE_PROVIDER, this);
+        if (store) {
+            actionMap.put(key, action);
+        }
+        return action;
+    }
+
+    /** Get a String.
+     * First looks one pref after another, in their addition order.
+     * Then looks one bundle after another, in their addition order.
+     * @param key Key to get String for
+     * @return the first value found or <code>null</code> if no value could be found
+     * @throws NullPointerException if <var>key</var> is <code>null</code>
+     */
+    @Nullable public String getString(@NotNull final String key) throws NullPointerException {
+        if (key == null) {
+            throw new NullPointerException("null key not allowed");
+        }
+        String value = null;
+        for (final Preferences pref : prefs) {
+            value = pref.get(key, value);
+            if (value != null) {
+                return value;
+            }
+        }
+        for (final ResourceBundle bundle : bundles) {
+            try {
+                value = bundle.getString(key);
+                return value;
+            } catch (final MissingResourceException e) { /* ignore */
+            } catch (final ClassCastException e) { /* ignore */
+            } // ignore exceptions because they don't mean errors just there's no resource, so parents are checked or null is returned.
+        }
+        for (final ActionFactory parent : parents) {
+            value = parent.getString(key);
+            if (value != null) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    /** Get a String from the preferences, ignoring the resource bundles.
+     * @param key Key to get String for
+     * @return the first value found or <code>null</code> if no value could be found
+     * @throws NullPointerException if <var>key</var> is <code>null</code>
+     */
+    @Nullable public String getStringFromPrefs(@NotNull final String key) throws NullPointerException {
+        if (key == null) {
+            throw new NullPointerException("null key not allowed");
+        }
+        String value = null;
+        for (final Preferences pref : prefs) {
+            value = pref.get(key, value);
+            if (value != null) {
+                return value;
+            }
+        }
+        for (final ActionFactory parent : parents) {
+            value = parent.getStringFromPrefs(key);
+            if (value != null) {
+                return value;
+            }
+        }
+        return null;
+    }
+
+    /** Get a String from the resource bundles, ignoring the preferences.
+     * @param key Key to get String for
+     * @return the first value found or <code>null</code> if no value could be found
+     * @throws NullPointerException if <var>key</var> is <code>null</code>
+     */
+    @Nullable public String getStringFromBundles(@NotNull final String key) throws NullPointerException {
+        if (key == null) {
+            throw new NullPointerException("null key not allowed");
+        }
+        String value;
+        for (final ResourceBundle bundle : bundles) {
+            try {
+                value = bundle.getString(key);
+                return value;
+            } catch (final MissingResourceException e) { /* ignore */
+            } catch (final ClassCastException e) { /* ignore */
+            } // ignore exceptions because they don't mean errors just there's no resource, so parents are checked or null is returned.
+        }
+        for (final ActionFactory parent : parents) {
+            value = parent.getStringFromBundles(key);
+            if (value != null) {
+                return value;
+            }
+        }
+        return null;
+    }
+    /** Creates actions.
+     * This is a loop variant of {@link #createAction(boolean,String,Object)}.
+     * The actions created can be retrieved using {@link #getAction(String)} or via the ActionMap returned by {@link #getActionMap()}.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param target Target object
+     * @param keys Keys of actions to create
+     * @return Array with created actions
+     * @throws NullPointerException in case keys is or contains <code>null</code>
+     */
+    public Action[] createActions(final boolean store, final Object target, final String... keys) throws NullPointerException {
+        final Action[] actions = new Action[keys.length];
+        for (int i = 0; i < keys.length; i++) {
+            actions[i] = createAction(store, keys[i], target);
+        }
+        return actions;
+    }
+
+    /** Create an Action.
+     * The created Action is automatically stored together with all other Actions created by this Factory instance in an ActionMap, which you can
+     * retreive using {@link #getActionMap()}.
+     * The supplied object needs to have a zero argument method named <var>key</var>.
+     * You may pass <code>null</code> as object, which means that the object the method is invoked on is not defined yet.
+     * You may safely use the Action, it will not throw any Exceptions upon {@link Action#actionPerformed(ActionEvent)} but simply silently do nothing.
+     * The desired object can be set later using <code>action.putValue({@link ReflectionAction#REFLECTION_TARGET}, <var>object</var>)</code>.
+     * <p />
+     * Users of this method can assume that the returned object behaves quite like {@link ReflectionAction}.
+     * Wether or not this method returns an instance of {@link ReflectionAction} should not be relied on.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param key Key for Action, which is used as basename for access to Preferences and ResourceBundles, as ActionMap key and as Reflection Method
+     * name within the supplied object (may not be <code>null</code>)
+     * @param object Instance to invoke method on if the Action was activated ({@link Action#actionPerformed(ActionEvent)})
+     * @return created Action
+     * @throws NullPointerException in case <var>key</var> was <code>null</code>
+     * @see #createAction(boolean,String)
+     * @see #createToggle(boolean,String,Object)
+     * @see #initAction(boolean,Action,String)
+     */
+    public Action createAction(final boolean store, final String key, final Object object) throws NullPointerException {
+        if (key == null) { throw new NullPointerException("null key for Action creation not allowed."); }
+        final Action action = new ReflectionAction(key, object);
+        initAction(store, action, key);
+        return action;
+    }
+
+    /** Method for creating a Menu.
+     * @param store whether to store the initialized Action in the ActionMap of this ActionFactory
+     * @param menuKey action key for Menu
+     * @param keys Action keys for menu items
+     * @return menu created fro...
 
[truncated message content]

Thread: [Japi-cvs] SF.net SVN: japi: [187] libs/swing-action/trunk

japi-cvs