• Home
• org.netbeans.api
• org-netbeans-spi-viewmodel
• RELEASE240
• source code
• Models.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.netbeans.spi.viewmodel.Models Maven / Gradle / Ivy

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

package org.netbeans.spi.viewmodel;

import java.awt.Component;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DnDConstants;
import java.awt.event.ActionEvent;
import java.beans.PropertyEditor;
import java.io.IOException;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
import java.security.PrivilegedAction;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.Executor;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JComponent;
import javax.swing.JPopupMenu;
import javax.swing.SwingUtilities;
import javax.swing.table.TableCellEditor;
import javax.swing.table.TableCellRenderer;

import org.netbeans.modules.viewmodel.AsynchronousModel;
import org.netbeans.modules.viewmodel.DefaultTreeExpansionManager;
import org.netbeans.modules.viewmodel.HyperCompoundModel;
import org.netbeans.modules.viewmodel.ModelRootChangeListener;
import org.netbeans.modules.viewmodel.OutlineTable;
import org.netbeans.modules.viewmodel.TreeModelNode.ActionOnPresetNodes;
import org.netbeans.modules.viewmodel.TreeModelNode.DisableableAction;
import org.netbeans.modules.viewmodel.TreeModelRoot;

import org.netbeans.spi.viewmodel.AsynchronousModelFilter.CALL;
import org.openide.awt.Actions;
import org.openide.explorer.ExplorerManager;
import org.openide.explorer.view.OutlineView;
import org.openide.explorer.view.TreeView;
import org.openide.nodes.Node;
import org.openide.util.Exceptions;
import org.openide.util.datatransfer.PasteType;
import org.openide.windows.TopComponent;


/**
 * Contains various utility methods for various models.
 *
 * @author   Jan Jancura
 */
public final class Models {

    /** Cached default implementations of expansion models. */
    private static final WeakHashMap defaultExpansionModels = new WeakHashMap();
    
    /**
     * Empty model - returns default root node with no children.
     */
    public static CompoundModel EMPTY_MODEL = createCompoundModel 
        (new ArrayList ());
    
    
    public static int MULTISELECTION_TYPE_EXACTLY_ONE = 1;
    public static int MULTISELECTION_TYPE_ALL = 2;
    public static int MULTISELECTION_TYPE_ANY = 3;

    private static final int DEFAULT_DRAG_DROP_ALLOWED_ACTIONS = DnDConstants.ACTION_NONE;
    
    private static boolean verbose = 
        System.getProperty ("netbeans.debugger.models") != null;
    
    
    /**
     * Creates a new instance of TreeTableView
     * for given {@link org.netbeans.spi.viewmodel.Models.CompoundModel}.
     *
     * @param compoundModel a compound model instance
     *
     * @return new instance of complete model view
     */
    public static JComponent createView (
        CompoundModel compoundModel
    ) {
        /*if (compoundModel.isTree()) {
            OutlineTree ot = new OutlineTree();
            ot.setModel (compoundModel);
            return ot;
        } else {*/
        OutlineTable ot = new OutlineTable ();
        if (compoundModel != null && compoundModel.isHyperModel()) {
            ot.setModel(compoundModel.createHyperModel(), compoundModel.getTreeNodeDisplayFormat());
        } else {
            ot.setModel (compoundModel, (compoundModel != null) ? compoundModel.getTreeNodeDisplayFormat() : null);
        }
        return ot;
        //}
    }
    
    /**
     * Creates a root node of the nodes tree structure
     * for given {@link org.netbeans.spi.viewmodel.Models.CompoundModel}.
     *
     * @param compoundModel a compound model instance
     * @param treeView The tree view component where nodes are going to be displayed.
     *
     * @return new instance root node
     * @since 1.15
     */
    public static Node createNodes (
        CompoundModel compoundModel,
        TreeView treeView
    ) {
        if (compoundModel != null && compoundModel.isHyperModel()) {
            return new TreeModelRoot (compoundModel.createHyperModel(), treeView).getRootNode();
        } else {
            return new TreeModelRoot (compoundModel, treeView).getRootNode();
        }
    }
    
    /**
     * Set given models to given view instance.
     *
     * @param view a view instance - must be an instance created by {@link #createView} method.
     * @param compoundModel a compound model instance
     */
    public static void setModelsToView (
        final JComponent view,
        final CompoundModel compoundModel
    ) {
        if (!(view instanceof OutlineTable)) {
            throw new IllegalArgumentException("Expecting an instance of "+OutlineTable.class.getName()+", which can be obtained from Models.createView(). view = "+view);
        }
        if (verbose) {
            System.out.println (compoundModel);
        }
        SwingUtilities.invokeLater (new Runnable () {
            @Override
            public void run () {
                if (compoundModel != null && compoundModel.isHyperModel()) {
                    ((OutlineTable) view).setModel (compoundModel.createHyperModel(), compoundModel.getTreeNodeDisplayFormat());
                } else {
                    if (compoundModel != null) {
                        ((OutlineTable) view).setModel (compoundModel, compoundModel.getTreeNodeDisplayFormat());
                    } else {
                        ((OutlineTable) view).setModel (compoundModel);
                    }
                }
            }
        });
    }
    
    /**
     * Creates one {@link CompoundModel} from given list of models.
     * 

     * If this list does not include any instance of TreeModel or
     * TreeExpansionModel, a default implementation of these models is created
     * based on the instance of this list. Thus you get one implementation
     * per provided instance of the models list.
     * 
     * @param models a list of models
     * @return {@link CompoundModel} encapsulating given list of models
     */
    public static CompoundModel createCompoundModel (List models) {
        return createCompoundModel(models, null);
    }
    
    /**
     * Creates one {@link CompoundModel} from given list of models.
     * 

     * If this list does not include any instance of TreeModel or
     * TreeExpansionModel, a default implementation of these models is created
     * based on the instance of this list. Thus you get one implementation
     * per provided instance of the models list.
     * 
     * @param models a list of models
     * @param propertiesHelpID The help ID, which is set for the properties
     *        sheets created from this model.
     * @return {@link CompoundModel} encapsulating given list of models
     * @since 1.7
     */
    // TODO: Add createCompoundModel(List models, String propertiesHelpID, RequestProcessor rp)
    // Or instead of RP use some interface that could provide the desired thread to run in (current, AWT, RP thread,...)
    public static CompoundModel createCompoundModel (List models, String propertiesHelpID) {
        if (models.size() > 1 && models.get(0) instanceof CompoundModel && models.get(1) instanceof CompoundModel) {
            // Hypermodel
            ArrayList subModels = new ArrayList();
            CompoundModel mainModel = null;
            TreeModelFilter treeFilter = null;
            for (Object o : models) {
                if (o instanceof CompoundModel) {
                    if (subModels.contains((CompoundModel) o)) {
                        mainModel = (CompoundModel) o;
                        continue;
                    }
                    subModels.add((CompoundModel) o);
                } else if (o instanceof TreeModelFilter) {
                    treeFilter = (TreeModelFilter) o;
                }
            }
            if (mainModel == null) {
                mainModel = subModels.get(0);
            }
            return new CompoundModel(mainModel, subModels.toArray(new CompoundModel[]{}), treeFilter, propertiesHelpID);
        }

        MessageFormat treeNodeDisplayFormat = null;
        if (models.size() > 0 && models.get(models.size() - 1) instanceof MessageFormat) {
            treeNodeDisplayFormat = (MessageFormat) models.remove(models.size() - 1);
        }
        ModelLists ml = new ModelLists();
        List           otherModels;
        
        // Either the list contains 10 lists of individual models + one list of mixed models
        //  + optional TreeExpansionModelFilter(s) + optional AsynchronousModelFilter(s)
        // ; or the models directly
        boolean hasLists = false;
        int modelsSize = models.size();
        if (11 <= modelsSize && modelsSize <= 18) {
            Iterator it = models.iterator ();
            boolean failure = false;
            while (it.hasNext ()) {
                Object model = it.next();
                if (!(model instanceof List)) {
                    failure = true;
                    break;
                }
            }
            if (!it.hasNext() && !failure) { // All elements are lists
                hasLists = true;
            }
        }
        if (hasLists) { // We have 11 or 12 lists of individual models + optional RP
            ml.treeModels =            (List)       models.get(0);
            ml.treeModelFilters =      (List) models.get(1);
            revertOrder(ml.treeModelFilters);
            ml.treeExpansionModels =   (List) models.get(2);
            ml.nodeModels =            (List) models.get(3);
            ml.nodeModelFilters =      (List) models.get(4);
            revertOrder(ml.nodeModelFilters);
            ml.tableModels =           (List) models.get(5);
            ml.tableModelFilters =     (List) models.get(6);
            revertOrder(ml.tableModelFilters);
            ml.nodeActionsProviders =  (List) models.get(7);
            ml.nodeActionsProviderFilters = (List) models.get(8);
            revertOrder(ml.nodeActionsProviderFilters);
            ml.columnModels =          (List) models.get(9);
            otherModels =           (List) models.get(10);
            if (modelsSize > 11) { // TreeExpansionModelFilter
                ml.treeExpansionModelFilters = (List) models.get(11);
                //if (modelsSize > 12) { // AsynchronousModel
                //    ml.asynchModels = (List) models.get(12);
                    if (modelsSize > 12) { // AsynchronousModelFilter
                        ml.asynchModelFilters = (List) models.get(12);
                        if (modelsSize > 13) {
                            ml.tableRendererModels = (List) models.get(13);
                            if (modelsSize > 14) {
                                ml.tableRendererModelFilters = (List) models.get(14);
                                //if (modelsSize > 15) {
                                //    ml.tableHtmlModels = (List) models.get(15);
                                    if (modelsSize > 15) {
                                        ml.tableHtmlModelFilters = (List) models.get(15);
                                        if (modelsSize > 16) {
                                            ml.tablePropertyEditorsModels = (List) models.get(16);
                                            if (modelsSize > 17) {
                                                ml.tablePropertyEditorsModelFilters = (List) models.get(17);
                                            }
                                        }
                                    }
                                //}
                            }
                        }
                    }
                //}
            }
            //treeExpansionModelFilters = (models.size() > 11) ? (List) models.get(11) : (List) Collections.EMPTY_LIST;
        } else { // We have the models, need to find out what they implement
            otherModels =          (List) models;
        }

        ml.addOtherModels(otherModels);
        if (ml.treeExpansionModels.isEmpty()) {
            DefaultTreeExpansionModel defaultExpansionModel;
            synchronized (defaultExpansionModels) {
                defaultExpansionModel = defaultExpansionModels.get(models);
                if (defaultExpansionModel != null) {
                    defaultExpansionModel = defaultExpansionModel.cloneForNewModel();
                } else {
                    defaultExpansionModel = new DefaultTreeExpansionModel();
                }
                defaultExpansionModels.put(models, defaultExpansionModel);
            }
            ml.treeExpansionModels = Collections.singletonList((TreeExpansionModel) defaultExpansionModel);
        }
        /*
        System.out.println("ALL MODELS = "+models+"\n");
        System.out.println("Tree Models = "+ml.treeModels);
        System.out.println("Tree Model Filters = "+ml.treeModelFilters);
        System.out.println("Tree Expans Models = "+ml.treeExpansionModels);
        System.out.println("Node Models = "+ml.nodeModels);
        System.out.println("Node Model Filters = "+ml.nodeModelFilters);
        System.out.println("Table Models = "+ml.tableModels);
        System.out.println("Table Model Filters = "+ml.tableModelFilters);
        System.out.println("Node Action Providers = "+ml.nodeActionsProviders);
        System.out.println("Node Action Provider Filters = "+ml.nodeActionsProviderFilters);
        System.out.println("Column Models = "+ml.columnModels);
         */
        CompoundModel cm = createCompoundModel(ml, propertiesHelpID);
        cm.setTreeNodeDisplayFormat(treeNodeDisplayFormat);
        return cm;
    }

    private  static CompoundModel createCompoundModel (ModelLists ml, String propertiesHelpID) {
        if (ml.treeModels.isEmpty ()) {
            TreeModel etm = new EmptyTreeModel();
            ml.treeModels = Collections.singletonList(etm);
        }
        DefaultTreeExpansionModel defaultExpansionModel = null;
        if (ml.treeExpansionModels.isEmpty()) {
            synchronized (defaultExpansionModels) {
                defaultExpansionModel = defaultExpansionModels.get(ml);
                if (defaultExpansionModel != null) {
                    defaultExpansionModel = defaultExpansionModel.cloneForNewModel();
                } else {
                    defaultExpansionModel = new DefaultTreeExpansionModel();
                }
                defaultExpansionModels.put(ml, defaultExpansionModel);
            }
            ml.treeExpansionModels = Collections.singletonList((TreeExpansionModel) defaultExpansionModel);
        } else if (ml.treeExpansionModels.size() == 1) {
            if (ml.treeExpansionModels.get(0) instanceof DefaultTreeExpansionModel) {
                defaultExpansionModel = (DefaultTreeExpansionModel) ml.treeExpansionModels.get(0);
            }
        }
        /*if (ml.asynchModels.isEmpty()) {
            ml.asynchModels = Collections.singletonList((AsynchronousModel) new DefaultAsynchronousModel());
        }*/
        
        CompoundModel cm;
        if (ml.columnModels == null && ml.tableModels == null && ml.tableModelFilters == null &&
            ml.tableRendererModels == null && ml.tableRendererModelFilters == null) {
            
            cm = new CompoundModel (
            createCompoundTreeModel (
                new DelegatingTreeModel (ml.treeModels),
                ml.treeModelFilters
            ),
            createCompoundTreeExpansionModel(
                new DelegatingTreeExpansionModel (ml.treeExpansionModels),
                ml.treeExpansionModelFilters
            ),
            createCompoundNodeModel (
                new DelegatingNodeModel (ml.nodeModels),
                ml.nodeModelFilters
            ),
            createCompoundNodeActionsProvider (
                new DelegatingNodeActionsProvider (ml.nodeActionsProviders),
                ml.nodeActionsProviderFilters
            ),
            null, null,
            createCompoundAsynchronousModel (
                new DefaultAsynchronousModel(),//new DelegatingAsynchronousModel (ml.asynchModels),
                ml.asynchModelFilters
            ),
            null, null,
            propertiesHelpID
        );
        } else {
            cm = new CompoundModel (
            createCompoundTreeModel (
                new DelegatingTreeModel (ml.treeModels),
                ml.treeModelFilters
            ),
            createCompoundTreeExpansionModel(
                new DelegatingTreeExpansionModel (ml.treeExpansionModels),
                ml.treeExpansionModelFilters
            ),
            createCompoundNodeModel (
                new DelegatingNodeModel (ml.nodeModels),
                ml.nodeModelFilters
            ),
            createCompoundNodeActionsProvider (
                new DelegatingNodeActionsProvider (ml.nodeActionsProviders),
                ml.nodeActionsProviderFilters
            ),
            ml.columnModels,
            createCompoundTableModel (
                new DelegatingTableModel (ml.tableModels),
                ml.tableModelFilters,
                ml.tableHtmlModelFilters
            ),
            createCompoundAsynchronousModel (
                new DefaultAsynchronousModel(),//new DelegatingAsynchronousModel (ml.asynchModels),
                ml.asynchModelFilters
            ),
            createCompoundTableRendererModel (
                new DelegatingTableRendererModel(ml.tableRendererModels),
                ml.tableRendererModelFilters
            ),
            /*createCompoundTableHTMLModel (
                new DelegatingTableHTMLModel(ml.tableHtmlModels),
                ml.tableHtmlModelFilters
            ),*/
            createCompoundTablePropertyEditorModel (
                new DelegatingTablePropertyEditorsModel(ml.tablePropertyEditorsModels),
                ml.tablePropertyEditorsModelFilters
            ),
            propertiesHelpID
        );
        }
        if (defaultExpansionModel != null) {
            defaultExpansionModel.setCompoundModel(cm);
        }
        return cm;
    }
    
    private static  void revertOrder(List filters) {
        int n = filters.size();
        // [TODO] do not remove the following line, prevents null to be returned by filters.remove(i);
        // needs deeper investigation why it can occure
        filters.toString();
        for (int i = 0; i < n; ) {
            T filter = filters.remove(i);
            boolean first = filter.getClass ().getName ().endsWith ("First");
            if (first) { // The "First" should be the last one in this list
                filters.add(filter);
                n--;
            } else {
                filters.add(0, filter);
                i++;
            }
        }
    }
    
    
    /**
     * Returns {@link javax.swing.Action} for given parameters.
     *
     * @param displayName a display name for action
     * @param performer a performer for action
     * @param multiselectionType The type of the multi selection - one of the
     *        MULTISELECTION_TYPE_* constants.
     *
     * @return a new instance of {@link javax.swing.Action} for given parameters
     */
    public static Action createAction (
        String displayName, 
        ActionPerformer performer,
        int multiselectionType
    ) {
        return new ActionSupport (
            displayName, 
            performer, 
            multiselectionType
        );
    }
    
    /**
     * Returns implementation of tree view features for given view.
     *
     * @param view a view created by this Models class
     * @throws UnsupportedOperationException in the case that given 
     *        view is not tree view
     * @return implementation of tree view features
     */
    public static TreeFeatures treeFeatures (JComponent view) 
    throws UnsupportedOperationException {
        return new DefaultTreeFeatures (view);
    }
    
    
    // private methods .........................................................
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and
     * {@link org.netbeans.spi.viewmodel.TreeModelFilter}.
     * 
     * @param originalTreeModel a original tree model
     * @param treeModelFilter a list of tree model filters
     *
     * @returns compund tree model
     */
    private static ReorderableTreeModel createCompoundTreeModel (
        ReorderableTreeModel originalTreeModel,
        List treeModelFilters
    ) {
        ReorderableTreeModel tm = originalTreeModel;
        int i, k = treeModelFilters.size ();
        for (i = 0; i < k; i++) {
            tm = new CompoundTreeModel (
                tm,
                (TreeModelFilter) treeModelFilters.get (i)
            );
        }
        return tm;
    }
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.NodeModel} for given NodeModel and
     * {@link org.netbeans.spi.viewmodel.NodeModelFilter}.
     * 
     * @param originalNodeModel a original node model
     * @param nodeModelFilters a list of node model filters
     *
     * @returns compound tree model
     */
    private static SuperNodeModel createCompoundNodeModel (
        SuperNodeModel originalNodeModel,
        List treeNodeModelFilters
    ) {
        SuperNodeModel nm = originalNodeModel;
        int i, k = treeNodeModelFilters.size ();
        for (i = 0; i < k; i++) {
            nm = new CompoundNodeModel (
                nm,
                (NodeModelFilter) treeNodeModelFilters.get (i)
            );
        }
        return nm;
    }
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.TableModel} for given TableModel and
     * {@link org.netbeans.spi.viewmodel.TableModelFilter}.
     * 
     * @param originalTableModel a original table model
     * @param tableModelFilters a list of table model filters
     *
     * @returns compound table model
     */
    private static TableHTMLModel createCompoundTableModel (
        TableHTMLModel originalTableModel,
        List tableModelFilters,
        List tableHtmlModelFilters
    ) {
        TableHTMLModel tm = originalTableModel;
        int i, k = tableModelFilters.size ();
        for (i = 0; i < k; i++) {
            tm = new CompoundTableModel (
                tm,
                (TableModelFilter) tableModelFilters.get (i)
            );
        }
        k = tableHtmlModelFilters.size ();
        for (i = 0; i < k; i++) {
            tm = new CompoundTableModel (
                tm,
                (TableHTMLModelFilter) tableHtmlModelFilters.get (i)
            );
        }
        return tm;
    }
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.TableModel} for given TableModel and
     * {@link org.netbeans.spi.viewmodel.TableModelFilter}.
     *
     * @param originalTableModel a original table model
     * @param tableModelFilters a list of table model filters
     *
     * @returns compound table model
     */
    private static TableRendererModel createCompoundTableRendererModel (
        TableRendererModel originalTableModel,
        List tableModelFilters
    ) {
        TableRendererModel tm = originalTableModel;
        int i, k = tableModelFilters.size ();
        for (i = 0; i < k; i++) {
            tm = new CompoundTableRendererModel (
                tm,
                (TableRendererModelFilter) tableModelFilters.get (i)
            );
        }
        return tm;
    }
    
    private static TablePropertyEditorsModel createCompoundTablePropertyEditorModel (
        TablePropertyEditorsModel originalTableModel,
        List tableModelFilters
    ) {
        TablePropertyEditorsModel tm = originalTableModel;
        int i, k = tableModelFilters.size ();
        for (i = 0; i < k; i++) {
            tm = new CompoundTablePropertyEditorsModel (
                tm,
                (TablePropertyEditorsModelFilter) tableModelFilters.get (i)
            );
        }
        return tm;
    }

    /**
     * Creates {@link org.netbeans.spi.viewmodel.NodeActionsProvider} for given NodeActionsProvider and
     * {@link org.netbeans.spi.viewmodel.NodeActionsProviderFilter}.
     * 
     * @param originalNodeActionsProvider a original node actions provider
     * @param nodeActionsProviderFilters a list of node actions provider filters
     *
     * @returns compound node actions provider
     */
    private static NodeActionsProvider createCompoundNodeActionsProvider (
        NodeActionsProvider originalNodeActionsProvider,
        List nodeActionsProviderFilters
    ) {
        NodeActionsProvider nap = originalNodeActionsProvider;
        int i, k = nodeActionsProviderFilters.size ();
        for (i = 0; i < k; i++) {
            nap = new CompoundNodeActionsProvider (
                nap,
                (NodeActionsProviderFilter) nodeActionsProviderFilters.get (i)
            );
        }
        return nap;
    }
    
    private static TreeExpansionModel createCompoundTreeExpansionModel (
            TreeExpansionModel expansionModel,
            List filters
    ) {
        for (TreeExpansionModelFilter filter : filters) {
            expansionModel = new CompoundTreeExpansionModel (expansionModel, filter);
        }
        return expansionModel;
    }

    private static AsynchronousModel createCompoundAsynchronousModel (
            AsynchronousModel asynchModel,
            List filters
    ) {
        for (AsynchronousModelFilter filter : filters) {
            asynchModel = new CompoundAsynchronousModel (asynchModel, filter);
        }
        return asynchModel;
    }
    
    
    // innerclasses ............................................................
    
    /**
     * @author   Jan Jancura
     */
    private static class ActionSupport extends AbstractAction implements DisableableAction,
                                                                         ActionOnPresetNodes {

        private ActionPerformer     performer;
        private int                 multiselectionType;
        private String              displayName;
        private PrivilegedAction    enabledTest;
        private List          presetNodes;

 
        ActionSupport (
            String displayName, 
            ActionPerformer performer,
            int multiselectionType
        ) {
            super (displayName);
            this.performer = performer;
            this.displayName = displayName;
            this.multiselectionType = multiselectionType;
        }
        
        @Override
        public void addNode(Node n) {
            if (SwingUtilities.isEventDispatchThread()) {
                if (presetNodes == null) {
                    presetNodes = new LinkedList();
                    SwingUtilities.invokeLater(new PresetNodesCleaner());
                }
                presetNodes.add(n);
            }
        }
        
        private Node[] getActiveNodes(ActionEvent e) {
            Node[] nodes = null;
            if (e != null) {
                nodes = getOutlineViewSelection(e);
            } else if (presetNodes != null) {
                nodes = presetNodes.toArray(new Node[] {});
            }
            if (nodes == null) {
                nodes = TopComponent.getRegistry().getActivatedNodes();
            }
            return nodes;
        }
        
        private Node[] getOutlineViewSelection(ActionEvent e) {
            Object source = e.getSource();
            if (source instanceof Component) {
                Component c = (Component) source;
                JPopupMenu popupMenu = null;
                while (c != null) {
                    if (c instanceof JPopupMenu) {
                        popupMenu = (JPopupMenu) c;
                        break;
                    }
                    c = c.getParent();
                }
                if (popupMenu != null) {
                    c = popupMenu.getInvoker();
                    while (c != null) {
                        if (c instanceof OutlineView || c instanceof TreeView) {
                            ExplorerManager manager = ExplorerManager.find(c);
                            return manager.getSelectedNodes();
                        }
                        c = c.getParent();
                    }
                }
            }
            return null;
        }
        
        @Override
        public boolean isEnabled () {
            if (enabledTest != null) {
                if (Boolean.FALSE.equals(enabledTest.run())) {
                    return false;
                }
            }
            boolean any = multiselectionType == MULTISELECTION_TYPE_ANY;
            Node[] ns = getActiveNodes(null);
            if (multiselectionType == MULTISELECTION_TYPE_EXACTLY_ONE) {
                if (ns.length != 1) {
                    return false;
                }
                return performer.isEnabled (
                    ns[0].getLookup().lookup(Object.class)
                );
            }
            int i, k = ns.length;
            if (k == 0) {
                if (!performer.isEnabled(TreeModel.ROOT)) {
                    return false;
                }
            } else {
                for (i = 0; i < k; i++) {
                    if (!performer.isEnabled(ns[i].getLookup().lookup(Object.class))) {
                        if (!any) {
                            return false;
                        }
                    } else if (any) {
                        return true;
                    }
                }
                if (any) {
                    return false;
                }
            }
            return true;
        }

        @Override
        public void actionPerformed (ActionEvent e) {
            //System.err.println("Models.ActionSupport.actionPerformed("+e+")");
            Node[] ns = getActiveNodes(e);
            int i, k = ns.length;
            IdentityHashMap> h = new IdentityHashMap>();
            for (i = 0; i < k; i++) {
                Object node = ns[i].getLookup().lookup(Object.class);
                Action[] as = ns [i].getActions (false);
                int j, jj = as.length;
                for (j = 0; j < jj; j++) {
                    if (equals (as [j])) {
                        ArrayList