/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2008 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.awt.Image;

import java.awt.event.ActionEvent;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.beans.PropertyChangeSupport;

import java.util.Collection;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

import java.util.Set;

import javax.swing.AbstractAction;

import javax.swing.Action;

import javax.swing.ImageIcon;

import org.openide.util.lookup.ProxyLookup;

/**

 * An action which operates in the global <i>selection context</i> (a

 * Lookup such as the return value of Utilities.actionsGlobalContext()).

 * Context actions are sensitive to the presence or absence of a particular

 * Java type in a Lookup.  The presence or absence of objects of that type

 * can changed based on things like what the user has selected, or what

 * logical window contains focus.

 * <p/>

 * Context actions make it possible to have a global action (i.e. it doesn't

 * have to know anything in particular about what it's going to operate on

 * to be created) which nonetheless acts on whatever happens to be selected

 * at some moment in time.

 * <p/>

 * This class is a replacement for most uses of NodeAction and CookieAction

 * in the Nodes API.

 *

 * <h4>Using ContextAction in place of NodeAction or CookieAction</h4>

 * Replacing CookieAction with ContextAction is fairly straightforward.

 * The one use-case which is not supported is writing an action which can

 * be enabled in the case of multiple different object types with no

 * common superclass (this can still be handled by implementing ContextAwareAction

 * on your own subclass of AbstractAction;  you just don't get the convenience

 * of this class).

 * <p/>

 * The most straightforward replacement for <code>CookieAction</code> is

 * <code>LookupProviderAction</code>.  It handles one layer of indirection -

 * that is, a <code>CookieAction</code> first needs to have at least one <code>Node</code>

 * selected;  a <code>Node is itself a <code>Lookup.Provider</code>,

 * and so the <code>CookieAction</code>

 * is sensitive to some object type in the lookup of one or more selected

 * <code>Node</code>s.  So a <code>CookieAction</code> is an action sensitive

 * to an object (the cookie) in the lookup of an object in the selection (the node).

 * <p/>

 * <code>LookupProviderAction</code> accomplishes the same thing, without

 * requiring that the second <code>Lookup.Provider</code> be a <code>Node</code>.

 * <p>

 * CookieAction supported a number of different <i>mode</i>s

 * which determined its enablement, based on how many objects were in the

 * selection and if there were any lookups in the selection that did <i>not</i>

 * contain an instance of the type it was sensitive to.  In <code>LookupProviderAction</code>,

 * this distinction is split into its two constituents:  To disallow enablement

 * if there is some Lookup.Provider that does <i>not</i> contain the type you

 * care about, pass true to the superclass constructor for the <code>all</code>

 * parameter.  To control for the number of selected items, override

 * <code>checkQuantity(int)</code>.

 * <p/>

 * It is also possible with <code>ContextAction</code>s to do deeper indirection.

 * E.g., say the selection will contain a <code>Node</code>.  <code>Node</code>

 * implements <code>Lookup.Provider</code>.  You are interested in <code>Node</code>s

 * which have a <code>Project</code> in their lookup, and <code>Project</code>

 * is also a <code>Lookup.Provider</code> too.  What you really want to do is

 * write an action that is enabled

 * <ul><li>When the selection contains a <code>Node</code>

 *   <ul><li>which contains a <code>Project</code> in its lookup</code>

 *      <ul><li>which contains a <code>Foo</code> in its lookup</code>

 *      </ul</li>

 *   </ul></li>

 * </ul></li>

 * The only actually interesting logic here is what you will do with a

 * <code>Foo</code> if you can get hold of one.  Handling this is easy:

 * <pre>

 * ContextAction<Foo> theRealAction = new MyContextAction(); //this is what you wrote

 * Action<Node> theGlobalAction = createIndirectAction(Node.class,

 *   createIndirectAction(Project.class, theRealAction));

 * </pre>

 * In the NetBeans IDE, to declaratively install such an action, simply write

 * a static method that contains the above code, and reference it in your

 * layer file as the <code>methodvalue</code> for your <code>.instance</code>

 * or similar file.

 * <p/>

 * To paraphrase, it's

 * <a href="http://en.wikipedia.org/wiki/Turtles_all_the_way_down">lookups

 * all the way down</a>.

 *

 * @see org.openide.util.ContextAwareAction

 * @see org.openide.util.Lookup

 * @see org.openide.util.Utilities.actionsGlobalContext()

 * @author Tim Boudreau

 */

public abstract class ContextAction<T> extends AbstractAction implements ContextAwareAction, HelpCtx.Provider {

    private final Class<T> type;

    private final StubListener stubListener = new StubListener();

    //A context aware instance which we use internally to trigger

    //enabled changes as long as there is at least one property change

    //listener attached to us.

    //By having the same thing we return from createContextAwareInstance handle

    //all internal state, we make it easy to make a survives-focus-change

    //subclass just by overriding createStub() to make a stub which retains

    //the last usable collection of objects

    ActionStub stub;

    static boolean unitTest;

    /**

     * Create a new ContextAction which will operate on instances of

     * type <code>type</code>

     * @param type The type this action needs in its context in order to be

     * invoked

     */

    protected ContextAction(Class<T> type) {

        this (type, null, null);

    }

    /**

     * Create a new ContextAction which will operate on a type <code>type</code>,

     * with the specified display name and icon.

     *

     * @param type The type this action needs in its context in order to be

     * invoked

     * @param displayName A localized display name

     * @param icon An image to use as the action's icon

     */

    protected ContextAction(Class<T> type, String displayName, Image icon) {

        this.type = type;

        if (type == null) {

            throw new NullPointerException ("Type null");

        }

        if (displayName != null) {

            putValue (Action.NAME, displayName);

        }

        if (icon != null) {

            putValue (Action.SMALL_ICON, new ImageIcon (icon));

        }

        putValue ("noIconInMenu", true);

    }

    /**

     * Whether or not the action is enabled.  By default, determines if there

     * are any instances of type <code>type</code> in the selection context

     * lookup, and if there are, returns true.  To refine this behavior further,

     * override <code>enabled (java.util.Collection)</code>.

     * @return

     */

    @Override

    public final boolean isEnabled() {

        ActionStub stubAction = getStub();

        Collection <? extends T> targets = stubAction.collection();

        boolean result = checkQuantity(targets) && stubAction.isEnabled();

        return result;

    }

    boolean checkQuantity(Collection<? extends T> targets) {

        return checkQuantity (targets.size());

    }

    protected boolean checkQuantity (int numberOfObjects) {

        return numberOfObjects > 0;

    }

    /**

     * Determine if this action should be enabled.  This method will only be

     * called if the size of the collection is > 0.  The default implementation

     * returns <code>true</code>.  If you need to do some further

     * test on the collection of objects to determine if the action should

     * really be enabled or not, override this method do that here.

     *

     * @param targets A collection of objects of type <code>type</code>

     * @return Whether or not the action should be enabled.

     */

    protected boolean enabled(Collection<? extends T> targets) {

        return true;

    }

    /**

     * Overridden to throw an UnsupportedOperationException.  Do not call.

     * @param newValue

     */

    @Override

    public final void setEnabled(boolean newValue) {

        throw new UnsupportedOperationException();

    }

    /**

     * Override to actually do whatever this action does.  This method is

     * passed the current collection of objects present in the selection

     * context.

     * @param targets The objects of type <code>type</code>, which

     * this action will use to do whatever it does

     */

    protected abstract void actionPerformed(Collection<? extends T> targets);

    /**

     * Fetches the collection of objects this action will act on and passes

     * them to <code>actionPerformed(Collection<? extends T>).

     * @param e The action event.  Ignored.

     */

    public final void actionPerformed(ActionEvent ignored) {

        getStub().actionPerformed(null);

    }

    /**

     * Create an instance of this action over a particular context.  This is

     * used to handle cases such as popup menus, where a popup menu is created

     * against whatever the selection is at the time of its creation;  if the

     * selection changes <i>while</i> the popup is onscreen, we do not want

     * the popup to operate on the new selection; it should operate on the thing

     * that the user right-clicked.  So for a popup menu, an instance of this

     * action is created over a snapshot-lookup - a snapshot

     * of the context at the moment it is created.

     * @param actionContext The context this action instance should operate on.

     * @return

     */

    public final Action createContextAwareInstance(Lookup actionContext) {

        return createStub (actionContext);

    }

    ActionStub<T> createStub(Lookup actionContext) {

        return new ActionStub<T>(actionContext, this);

    }

    private ActionStub<T> createInternalStub () {

        //Don't synchronize, just ensure we are only called from sync methods

        assert Thread.holdsLock(this);

        ActionStub result = (ActionStub)

                createContextAwareInstance (Utilities.actionsGlobalContext());

        return result;

    }

    private synchronized ActionStub<T> getStub() {

        if (stub == null && attached) {

            stub = createInternalStub();

            stub.addPropertyChangeListener(stubListener);

        }

        return stub == null ? createInternalStub() : stub;

    }

    /**

     * Get the help context, if any.  Returns <code>HelpCtx.DEFAULT_HELP</code>

     * by default.

     * @return A help context

     */

    public HelpCtx getHelpCtx() {

        return HelpCtx.DEFAULT_HELP;

    }

    @Override

    public String toString() {

        return super.toString() + "[type=" + type.getName() + "]";

    }

    @Override

    public boolean equals(Object obj) {

        if (obj == null) {

            return false;

        }

        if (getClass() != obj.getClass()) {

            return false;

        }

        final ContextAction<T> other = (ContextAction<T>) obj;

        if (this.type != other.type && (this.type == null || !this.type.equals(other.type))) {

            return false;

        }

        return true;

    }

    @Override

    public int hashCode() {

        int hash = 7;

        hash = 47 * hash + (this.type != null ? this.type.hashCode() : 0);

        return hash;

    }

    @Override

    public synchronized void addPropertyChangeListener(PropertyChangeListener listener) {

        super.addPropertyChangeListener(listener);

        int count = getPropertyChangeListeners().length;

        if (count == 1) {

            addNotify();

        }

    }

    @Override

    public synchronized void removePropertyChangeListener(PropertyChangeListener listener) {

        super.removePropertyChangeListener(listener);

        int count = getPropertyChangeListeners().length;

        if (count == 0) {

            removeNotify();

        }

    }

    volatile boolean attached;

    void addNotify() {

        assert Thread.holdsLock(this);

        attached = true;

        stub = getStub();

    }

    void removeNotify() {

        assert Thread.holdsLock(this);

        attached = false;

        stub.removePropertyChangeListener(stubListener);

        stub = null;

    }

    //for unit tests

    synchronized Collection<? extends T> stubCollection() {

        return stub == null ? null : stub.collection();

    }

    private class StubListener implements PropertyChangeListener {

        public void propertyChange(PropertyChangeEvent evt) {

            if ("enabled".equals(evt.getPropertyName())) { //NOI18N

                firePropertyChange (evt.getPropertyName(),

                        evt.getOldValue(), evt.getNewValue());

            }

        }

    }

    //Inner stub action class which delegates to the parent action's methods.

    //Used both for context aware instances, and for internal state for

    //ContextAction instances

    private static class ActionStub<T> implements Action, LookupListener {

        private final Lookup.Result<T> lkpResult;

        private final Map<String, Object> pairs = new HashMap<String, Object>();

        private final PropertyChangeSupport supp = new PropertyChangeSupport(this);

        private final Lookup context;

        protected final ContextAction parent;

        protected boolean enabled;

        ActionStub(Lookup context, ContextAction parent) {

            assert context != null;

            this.context = context;

            this.parent = parent;

            lkpResult = context.lookupResult(parent.type);

            lkpResult.addLookupListener(this);

            if (getClass() == ActionStub.class) {

                //avoid superclass call to Retained.collection() before

                //it has initialized

                enabled = isEnabled();

            }

        }

        public Object getValue(String key) {

            Object result = pairs.get(key);

            if (result == null) {

                result = parent.getValue(key);

            }

            return result;

        }

        Collection<? extends T> collection() {

            return lkpResult.allInstances();

        }

        public void putValue(String key, Object value) {

            Object old = pairs.put(key, value);

            boolean fire = (old == null) != (value == null);

            if (fire) {

                fire = value != null && !value.equals(old);

                if (fire) {

                    supp.firePropertyChange (key, old, value);

                }

            }

        }

        public void setEnabled(boolean b) {

            //Will throw exception

            parent.setEnabled(b);

        }

        public boolean isEnabled() {

            Collection<? extends T> targets = collection();

            assert targets != null;

            assert parent != null;

            return targets.isEmpty() ? false : parent.checkQuantity(targets) &&

                    parent.enabled(targets);

        }

        public void addPropertyChangeListener(PropertyChangeListener listener) {

            supp.addPropertyChangeListener(listener);

        }

        public void removePropertyChangeListener(PropertyChangeListener listener) {

            supp.removePropertyChangeListener(listener);

        }

        public void actionPerformed(ActionEvent e) {

            assert isEnabled() : "Not enabled: " + this + " collection " +

                    collection() + " of " + parent.type.getName();

            Collection<? extends T> targets = collection();

            parent.actionPerformed(targets);

        }

        void enabledChanged(final boolean enabled) {

            Mutex.EVENT.readAccess(new Runnable() {

                public void run() {

                    supp.firePropertyChange("enabled", !enabled, enabled); //NOI18N

                    if (unitTest) {

                        synchronized (parent) {

                            parent.notifyAll();

                        }

                        synchronized (this) {

                            this.notifyAll();

                        }

                    }

                }

            });

        }

        public void resultChanged(LookupEvent ev) {

            boolean old = enabled;

            enabled = isEnabled();

            if (old != enabled) {

                enabledChanged (enabled);

            }

        }

        @Override

        public String toString() {

            return super.toString() + "[name=" + getValue (NAME) + //NOI18N

                    "delegating={"+ parent + "} context=" + //NOI18N

                    context +"]"; //NOI18N

        }

        @Override

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final ActionStub<T> other = (ActionStub<T>) obj;

            if (this.parent != other.parent && (this.parent == null || !this.parent.equals(other.parent))) {

                return false;

            }

            if (this.context != other.context && (this.context == null || !this.context.equals(other.context))) {

                return false;

            }

            return true;

        }

        @Override

        public int hashCode() {

            int hash = 7;

            hash = 59 * hash + (this.context != null ? this.context.hashCode() : 0);

            hash = 59 * hash + (this.parent != null ? this.parent.hashCode() : 0);

            return hash;

        }

    }

    /**

     * Subclass of ContextAction which does not support multi-selection -

     * like ContextAction, it is sensitive to a particular type.  However,

     * it only is enabled if there is exactly one object of type <code>type</code>

     * in the selection.

     * @param <T> The type this action is sensitive to

     */

    public static abstract class Single<T> extends ContextAction<T> {

        protected Single (Class<T> type) {

            super (type);

        }

        protected Single(Class<T> type, String displayName, Image icon) {

            super (type, displayName, icon);

        }

        /**

         * Delegates to actionePerformed(T)</code> with the first and

         * only element of the collection.

         * @param targets The objects this action may operate on

         */

        @Override

        protected final void actionPerformed(Collection<? extends T> targets) {

            actionPerformed (targets.iterator().next());

        }

        /**

         * Actually perform the action.

         * @param target The only instance of <code>T</code> in the action

         * context.

         */

        protected abstract void actionPerformed (T target);

        @Override

        protected final boolean checkQuantity(int count) {

            return count == 1;

        }

    /**

     * Determine if this action should be enabled.  This method will only be

     * called if the size of the collection == 1.  The default implementation

     * returns <code>true</code>.  If you need to do some further

     * test on the collection of objects to determine if the action should

     * really be enabled or not, override this method do that here.

     *

     * @param targets A collection of objects of type <code>type</code>

     * @return Whether or not the action should be enabled.

     */

        @Override

        protected boolean enabled(Collection<? extends T> targets) {

            //Overridden only in order to have different javadoc

            return super.enabled(targets);

        }

    }

    /**

     * A context action which, once enabled, remains enabled.

     * <p/>

     * The canonical example of this sort of action in the NetBeans IDE is

     * NextErrorAction:  It becomes enabled when the output window gains

     * focus.  But it should remain enabled when focus goes back to the

     * editor, and still work against whatever context the output window

     * gave it to work on.  Such cases are rare but legitimate.

     * <p/>

     * Use judiciously - such actions are temporary memory

     * leaks - the action will retain the last usable collection of

     * objects it had to work on as long as there are any property

     * change listeners attached to it.

     *

     * @param <T> The type this object is sensitive to

     */

    public static abstract class SurviveSelectionChange<T> extends Single<T> {

        protected SurviveSelectionChange (Class<T> type) {

            super (type);

        }

        protected SurviveSelectionChange(Class<T> type, String displayName, Image icon) {

            super (type, displayName, icon);

        }

        @Override

        ActionStub<T> createStub(Lookup actionContext) {

            return new RetainingStub<T> (actionContext, this);

        }

        @Override

        boolean checkQuantity(Collection<? extends T> targets) {

            return super.checkQuantity(targets) || stub != null &&

                    super.checkQuantity(((RetainingStub) stub).retained);

        }

        private static final class RetainingStub<T> extends ActionStub<T> {

            Collection <? extends T> retained;

            RetainingStub(Lookup context, SurviveSelectionChange parent) {

                super (context, parent);

                assert parent != null;

                assert context != null;

                retained = super.collection();

                assert retained != null;

                enabled = isEnabled();

            }

            @Override

            Collection <? extends T> collection() {

                boolean wasEnabled = enabled;

                if (wasEnabled) {

                    Collection <? extends T> nue = super.collection();

                    assert nue != null;

                    //If we were enabled, and now we have too many objects,

                    //become disabled, don't keep the old single object

                    if (!parent.checkQuantity(nue)) {

                        retained = nue;

                    }

                    if (!nue.isEmpty()) {

                        retained = nue;

                    }

                }

                return retained;

            }

        }

    }

    /**

     * LookupProviderAction is an action subclass which looks up some

     * type which implements Lookup.Provider in the global selection, and then

     * actually delegates to some other type in the lookups of the Lookup.Providers

     * within.

     * <p/>

     * The canonical example of this is NodeContextAction, which looks for one or more Nodes

     * in the global action context, but what it really needs to operate on

     * is some objects that may or may not be in those Nodes' lookups.

     * <p/>

     * This also handles the case of exclusive multi-selection, where the action

     * should only be enabled if like objects are selected.  An example of this

     * is OpenAction, which should be enabled if all of the selected files

     * own an OpenCookie, but should not be enabled otherwise.

     * <p/>

     * To do more than one level of indirection of Lookup.Providers, or to

     * impose restrictions such as how many instances of a type can be in the

     * lookup, use IndirectAction and pass it a subclass of

     * ContextAction (such as ContextAction.Single) that does what you want.

     * <p/>

     * Anything that can be done with this class can be done with

     * DelegateAction;  this class just simplifies the common case of one

     * layer of indirection.

     *

     * @param <T> The type of Lookup.Provider to look for in the selection - for

     * example, Node.class or Project.class

     * @param <R> The type of object this action will actually operate on - for

     * example, an OpenCookie instance

     */

    public static abstract class LookupProviderAction<T extends Lookup.Provider, R> extends ContextAction <T>{

        private final Class<R> delegateType;

        private final boolean all;

        private final ContextAction<R> overDelegateType;

        private boolean inDelegate;

        /**

         * Create a new LookupProviderAction.

         * @param type The type of Lookup.Provider to find in the global selection

         * @param delegateType The type of object to look for in the lookups of the instances

         * of <code>type</code> in the global selection

         * @param all If true, all T's in the global selection must contain at least one R

         * for this action to be enabled.  If false, it is enabled if there are any R's in

         * any of the T's lookups.

         */

        protected LookupProviderAction (Class<T> type, Class<R> delegateType, boolean all) {

            super (type);

            assert delegateType != null;

            this.delegateType = delegateType;

            this.all = all;

            overDelegateType = new InternalDelegateAction(delegateType);

        }

        /**

         * Create a new LookupProviderAction.

         * @param type The type of Lookup.Provider to find in the global selection

         * @param delegateType The type of object to look for in the lookups of the instances

         * of <code>type</code> in the global selection

         * @param all If true, all T's in the global selection must contain at least one R

         * for this action to be enabled.  If false, it is enabled if there are any R's in

         * any of the T's lookups.

         * @param displayName The localized display name

         * @param icon The icon

         */

        protected LookupProviderAction (Class<T> type, Class<R> delegateType, boolean all, String displayName, Image icon) {

            super (type, displayName, icon);

            assert delegateType != null;

            this.delegateType = delegateType;

            this.all = all;

            overDelegateType = new InternalDelegateAction(delegateType);

        }

        protected final void actionPerformed(Collection<? extends T> targets) {

            if (all) {

                Collection<? extends R> delegates = delegates(targets);

                assert delegates != null && !delegates.isEmpty();

            }

            Action contextDelegate = overDelegateType.createContextAwareInstance(

                    delegateLookup());

            assert contextDelegate.isEnabled();

            contextDelegate.actionPerformed((ActionEvent) null);

        }

        /**

         * Determine if this action should be enabled in the case of

         * multi-selection.  By default this method simply returns true

         * if lookupProviderCount > 0.  To have an action which only

         * is enabled if there is exactly one selected item, override

         * and test <code>lookupProviderCount == 1</code>.

         * <p/>

         * Note that the number passed to this method is the number of

         * <i><code>Lookup.Provider</code></i>s in the selection, <b>not</b>

         * the number of objects of type R in those Lookup.Providers.

         * If you want to control for that, override <code>isEnabled(Collection)</code>.

         *

         * @param lookupProviderCount The number of Lookup.Providers of type T

         * in the selection

         * @return true if the action should be enabled

         */

        @Override

        protected boolean checkQuantity(int lookupProviderCount) {

            return lookupProviderCount > 0;

        }

        /**

         * Creates a ProxyLookup over all selected Lookup.Providers of type T

         * @return A lookup that proxies all the lookups of all T's in the

         * current global selection

         */

        private synchronized Lookup delegateLookup() {

            inDelegate = true;

            try {

                List <Lookup> lookups = new LinkedList<Lookup>();

                Collection <? extends T> sc = super.getStub().collection();

                assert sc != null;

                for (Lookup.Provider provider : sc) {

                    lookups.add (provider.getLookup());

                }

                Lookup[] lkps = lookups.toArray (new Lookup[0]);

                return new ProxyLookup (lkps);

            } finally {

                inDelegate = false;

            }

        }

        /**

         * Get the objects of type R that we really want to operate on.

         * @param targets The collection from the lookup of the current selection (which

         * is a Lookup.Provider)

         * @return A collection of R's.  If all Lookup.Providers in the selection

         * must contain an R and one or more do not, returns null.

         */

        private Set <? extends R> delegates(Collection<? extends T> targets) {

            Set <R> realTargets = new HashSet<R>();

            for (Lookup.Provider provider : targets) {

                Collection <? extends R> delegateCookies =

                        provider.getLookup().lookupAll (delegateType);

                if (all && delegateCookies.isEmpty()) {

                    return null;

                } else {

                    realTargets.addAll (delegateCookies);

                }

            }

            return realTargets;

        }

        /**

         * Actually perform the action on the collection of objects found

         * in the Lookup.Provider of type <code>T</code> in the lookup.

         * @param targets The collection of objects

         */

        protected abstract void perform(Collection <? extends R> targets);

        /**

         * Determine if the action should be enabled.  This method is only

         * called if the collection is non-empty.  The default implementation

         * simply returns true.  Only override this if you really need to

         * check the state of the objects in the collection to determine

         * if the action can really be performed.

         * @param targets The collection of objects found in the

         * Lookup.Provider of type <code>T</code> in the selection.

         * @return

         */

        protected boolean isEnabled (Collection<? extends R> targets) {

            return true;

        }

        @Override

        protected final boolean enabled(Collection<? extends T> targets) {

            if (inDelegate) {

                //Avoid endless loop when context aware instance also checks

                //its enablement to initialize its state

                return true;

            }

            boolean result;

            if (all) {

                //If all the Lookups must contain at least one R, make

                //sure they do

                Collection<? extends R> delegates = delegates(targets);

                result = delegates != null && !delegates.isEmpty();

            } else {

                result = true;

            }

            //Okay, we know we have a selection we can use.  Get an actual

            //instance

            if (result) {

                result = overDelegateType.createContextAwareInstance(delegateLookup()).isEnabled();

            }

            return result;

        }

        private class InternalDelegateAction extends ContextAction<R> {

            public InternalDelegateAction(Class<R> type) {

                super(type);

            }

            @Override

            protected void actionPerformed(Collection<? extends R> targets) {

                perform(targets);

            }

            @Override

            protected boolean enabled(Collection<? extends R> targets) {

                return LookupProviderAction.this.isEnabled(targets);

            }

            @Override

            public Object getValue(String key) {

                Object result = super.getValue(key);

                if (result == null) {

                    result = LookupProviderAction.this.getValue(key);

                }

                return result;

            }

        }

    }

    /**

     * Create an action which looks for a particular type <code>T</code> in

     * the selection, where T itself is a subclass <code>Lookup.Provider</code>

     * (such as a Node or Project in the NetBeans IDE), and delegates to

     * another action which is sensitive to some object in that lookup.

     * <p/>

     * Such actions can be chained to arbitrarily depths of lookup providers;

     * you only need to write a ContextAction that is sensitive to the thing

     * you are actually interested in at the end of the chain.

     * So, if you want to write an action which is sensitive to, say, a

     * ClassPathProvider that belongs to the Project found in the selected

     * Node in the global selection, you would do as follows:

     * <pre>

     * ContextAction<ClassPathProvider> theRealAction = new MyContextAction();

     * Action<Node> theGlobalAction = createIndirectAction(Node.class,

     *   createIndirectAction(Project.class, theRealAction));

     * </pre>

     * The returned action will pick up its properties (name, icon, enabled

     * state, etc.) from the action passed in to this one, and it will re-fire

     * property changes from that one.

     * <p>

     * If you need more specific control of enablement logic, either override

     * <code>enabled()</code> in your <code>ContextAction</code>, or use

     * one of the subclasses such as <code>Single</code> or

     * <code>SurviveSelectionChange</code> which provide

     * specific enablement behavior.

     *

     * @param <T>

     * @param lkpProviderType

     * @param theRealAction

     * @return

     */

    public static <T extends Lookup.Provider> ContextAction<T>

            createIndirectAction(Class<T> lkpProviderType, ContextAction<?> theRealAction) {

        return new IndirectAction (lkpProviderType, theRealAction);

    }

    /**

     * A ContextAction which looks for a specific subclass of Lookup.Provider

     * in the selection, and then delegates to another ContextAction for that

     * type.

     * <p/>

     * This class can be used to do multiple levels of indirection, simply

     * by passing another instance of IndirectAction to the constructor.

     * Say that you want to write an action that operates on the

     * ClassPathProvider of the Project which the selected Node belongs to.

     * This can be written quite simply:

     * <pre>

     * ContextAction<ClassPathProvider> theRealAction = new MyContextAction();

     * Action theGlobalAction = new IndirectAction<Node>(Project.class, new IndirectAction(ClassPathProvider.class, theRealAction));

     * </pre>

     * <p/>

     *

     * @param <T> The type of Lookup.Provider to look for in the lookup.

     * @param <R> The type that the passed ContextAction is interested in

     */

    static final class IndirectAction<T extends Lookup.Provider, R> extends ContextAction<T> {

        private final ContextAction<R> delegate;

        private final PCL pcl = new PCL();

        /**

         * Create a new IndirectAction.

         *

         * @param toLookupType The type of Lookup.Provider to find in the

         * selection

         * @param delegate The action that will look in those Lookup.Providers

         * lookups

         */

        public IndirectAction (Class<T> toLookupType, ContextAction<R> delegate) {

            super (toLookupType);

            this.delegate = delegate;

            delegate.addPropertyChangeListener(WeakListeners.propertyChange(pcl,

                    delegate));

        }

        @Override

        public Object getValue(String key) {

            Object result = super.getValue(key);

            if (result == null) {

                result = delegate.getValue(key);

            }

            return result;

        }

        private Lookup delegateLookup(Collection<? extends T> targets) {

            List <Lookup> lookups = new LinkedList<Lookup>();

            for (Lookup.Provider provider : targets) {

                lookups.add (provider.getLookup());

            }

            Lookup proxy = new ProxyLookup (lookups.toArray(new Lookup[0]));

            return proxy;

        }

        @Override

        protected void actionPerformed(Collection<? extends T> targets) {

            Action delegateStub = delegate.createContextAwareInstance(delegateLookup(targets));

            delegateStub.actionPerformed(null);

        }

        @Override

        protected boolean enabled(Collection<? extends T> targets) {

            Action delegateStub = delegate.createContextAwareInstance(delegateLookup(targets));

            return delegateStub.isEnabled();

        }

        private final class PCL implements PropertyChangeListener {

            public void propertyChange(PropertyChangeEvent evt) {

                firePropertyChange(evt.getPropertyName(), evt.getOldValue(),

                        evt.getNewValue());

            }

        }

    }

}

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2008 Sun Microsystems, Inc. All rights reserved.

 *

 * The contents of this file are subject to the terms of either the GNU

 * General Public License Version 2 only ("GPL") or the Common

 * Development and Distribution License("CDDL") (collectively, the

 * "License"). You may not use this file except in compliance with the

 * License. You can obtain a copy of the License at

 * http://www.netbeans.org/cddl-gplv2.html

 * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

 * specific language governing permissions and limitations under the

 * License.  When distributing the software, include this License Header

 * Notice in each file and include the License file at

 * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the GPL Version 2 section of the License file that

 * accompanied this code. If applicable, add the following below the

 * License Header, with the fields enclosed by brackets [] replaced by

 * your own identifying information:

 * "Portions Copyrighted [year] [name of copyright owner]"

 *

 * If you wish your version of this file to be governed by only the CDDL

 * or only the GPL Version 2, indicate your decision by adding

 * "[Contributor] elects to include this software in this distribution

 * under the [CDDL or GPL Version 2] license." If you do not indicate a

 * single choice of license, a recipient has the option to distribute

 * your version of this file under either the CDDL, the GPL Version 2 or

 * to extend the choice of license to its licensees as provided above.

 * However, if you add GPL Version 2 code and therefore, elected the GPL

 * Version 2 license, then the option applies only if the new code is

 * made subject to such option by the copyright holder.

 *

 * Contributor(s):

 *

 * Portions Copyrighted 2008 Sun Microsystems, Inc.

 */

package org.openide.util;

import java.awt.event.ActionEvent;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashSet;

import java.util.Set;

import javax.swing.Action;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.netbeans.junit.MockServices;

import org.netbeans.junit.NbTestCase;

import org.openide.util.lookup.AbstractLookup;

import org.openide.util.lookup.InstanceContent;

import org.openide.util.lookup.Lookups;

import org.openide.util.ContextAction.*;

import static org.junit.Assert.*;

/**

 *

 * @author Tim Boudreau

 */

public class ContextActionTest extends NbTestCase {

    public ContextActionTest(String x) { super (x); }

    @BeforeClass

    public static void setUpClass() throws Exception {

    }

    @AfterClass

    public static void tearDownClass() throws Exception {

    }

    private InstanceContent content;

    private Lookup lkp;

    private static final int TIMEOUT = 100;

    @Before

    @Override

    public void setUp() {

        //This will cause ContextAction instances to invoke notifyAll()

        //when their enablement changes

        ContextAction.unitTest = true;

        MockServices.setServices(Provider.class);

        ContextGlobalProvider x = Lookup.getDefault().lookup (ContextGlobalProvider.class);

        assertNotNull (x);

        assertTrue (x instanceof Provider);

        Provider p = (Provider) x;

        content = p.content;

        lkp = p.lkp;

        //some sanity checks

        setContent ("hello");

        assertEquals ("hello", lkp.lookupAll(String.class).iterator().next());

        assertEquals ("hello", Utilities.actionsGlobalContext().lookupAll(String.class).iterator().next());

        clearContent();

        assertEquals (null, lkp.lookup(String.class));

        assertEquals (null, Utilities.actionsGlobalContext().lookup(String.class));

        assertEquals (0, Utilities.actionsGlobalContext().lookupAll(Object.class).size());

    }

    static Provider instance;

    public static class Provider implements ContextGlobalProvider {

        private final Lookup lkp;

        private final InstanceContent content;

        public Provider () {

            lkp = new AbstractLookup (content = new InstanceContent());

            instance = this;

        }

        public Lookup createGlobalContext() {

            return lkp;

        }

    }

    void setContent(Object... stuff) {

        content.set(Arrays.asList(stuff), null);

    }

    void clearContent() {

        content.set(Collections.EMPTY_SET, null);

    }

    public void testEnablement() {

        assertEquals (0, lkp.lookupAll(String.class).size()); //sanity check

        A a = new A();

        assertFalse (a.isEnabled());

        setContent ("testEnablement");

        assertEquals (1, lkp.lookupAll(String.class).size()); //sanity check

        assertTrue (a.isEnabled());

        clearContent();

        assertFalse (a.isEnabled());

    }

    public void testEnablementFired() throws Exception {

        System.out.println("testEnablementFired");

        A a = new A();

        assertEquals (0, lkp.lookupAll(String.class).size());

        PCL pcl = new PCL();

        a.addPropertyChangeListener(pcl);

        assertFalse (a.isEnabled());

        setContent ("testEnablementFired");

        synchronized (a) {

            a.wait(TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        assertTrue (a.isEnabled());

        pcl.assertEnabledChangedTo(true);

        clearContent();

        assertFalse (a.isEnabled());

        synchronized (a) {

            a.wait (TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertEnabledChangedTo(false);

        setContent("woo");

        synchronized (a) {

            a.wait (TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertEnabledChangedTo(true);

        setContent ("hello", "goodbye");

        synchronized (a) {

            a.wait (TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertEnabledChangedTo(false);

        assertFalse (a.isEnabled());

        clearContent();

        synchronized (a) {

            a.wait (TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertNotFired();

        a.removePropertyChangeListener(pcl);

        setContent("hmm");

        assertTrue (a.isEnabled());

        pcl.assertNotFired();

    }

    public void testContextInstancesDoNotInterfereWithEachOtherOrParent() throws Exception {

        System.out.println("testContextInstancesDoNotInterfereWithEachOtherOrParent");

        A a = new A();

        assertNull (Utilities.actionsGlobalContext().lookup(String.class)); //sanity check

        assertEquals ("A", a.getValue(Action.NAME));

        Action a1 = a.createContextAwareInstance(Lookup.EMPTY);

        assertFalse (a.isEnabled());

        assertEquals ("A", a1.getValue(Action.NAME));

        Action a2 = a.createContextAwareInstance(Lookups.fixed("testGeneralBehavior"));

        assertTrue (a2.isEnabled());

        assertFalse (a.isEnabled());

        setContent ("foo");

        assertTrue (a.isEnabled());

        assertFalse (a1.isEnabled());

        assertTrue (a2.isEnabled());

        clearContent();

        assertFalse (a.isEnabled());

        assertTrue (a2.isEnabled());

    }

    public void testContextInstancesAreIndependent() throws Exception {

        System.out.println("testContextInstancesAreIndependent");

        A a = new A();

        assertNull (Utilities.actionsGlobalContext().lookup(String.class)); //sanity check

        InstanceContent ic = new InstanceContent();

        Lookup l = new AbstractLookup (ic);

        Action a3 = a.createContextAwareInstance(l);

        assertFalse (a3.isEnabled());

        PCL pcl = new PCL();

        a3.addPropertyChangeListener(pcl);

        setContent ("fuddle");

        a.assertNotPerformed();

        assertTrue (a.isEnabled());

        assertFalse (a3.isEnabled());

        synchronized (a3) {

            //should time out if test is going to pass

            a3.wait(TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertNotFired();

        ic.set(Collections.singleton("boo"), null);

        synchronized (a3) {

            a3.wait(TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        pcl.assertEnabledChangedTo(true);

        clearContent();

        assertTrue (a3.isEnabled());

        assertFalse (a.isEnabled());

    }

    public void testGetSetValue() {

        System.out.println("testGetSetValue");

        A a = new A();

        Action a1 = a.createContextAwareInstance(Lookup.EMPTY);

        Action a2 = a.createContextAwareInstance(Lookups.fixed("testGeneralBehavior"));

        a.putValue ("foo", "bar");

        assertEquals("bar", a.getValue("foo"));

        assertEquals("bar", a1.getValue("foo"));

        assertEquals("bar", a2.getValue("foo"));

        a1.putValue ("x", "y");

        assertNull (a.getValue("x"));

        assertEquals ("y", a1.getValue("x"));

        a.putValue("x", "z");

        assertEquals ("y", a1.getValue("x"));

        assertEquals ("z", a.getValue("x"));

    }

    public void testSurviveFocusChange() throws InterruptedException {

        System.out.println("testSurviveFocusChange");

        B b = new B();

        assertFalse (b.isEnabled());

        setContent ("testSurviveFocusChange");

        assertTrue (b.isEnabled());

        PCL pcl = new PCL();

        b.addPropertyChangeListener(pcl);

        setContent ("x");

        assertTrue (b.isEnabled());

        b.actionPerformed((ActionEvent)null);

        b.assertPerformed("x");

        clearContent();

        assertTrue (b.isEnabled());

        b.actionPerformed((ActionEvent) null);

        b.assertPerformed("x");

        setContent ("a", "b");

        assertFalse (b.isEnabled());

        synchronized (b) {

            b.wait(TIMEOUT);

        }

        synchronized (pcl) {

            pcl.wait(TIMEOUT);

        }

        assertFalse (b.createContextAwareInstance(Lookup.EMPTY).isEnabled());

        assertTrue (b.createContextAwareInstance(Lookups.fixed("foo")).isEnabled());

        assertFalse (b.createContextAwareInstance(Lookups.fixed("moo", "goo")).isEnabled());

    }

    public void testSingleNotEnabledOnMoreThanOne() throws Exception {

        System.out.println("testSingleNotEnabledOnMoreThanOne");

        A a = new A();

        assertFalse (a.createContextAwareInstance(Lookups.fixed("moo", "goo")).isEnabled());

        assertTrue (a.createContextAwareInstance(Lookups.fixed("foo")).isEnabled());

    }

    public void testExactCount() throws Exception {

        System.out.println("testExactCount");

        C c = new C();

        assertFalse (c.isEnabled());

        setContent ("1");

        assertFalse (c.isEnabled());

        setContent ("1", "2", "3", "4", "5");

        assertTrue (c.isEnabled());

        clearContent();

        assertFalse (c.isEnabled());

        setContent ("1", "2", "3", "4", "5");

        assertTrue (c.isEnabled());

        setContent ("1", "2", "3", "4", "5", "6");

        assertFalse (c.isEnabled());

    }

    public void testNesting() throws Exception {

        System.out.println("testNesting");

        D d = new D();

        Thing thingOne = new Thing ("a");

        Thing thingTwo = new Thing ("b");

        Thing thingThree = new Thing ("c");

        Thing thingFour = new Thing("d");

        Thing badThing = new Thing("no");

        FakeNode node1 = new FakeNode (thingOne);

        FakeNode node2 = new FakeNode (thingTwo);

        FakeNode node3 = new FakeNode (thingThree);

        FakeNode node4 = new FakeNode (thingFour);

        FakeNode nodeBad = new FakeNode (badThing);

        PCL pcl = new PCL();

        d.addPropertyChangeListener(pcl);

        assertFalse (d.isEnabled());

        setContent (node1);

        assertTrue (d.isEnabled());

        synchronized (d) {

            d.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(true);

        clearContent();

        synchronized (d) {

            d.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(false);

        assertFalse (d.isEnabled());

        setContent (node1, node2, node3, node4);

        assertTrue (d.isEnabled());

        setContent (node1, node2, node3, node4, nodeBad);

        synchronized (d) {

            d.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(false);

        assertFalse (d.isEnabled());

        setContent (node1, node2, node3, node4);

        assertTrue (d.isEnabled());

        d.actionPerformed((ActionEvent) null);

        Set<Thing> expected = new HashSet<Thing>(Arrays.asList(

                thingOne, thingTwo, thingThree, thingFour));

        d.assertTargets(expected);

        clearContent();

        assertFalse (d.isEnabled());

        FakeNode doesntHaveAThing = new FakeNode ("Hello");

        d = new D(true);

        assertFalse (d.isEnabled());

        setContent (node1);

        assertTrue (d.isEnabled());

        clearContent();

        assertFalse (d.isEnabled());

        setContent (node1, node2, node3, node4);

        assertTrue (d.isEnabled());

        clearContent();

        assertFalse (d.isEnabled());

        setContent (node1, node2, node3, doesntHaveAThing);

        assertFalse(d.isEnabled());

    }

    public void testDeepDelegation () throws Exception {

        System.out.println("testDeepDelegation");

        E e = new E();

        IndirectAction a = new IndirectAction (FakeNode.class,

                new IndirectAction(FakeProject.class, e));

        Thing thing1 = new Thing ("a");

        Thing thing2 = new Thing ("b");

        Thing thing3 = new Thing ("c");

        Thing thing4 = new Thing("d");

        Thing badThing = new Thing("no");

        FakeProject proj1 = new FakeProject (thing1);

        FakeProject proj2 = new FakeProject (thing2);

        FakeProject proj3 = new FakeProject (thing3);

        FakeProject proj4 = new FakeProject (thing4);

        FakeProject projBad = new FakeProject (badThing);

        FakeNode node1 = new FakeNode (proj1);

        FakeNode node2 = new FakeNode (proj2);

        FakeNode node3 = new FakeNode (proj3);

        FakeNode node4 = new FakeNode (proj4);

        FakeNode nodeBad = new FakeNode (projBad);

        assertFalse (a.isEnabled());

        setContent (node1, node2);

        assertTrue (a.isEnabled());

        setContent (node1, node2, node3);

        assertTrue (a.isEnabled());

        clearContent();

        assertFalse (a.isEnabled());

        setContent (node1, node2, node4);

        assertTrue (a.isEnabled());

        setContent (node1, node2, nodeBad);

        assertFalse (a.isEnabled());

        setContent (node1, node2);

        a.actionPerformed((ActionEvent) null);

        e.assertTargets(new HashSet<Thing>(Arrays.asList(thing1, thing2)));

        clearContent();

        PCL pcl = new PCL();

        a.addPropertyChangeListener(pcl);

        setContent (node1, node3);

        synchronized (a) {

            a.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(true);

        clearContent();

        synchronized (a) {

            a.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(false);

        setContent (node1, node3);

        synchronized (a) {

            a.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(true);

        setContent (nodeBad);

        synchronized (a) {

            a.wait(500);

        }

        synchronized (pcl) {

            pcl.wait(500);

        }

        pcl.assertEnabledChangedTo(false);

    }

    private class PCL implements PropertyChangeListener {

        PropertyChangeEvent evt;

        public void propertyChange(PropertyChangeEvent evt) {

            if ("enabled".equals (evt.getPropertyName())) {

                this.evt = evt;

            }

            synchronized (this) {

                notifyAll();

            }

        }

        void assertEnabledChangedTo (boolean val) {

            PropertyChangeEvent old = this.evt;

            this.evt = null;

            assertNotNull (old);

            Boolean b = Boolean.valueOf(val);

            assertEquals (b, old.getNewValue());

        }

        void assertNotFired() {

            assertNull (evt);

        }

    }

    private static class A extends ContextAction.Single<String> {

        String perfString;

        A() { super (String.class, "A", null); }

        @Override

        protected void actionPerformed(String target) {

            perfString = target;

        }

        void assertPerformed (String expected) {

            String old = perfString;

            perfString = null;

            assertNotNull (old);

            assertEquals (expected, old);

        }

        void assertNotPerformed () {

            assertNull (perfString);

        }

    }

    private static class B extends ContextAction.SurviveSelectionChange<String> {

        String perfString;

        B() { super (String.class, "B", null); }

        @Override

        protected void actionPerformed(String target) {

            perfString = target;

        }

        void assertPerformed (String expected) {

            String old = perfString;

            perfString = null;

            assertNotNull (old);

            assertEquals (expected, old);

        }

    }

    private static class C extends ContextAction<String> {

        Set <String> perfStrings;

        C() { super (String.class); }

        @Override

        protected boolean checkQuantity(int numberOfObjects) {

            return numberOfObjects == 5;

        }

        void assertPerformed (Set<String> expected) {

            Set<String> old = perfStrings;

            perfStrings = null;

            assertNotNull (old);

            assertEquals (expected, old);

        }

        @Override

        protected void actionPerformed(Collection<? extends String> targets) {

            perfStrings = new HashSet <String> (targets);

        }

    }

    private static class FakeNode implements Lookup.Provider {

        private final InstanceContent content = new InstanceContent();

        private final AbstractLookup lkp = new AbstractLookup (content);

        FakeNode (Object... contents) {

            content.set(Arrays.asList(contents), null);

        }

        public Lookup getLookup() {

            return lkp;

        }

    }

    private static class FakeProject implements Lookup.Provider {

        private final InstanceContent content = new InstanceContent();

        private final AbstractLookup lkp = new AbstractLookup (content);

        FakeProject (Object... contents) {

            content.set(Arrays.asList(contents), null);

        }

        public Lookup getLookup() {

            return lkp;

        }

    }

    private static final class Thing {

        private final String s;

        Thing (String s) {

            this.s = s;

        }

        @Override

        public boolean equals(Object obj) {

            if (obj == null) {

                return false;

            }

            if (getClass() != obj.getClass()) {

                return false;

            }

            final Thing other = (Thing) obj;

            if ((this.s == null) ? (other.s != null) : !this.s.equals(other.s)) {

                return false;

            }

            return true;

        }

        @Override

        public int hashCode() {

            int hash = 3;

            hash = 47 * hash + (this.s != null ? this.s.hashCode() : 0);

            return hash;

        }

        @Override

        public String toString () {

            return super.toString() + "[" + s + "]";

        }

    }

    private static final class D extends LookupProviderAction<FakeNode, Thing> {

        private Set<Thing> performedOn;

        D() {

            this (false);

        }

        D(boolean all) {

            super (FakeNode.class, Thing.class, all);

        }

        @Override

        protected void perform(Collection<? extends Thing> delegates) {

            this.performedOn = new HashSet <Thing> (delegates);

        }

        @Override

        protected boolean isEnabled(Collection<? extends Thing> targets) {

            return !targets.contains(new Thing("no"));

        }

        void assertTargets (Set <Thing> expected) {

            Set <Thing> old = performedOn;

            performedOn = null;

            assertNotNull ("Expected targets " + expected + " but got " +

                    old, old);

            assertEquals ("Expected targets " + expected + " but got " +

                    old, expected, old);

        }

    }

    private static final class E extends ContextAction <Thing> {

        private Set<Thing> performedOn;

        E() {

            super (Thing.class);

        }

        @Override

        protected void actionPerformed(Collection<? extends Thing> targets) {

            this.performedOn = new HashSet<Thing>(targets);

        }

        @Override

        protected boolean enabled(Collection<? extends Thing> targets) {

            return !targets.contains(new Thing("no"));

        }

        void assertTargets (Set <Thing> expected) {

            Set <Thing> old = performedOn;

            performedOn = null;

            assertNotNull ("Expected targets " + expected + " but got " +

                    old, old);

            assertEquals ("Expected targets " + expected + " but got " +

                    old, expected, old);

        }

    }

}