Attachment #19667 for bug #46167

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 46167
Collapse All | Expand All





    
    public SessionsTableModel () {
//        Session session = DebuggerManager.getDebuggerManager ().
//            getCurrentSession ();
//        session.addPropertyChangeListener (
//            Session.PROP_CURRENT_LANGUAGE, 
//            this
//        );
    }
    
    public Object getValueAt (Object row, String columnID) throws 




            return;
        if (tree == null) {
            setLayout (new BorderLayout ());
            tree = Models.createView (Models.EMPTY_MODEL);
                (null, null, null, null, new ArrayList ());
            tree.setName ("BreakpointsView");
            add (tree, "Center");  //NOI18N
        }

    }
    
    public String getName () {
        return NbBundle.getMessage 
            (BreakpointsView.class, "CTL_Breakpoints_view");
    }
    
    public String getToolTipText () {
        return NbBundle.getMessage 
            (BreakpointsView.class, "CTL_Breakpoints_view_tooltip");// NOI18N
    }
}

Lines 46-53 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/CallStackView.java (-2 / +1 lines)
46	return;	46	return;
47	if (tree == null) {	47	if (tree == null) {
48	setLayout (new BorderLayout ());	48	setLayout (new BorderLayout ());
49	tree = Models.createView	49	tree = Models.createView (Models.EMPTY_MODEL);
50	(null, null, null, null, new ArrayList ());
51	tree.setName ("CallStackView");	50	tree.setName ("CallStackView");
52	add (tree, "Center"); //NOI18N	51	add (tree, "Center"); //NOI18N
53	}	52	}

Lines 46-53 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/LocalsView.java (-2 / +1 lines)
46	return;	46	return;
47	if (tree == null) {	47	if (tree == null) {
48	setLayout (new BorderLayout ());	48	setLayout (new BorderLayout ());
49	tree = Models.createView	49	tree = Models.createView (Models.EMPTY_MODEL);
50	(null, null, null, null, new ArrayList ());
51	tree.setName ("LocalsView");	50	tree.setName ("LocalsView");
52	add (tree, "Center"); //NOI18N	51	add (tree, "Center"); //NOI18N
53	}	52	}

Lines 49-56 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/SessionsView.java (-2 / +1 lines)
49	return;	49	return;
50	if (tree == null) {	50	if (tree == null) {
51	setLayout (new BorderLayout ());	51	setLayout (new BorderLayout ());
52	tree = Models.createView	52	tree = Models.createView (Models.EMPTY_MODEL);
53	(null, null, null, null, new ArrayList ());
54	tree.setName ("SessionsView");	53	tree.setName ("SessionsView");
55	add (tree, "Center"); //NOI18N	54	add (tree, "Center"); //NOI18N
56	}	55	}

Lines 47-54 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/ThreadsView.java (-2 / +1 lines)
47	return;	47	return;
48	if (tree == null) {	48	if (tree == null) {
49	setLayout (new BorderLayout ());	49	setLayout (new BorderLayout ());
50	tree = Models.createView	50	tree = Models.createView (Models.EMPTY_MODEL);
51	(null, null, null, null, new ArrayList ());
52	tree.setName ("ThreadsView");	51	tree.setName ("ThreadsView");
53	add (tree, "Center"); //NOI18N	52	add (tree, "Center"); //NOI18N
54	}	53	}




import org.netbeans.api.debugger.DebuggerEngine;
import org.netbeans.api.debugger.DebuggerManager;
import org.netbeans.api.debugger.DebuggerManagerAdapter;
import org.netbeans.spi.viewmodel.Model;
import org.netbeans.spi.viewmodel.Models;
import org.netbeans.spi.viewmodel.ColumnModel;
import org.netbeans.spi.viewmodel.TableModelFilter;

import org.netbeans.spi.viewmodel.NodeModel;
import org.netbeans.spi.viewmodel.NodeModelFilter;
import org.netbeans.spi.viewmodel.TableModel;
import org.netbeans.spi.viewmodel.TreeExpansionModel;
import org.netbeans.spi.viewmodel.TreeModel;
import org.netbeans.spi.viewmodel.TreeModelFilter;
import org.netbeans.spi.viewmodel.TreeModelListener;

        );
        Models.setModelsToView (
            view, 
            Models.EMPTY_MODEL
            Models.EMPTY_NODE_MODEL, 
            Models.EMPTY_TABLE_MODEL, 
            Models.EMPTY_NODE_ACTIONS_PROVIDER, 
            Collections.EMPTY_LIST
        );
    }


    }
    
    private void updateModel () {
        DebuggerManager dm = DebuggerManager.getDebuggerManager ();
        DebuggerEngine e = dm.getCurrentEngine ();
        ArrayList l = new ArrayList ();
        if (e != null) {
            l.addAll (e.lookup (viewType, TreeModel.class));
            l.addAll (e.lookup (viewType, TreeModelFilter.class));
            l.addAll (e.lookup (viewType, TreeExpansionModel.class));
            l.addAll (e.lookup (viewType, NodeModel.class));
            l.addAll (e.lookup (viewType, NodeModelFilter.class));
            l.addAll (e.lookup (viewType, TableModel.class));
            l.addAll (e.lookup (viewType, TableModelFilter.class));
            l.addAll (e.lookup (viewType, NodeActionsProvider.class));
            l.addAll (e.lookup (viewType, NodeActionsProviderFilter.class));
            l.addAll (e.lookup (viewType, ColumnModel.class));
            l.addAll (e.lookup (viewType, Model.class));
        }
        l.addAll (dm.lookup (viewType, TreeModel.class));
        l.addAll (dm.lookup (viewType, TreeModelFilter.class));
        l.addAll (dm.lookup (viewType, TreeExpansionModel.class));
        l.addAll (dm.lookup (viewType, NodeModel.class));
        l.addAll (dm.lookup (viewType, NodeModelFilter.class));
        l.addAll (dm.lookup (viewType, TableModel.class));
        l.addAll (dm.lookup (viewType, TableModelFilter.class));
        l.addAll (dm.lookup (viewType, NodeActionsProvider.class));
        l.addAll (dm.lookup (viewType, NodeActionsProviderFilter.class));
        l.addAll (dm.lookup (viewType, ColumnModel.class));
        l.addAll (dm.lookup (viewType, Model.class));
        
        Models.setModelsToView (view, Models.createCompoundModel (l));
            view, 
            Models.createCompoundTreeModel (
                tm, 
                loadModels (TreeModelFilter.class)
            ),
            Models.createCompoundNodeModel (
                Models.createCompoundNodeModel (
                    l
                ),
                loadModels (NodeModelFilter.class)
            ),
            Models.createCompoundTableModel (
                Models.createCompoundTableModel (
                    loadModels (TableModel.class)
                ),
                loadModels (TableModelFilter.class)
            ),
            Models.createCompoundNodeActionsProvider (
                Models.createCompoundNodeActionsProvider (
                    loadModels (NodeActionsProvider.class)
                ),
                loadModels (NodeActionsProviderFilter.class)
            ),
            loadModels (ColumnModel.class)
        );
                    
    }
    
    private Object loadModel (Class modelType) {
        DebuggerEngine e = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        Object m = null;
        if (e != null)
            m = e.lookupFirst (viewType, modelType);
        if (m == null)
            m = DebuggerManager.getDebuggerManager ().
                lookupFirst (viewType, modelType);
        return m;
    }

    private List loadModels (Class modelType) {
        DebuggerEngine e = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        List l = new ArrayList ();
        if (e != null)
            l.addAll (e.lookup (viewType, modelType));
        l.addAll (DebuggerManager.getDebuggerManager ().
            lookup (viewType, modelType));
        return l;
    }

    

Lines 46-53 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/WatchesView.java (-2 / +1 lines)
46	return;	46	return;
47	if (tree == null) {	47	if (tree == null) {
48	setLayout (new BorderLayout ());	48	setLayout (new BorderLayout ());
49	tree = Models.createView	49	tree = Models.createView (Models.EMPTY_MODEL);
50	(null, null, null, null, new ArrayList ());
51	tree.setName ("WatchesView");	50	tree.setName ("WatchesView");
52	add (tree, "Center"); //NOI18N	51	add (tree, "Center"); //NOI18N
53	}	52	}




import java.beans.PropertyEditor;
import java.lang.IllegalAccessException;
import java.lang.ref.WeakReference;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.KeyStroke;
import javax.swing.SwingUtilities;

import org.netbeans.spi.viewmodel.ColumnModel;
import org.netbeans.spi.viewmodel.Models;
import org.netbeans.spi.viewmodel.UnknownTypeException;

import org.openide.nodes.AbstractNode;

    
    // variables ...............................................................

    private Models.CompoundModel model;
    private TreeModelRoot       treeModelRoot;
    private Object              object;
    

    * Creates root of call stack for given producer.
    */
    public TreeModelNode ( 
        final Models.CompoundModel model, 
        final TreeModelRoot treeModelRoot,
        final Object object
    ) {
        super (
            createChildren (model, treeModelRoot, object),

    }
    
    private static Children createChildren (
        Models.CompoundModel model, 
        TreeModelRoot treeModelRoot,
        Object object
    ) {

        }
    }
    
//    public String getName () {
//        try {
//            if (name == null) {
//                name = model.getDisplayName (object);
//                if (name == null) 
//                    throw new NullPointerException (
//                        "Model: " + model + ".getDisplayName (" + object + 
//                        ") = null!"
//                    );
//            }
//            return name;
//        } catch (UnknownTypeException e) {
//            e.printStackTrace ();
//            System.out.println (model);
//            System.out.println ();
//            return object.toString ();
//        } catch (final ComputingException ex) {
//            name = "";
//            RequestProcessor.getDefault ().post (new Runnable () {
//                public void run () {
//                    name = (String) ex.getValue ();
//                    if (name == null) {
//                        name = "?";
//                        throw new NullPointerException (
//                            "Model: " + model + ".getDisplayName (" + object + 
//                            ") = null!"
//                        );
//                    }
//                    setName (name);
//                    setDisplayName (name);
//                }
//            });
//            return "";
//        }
//    }
//    
//    public String getDisplayName () {
//        return getName ();
//    }
    
    public String getShortDescription () {
        if (shortDescription == null) {
            RequestProcessor.getDefault ().post (new Runnable () {

    private static final class TreeModelChildren extends Children.Keys {
            
        private boolean             initialezed = false;
        private Models.CompoundModel model;
        private TreeModelRoot       treeModelRoot;
        private Object              object;
        private WeakHashMap         objectToNode = new WeakHashMap ();
        
        
        TreeModelChildren (
            Models.CompoundModel model,
            TreeModelRoot   treeModelRoot,
            Object          object
        ) {

                            System.out.println ();
                        }
                        setKeys (new Object [0]);
                        return;
                    }
                }
            });

        
        void refreshChildren (int count) {
            try {
                final Object[] ch = model.getChildren (
                    object, 
                    0, 
                    count

                }
                objectToNode = newObjectToNode;
                setKeys (ch);
                
                SwingUtilities.invokeLater (new Runnable () {
                    public void run () {
                        int i, k = ch.length;
                        for (i = 0; i < k; i++)
                            try {
                                if (model.isExpanded (ch [i]))
                                    treeModelRoot.getTreeTable ().expandNode (ch [i]);
                            } catch (UnknownTypeException ex) {
                            }
                    }
                });
            } catch (UnknownTypeException e) {
                setKeys (new Object [0]);
                if (!(object instanceof String)) {




import java.util.Iterator;
import java.util.WeakHashMap;
import javax.swing.SwingUtilities;
import org.netbeans.spi.viewmodel.Models;

import org.netbeans.spi.viewmodel.TreeModel;
import org.netbeans.spi.viewmodel.TreeModelListener;

    
    // variables ...............................................................

    private Models.CompoundModel model;
    private TreeModelNode rootNode;
    private WeakHashMap objectToNode = new WeakHashMap ();
    private TreeTable treeTable;


    public TreeModelRoot (Models.CompoundModel model, TreeTable treeTable) {
        this.model = model;
        this.treeTable = treeTable;
        model.addTreeModelListener (this);
    }
    
    public TreeTable getTreeTable () {
        return treeTable;
    }

    public TreeModelNode getRootNode () {
        if (rootNode == null)

        objectToNode.put (o, new WeakReference (n));
    }
    
    TreeModelNode findNode (Object o) {
        WeakReference wr = (WeakReference) objectToNode.get (o);
        if (wr == null) return null;
        return (TreeModelNode) wr.get ();




import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.event.TreeExpansionListener;
import javax.swing.event.TreeExpansionEvent;


import org.netbeans.spi.viewmodel.Models;
import org.netbeans.spi.viewmodel.ColumnModel;
import org.netbeans.spi.viewmodel.UnknownTypeException;
import org.openide.explorer.ExplorerActions;

import org.openide.explorer.ExplorerManager;

 * @author   Jan Jancura
 */
public class TreeTable extends JPanel implements 
ExplorerManager.Provider, PropertyChangeListener, TreeExpansionListener {
    
    private ExplorerManager     explorerManager;
    private MyTreeTable         treeTable;
    private Node.Property[]     columns;
    private List                expandedPaths = new ArrayList ();
    private TreeModelRoot       currentTreeModelRoot;
    private Models.CompoundModel model;
    
    
    private ExplorerActions     explorerActions = new ExplorerActions ();
    {explorerActions.setConfirmDelete (false);}

            treeTable.setHorizontalScrollBarPolicy 
                (JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
        add (treeTable, "Center");  //NOI18N
        treeTable.getTree ().addTreeExpansionListener (this);
    }
    
    public void setModel (Models.CompoundModel model) {
        this.model = model;
        
        // 1) destroy old model
        if (currentTreeModelRoot != null) 

        columns = createColumns (model);
        treeTable.setProperties (columns);
        
        treeTable.setToolTipText ("tttttttttttttttttttttttt");
        setToolTipText ("aaaaaaaaaaaaaaaaaaaaa");
//        try {
//            treeTable.setToolTipText (model.getShortDescription (
//                model.getRoot ()

//        }
        
        // 5) set root node for given model
        currentTreeModelRoot = new TreeModelRoot (model, this);
        getExplorerManager ().setRootContext (
            currentTreeModelRoot.getRootNode ()
        );

        final List backupPath = new ArrayList(expandedPaths);
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                if (backupPath.size () == 0)
                    try {
                        expandDefault (
                            TreeTable.this.model.getChildren 
                            (TreeTable.this.model.getRoot (), 0, 0));
                    } catch (UnknownTypeException ex) {
                        
                    }
                else
                    treeTable.expandNodes (backupPath);
            }
        });
        if (ep.size () > 0) expandedPaths = ep;

        }
    }
    
    /**
      * Called whenever an item in the tree has been expanded.
      */
    public void treeExpanded (TreeExpansionEvent event) {
        TreeModelNode tmn = (TreeModelNode) Visualizer.findNode 
            (event.getPath ().getLastPathComponent ());
        model.nodeExpanded (tmn.getObject ());
    }

    /**
      * Called whenever an item in the tree has been collapsed.
      */
    public void treeCollapsed (TreeExpansionEvent event) {
        TreeModelNode tmn = (TreeModelNode) Visualizer.findNode 
            (event.getPath ().getLastPathComponent ());
        model.nodeCollapsed (tmn.getObject ());
    }
    
    private boolean equalNodes () {
        Node[] ns1 = TopComponent.getRegistry ().getCurrentNodes ();
        Node[] ns2 = getExplorerManager ().getSelectedNodes ();

        return true;
    }
    
    private Node.Property[] createColumns (Models.CompoundModel model) {
        ColumnModel[] cs = model.getColumns ();
        int i, k = cs.length;
        Node.Property[] columns = new Column [k];

        }
    }
    
    private void expandDefault (Object[] nodes) {
        int i, k = nodes.length;
        for (i = 0; i < k; i++)
            try {
                if (model.isExpanded (nodes [i]))
                    expandNode (nodes [i]);
            } catch (UnknownTypeException ex) {
            }
    }
    
    /** Requests focus for the tree component. Overrides superclass method. */
    public boolean requestFocusInWindow () {
        super.requestFocusInWindow ();

        TopComponent.getRegistry ().removePropertyChangeListener (this);
        getExplorerManager ().removePropertyChangeListener (this);
    }
    
    public boolean isExpanded (Object node) {
        Node n = currentTreeModelRoot.findNode (node);
        return treeTable.isExpanded (n);
    }

    public void expandNode (Object node) {
        Node n = currentTreeModelRoot.findNode (node);
        treeTable.expandNode (n);
    }

    public void collapseNode (Object node) {
        Node n = currentTreeModelRoot.findNode (node);
        treeTable.collapseNode (n);
    }
    
    private static class MyTreeTable extends TreeTableView {
        MyTreeTable () {

        
        JTable getTable () {
            return treeTable;
        }
        
        JTree getTree () {
            return tree;
        }

        public List getExpandedPaths () {

Lines 24-30 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/ColumnModel.java (-1 / +1 lines)
24	*	24	*
25	* @author Jan Jancura	25	* @author Jan Jancura
26	*/	26	*/
27	public abstract class ColumnModel {	27	public abstract class ColumnModel implements Model {
28		28
29		29
30	/**	30	/**




import javax.swing.JComponent;
import javax.swing.SwingUtilities;

import org.netbeans.modules.viewmodel.CompoundModel;
import org.netbeans.modules.viewmodel.TreeModelNode;
import org.netbeans.modules.viewmodel.TreeTable;


 */
public final class Models {

    /**
     * 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;

     * @return new instance of complete model
     */
    public static JComponent createView (
        CompoundModel compoundModel
        NodeModel nodeModel, 
        TableModel tableModel,
        NodeActionsProvider nodeActionsProvider,
        List columnModels
    ) {
        TreeTable tt = new TreeTable ();
        tt.setModel (compoundModel);
            CompoundModel cm = new CompoundModel (
                treeModel,
                nodeModel,
                nodeActionsProvider,
                columnModels,
                tableModel
            );
            tt.setModel (cm);
        }
        return tt;
    }
    

     */
    public static void setModelsToView (
        final JComponent view,
        final CompoundModel compoundModel
        NodeModel nodeModel, 
        TableModel tableModel,
        NodeActionsProvider nodeActionsProvider,
        List columnModels
    ) {
        if (verbose)
            System.out.println (compoundModel);
            if (treeModel instanceof CompoundTreeModel)
                System.out.println (((CompoundTreeModel) treeModel).toString ("    "));
            else
                System.out.println ("    " + treeModel);
            
            System.out.println ("  NodeModel:");
            if (nodeModel instanceof CompoundNodeModel)
                System.out.println (((CompoundNodeModel) nodeModel).toString ("    "));
            else
            if (nodeModel instanceof DelegatingNodeModel)
                System.out.println (((DelegatingNodeModel) nodeModel).toString ("    "));
            else
                System.out.println ("    " + nodeModel);
            
            System.out.println ("  NodeActionsProvider:");
            if (nodeActionsProvider instanceof CompoundNodeActionsProvider)
                System.out.println (((CompoundNodeActionsProvider) nodeActionsProvider).toString ("    "));
            else
            if (nodeActionsProvider instanceof DelegatingNodeActionsProvider)
                System.out.println (((DelegatingNodeActionsProvider) nodeActionsProvider).toString ("    "));
            else
                System.out.println ("    " + nodeActionsProvider);

            System.out.println ("  ColumnModels:");
            int i, k = columnModels.size ();
            for (i = 0; i < k; i++)
                System.out.println ("    " + columnModels.get (i));
            
            System.out.println ("  TableModel:");
            if (tableModel instanceof CompoundTableModel)
                System.out.println (((CompoundTableModel) tableModel).toString ("    "));
            else
            if (tableModel instanceof DelegatingTableModel)
                System.out.println (((DelegatingTableModel) tableModel).toString ("    "));
            else
                System.out.println ("    " + tableModel);
        }
        final CompoundModel cm = new CompoundModel (
            treeModel,
            nodeModel,
            nodeActionsProvider,
            columnModels,
            tableModel
        );
        SwingUtilities.invokeLater (new Runnable () {
            public void run () {
                ((TreeTable) view).setModel (compoundModel);
            }
        });
    }
    
    public static CompoundModel createCompoundModel (List models) {
        List treeModels =           new ArrayList ();
        List treeModelFilters =     new ArrayList ();
        List treeExpansionModels =  new ArrayList ();
        List nodeModels =           new ArrayList ();
        List nodeModelFilters =     new ArrayList ();
        List tableModels =          new ArrayList ();
        List tableModelFilters =    new ArrayList ();
        List nodeActionsProviders = new ArrayList ();
        List nodeActionsProviderFilters = new ArrayList ();
        List columnModels =         new ArrayList ();
        
        // 1) sort models
        Iterator it = models.iterator ();
        while (it.hasNext ()) {
            Object model = it.next ();
            if (model instanceof TreeModel)
                treeModels.add (model);
            if (model instanceof TreeModelFilter)
                treeModelFilters.add (model);
            if (model instanceof TreeExpansionModel)
                treeExpansionModels.add (model);
            if (model instanceof NodeModel)
                nodeModels.add (model);
            if (model instanceof NodeModelFilter)
                nodeModelFilters.add (model);
            if (model instanceof TableModel)
                tableModels.add (model);
            if (model instanceof TableModelFilter)
                tableModelFilters.add (model);
            if (model instanceof NodeActionsProvider)
                nodeActionsProviders.add (model);
            if (model instanceof NodeActionsProviderFilter)
                nodeActionsProviderFilters.add (model);
            if (model instanceof ColumnModel)
                columnModels.add (model);
        }
        
        if (treeModels.isEmpty ()) treeModels.add (new EmptyTreeModel ());
        
        return new CompoundModel (
            createCompoundTreeModel (
                new DelegatingTreeModel (treeModels),
                treeModelFilters
            ),
            new DelegatingTreeExpansionModel (treeExpansionModels),
            createCompoundNodeModel (
                new DelegatingNodeModel (nodeModels),
                nodeModelFilters
            ),
            createCompoundNodeActionsProvider (
                new DelegatingNodeActionsProvider (nodeActionsProviders),
                nodeActionsProviderFilters
            ),
            columnModels,
            createCompoundTableModel (
                new DelegatingTableModel (tableModels),
                tableModelFilters
            )
        );
    }
    
    /**
     * Returns {@link javax.swing.Action} for given parameters.
     *
     * @param displayName a display name for action
     * @param node a node the action should by applied to
     * @param performer a performer for action
     *
     * @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 TreeFeatures (view);
    }
    
    
    // private methods .........................................................
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.TreeModel} for given TreeModel and
     * {@link org.netbeans.spi.viewmodel.TreeModelFilter}.

     *
     * @returns compund tree model
     */
    private static TreeModel createCompoundTreeModel (
        TreeModel originalTreeModel,
        List treeModelFilters
    ) {

     *
     * @returns compund tree model
     */
    private static NodeModel createCompoundNodeModel (
        NodeModel originalNodeModel,
        List treeNodeModelFilters
    ) {

     *
     * @returns compund table model
     */
    private static TableModel createCompoundTableModel (
        TableModel originalTableModel,
        List tableModelFilters
    ) {

     *
     * @returns compund node actions provider
     */
    private static NodeActionsProvider createCompoundNodeActionsProvider (
        NodeActionsProvider originalNodeActionsProvider,
        List nodeActionsProviderFilters
    ) {

        return nap;
    }
    
//    /**
//     * Creates one {@link org.netbeans.spi.viewmodel.TableModel}
//     * from given array of TableModels. TableModel asks all underlaying 
//     * models for each concrete parameter, and returns first returned value.
//     *
//     * @param originalTableModels a array of original table models
//     */
//    public static TableModel createCompoundTableModel (
//        TableModel[] originalTableModels
//    ) {
//        return new DelegatingTableModel (
//            originalTableModels
//        );
//    }
    
    /**
     * Creates one {@link org.netbeans.spi.viewmodel.TableModel}
     * from given list of TableModels. TableModel asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @param originalTableModels a list of original table models
     */
    public static TableModel createCompoundTableModel (
        List originalTableModels
    ) {
        return new DelegatingTableModel (
            originalTableModels
        );
    }
    
//    /**
//     * Creates one {@link org.netbeans.spi.viewmodel.NodeModel}
//     * from given array of NodeModels. NodeModel asks all underlaying 
//     * models for each concrete parameter, and returns first returned value.
//     *
//     * @param originalNodeModels a array of original node models
//     */
//    public static NodeModel createCompoundNodeModel (
//        NodeModel[] originalNodeModels
//    ) {
//        return new DelegatingNodeModel (
//            originalNodeModels
//        );
//    }
    
    /**
     * Creates one {@link org.netbeans.spi.viewmodel.NodeModel}
     * from given list of NodeModels. NodeModel asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @param originalNodeModels a list of original node models
     */
    public static NodeModel createCompoundNodeModel (
        List originalNodeModels
    ) {
        return new DelegatingNodeModel (
            originalNodeModels
        );
    }
    
//    /**
//     * Creates one {@link org.netbeans.spi.viewmodel.NodeActionsProvider}
//     * from given array of NodeActionsProviders. NodeActionsProvider asks all underlaying 
//     * models for each concrete parameter, and returns first returned value.
//     *
//     * @param originalNodeActionsProviders a array of original node action providers
//     */
//    public static NodeActionsProvider createCompoundNodeActionsProvider (
//        NodeActionsProvider[] originalNodeActionsProviders
//    ) {
//        return new DelegatingNodeActionsProvider (
//            originalNodeActionsProviders
//        );
//    }
    
    /**
     * Creates one {@link org.netbeans.spi.viewmodel.NodeActionsProvider}
     * from given list of NodeActionsProviders. NodeActionsProvider asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @param originalNodeActionsProviders a list of original node action providers
     */
    public static NodeActionsProvider createCompoundNodeActionsProvider (
        List originalNodeActionsProviders
    ) {
        return new DelegatingNodeActionsProvider (
            originalNodeActionsProviders
        );
    }
    
    /**
     * Returns {@link javax.swing.Action} for given parameters.
     *
     * @param displayName a display name for action
     * @param node a node the action should by applied to
     * @param performer a performer for action
     *
     * @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
        );
    }
    
    
    // innerclasses ............................................................
    

                   n + "  " + model;
        }
    }

    /**
     * Creates one {@link org.netbeans.spi.viewmodel.TreeModel}
     * from given list of TreeModels. DelegatingTreeModel asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @author   Jan Jancura
     */
    final static class DelegatingTreeModel implements TreeModel {

        private TreeModel[] models;
        private HashMap classNameToModel = new HashMap ();


        /**
         * Creates new instance of DelegatingTreeModel for given list of 
         * TableModels.
         *
         * @param models a list of TableModels
         */
        DelegatingTreeModel (List models) {
            this (convert (models));
        }

        private static TreeModel[] convert (List l) {
            TreeModel[] models = new TreeModel [l.size ()];
            return (TreeModel[]) l.toArray (models);
        }

        /**
         * Creates new instance of DelegatingTreeModel for given array of 
         * TableModels.
         *
         * @param models a array of TreeModel
         */
        DelegatingTreeModel (TreeModel[] models) {
            this.models = models;        
        }
        
        /** 
         * Returns the root node of the tree or null, if the tree is empty.
         *
         * @return the root node of the tree or null
         */
        public Object getRoot () {
            return models [0].getRoot ();
        }

        /** 
         * Returns children for given parent on given indexes.
         *
         * @param   parent a parent of returned nodes
         * @param   from a start index
         * @param   to a end index
         *
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve children for given node type
         *
         * @return  children for given parent on given indexes
         */
        public Object[] getChildren (Object node, int from, int to)
        throws UnknownTypeException {
            TreeModel model = (TreeModel) classNameToModel.get (
                node.getClass ().getName ()
            );
            if (model != null) 
                try {
                    return model.getChildren (node, from, to);
                } catch (UnknownTypeException e) {
                }
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                try {
                    Object[] v = models [i].getChildren (node, from, to);
                    classNameToModel.put (node.getClass ().getName (), models [i]);
                    return v;
                } catch (UnknownTypeException e) {
                }
            }
            throw new UnknownTypeException (node);
        }    

        /**
         * Returns number of children for given node.
         * 
         * @param   node the parent node
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve children for given node type
         *
         * @return  true if node is leaf
         * @since 1.1
         */
        public int getChildrenCount (Object node) 
        throws UnknownTypeException {
            TreeModel model = (TreeModel) classNameToModel.get (
                node.getClass ().getName ()
            );
            if (model != null) 
                try {
                    return model.getChildrenCount (node);
                } catch (UnknownTypeException e) {
                }
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                try {
                    int result = models [i].getChildrenCount (node);
                    classNameToModel.put (node.getClass ().getName (), models [i]);
                    return result;
                } catch (UnknownTypeException e) {
                }
            }
            throw new UnknownTypeException (node);
        }    

        /**
         * Returns true if node is leaf.
         * 
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve dchildren for given node type
         * @return  true if node is leaf
         */
        public boolean isLeaf (Object node) throws UnknownTypeException {
            TreeModel model = (TreeModel) classNameToModel.get (
                node.getClass ().getName ()
            );
            if (model != null) 
                try {
                    return model.isLeaf (node);
                } catch (UnknownTypeException e) {
                }
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                try {
                    boolean result = models [i].isLeaf (node);
                    classNameToModel.put (node.getClass ().getName (), models [i]);
                    return result;
                } catch (UnknownTypeException e) {
                }
            }
            throw new UnknownTypeException (node);
        }    

        /** 
         * Registers given listener.
         * 
         * @param l the listener to add
         */
        public void addTreeModelListener (TreeModelListener l) {
            int i, k = models.length;
            for (i = 0; i < k; i++)
                models [i].addTreeModelListener (l);
        }

        /** 
         * Unregisters given listener.
         *
         * @param l the listener to remove
         */
        public void removeTreeModelListener (TreeModelListener l) {
            int i, k = models.length;
            for (i = 0; i < k; i++)
                models [i].removeTreeModelListener (l);
        }

        public String toString () {
            return super.toString () + "\n" + toString ("    ");
        }
        
        public String toString (String n) {
            int i, k = models.length - 1;
            if (k == -1) return "";
            StringBuffer sb = new StringBuffer ();
            for (i = 0; i < k; i++) {
                sb.append (n);
                sb.append (models [i]);
                sb.append ('\n');
            }
            sb.append (n);
            sb.append (models [i]);
            return new String (sb);
        }
    }
    
    /**
     * Creates {@link org.netbeans.spi.viewmodel.NodeActionsProvider} 

    }

    /**
     * Creates one {@link org.netbeans.spi.viewmodel.TableModel}
     * from given list of TableModels. DelegatingTableModel asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @author   Jan Jancura
     */
    final static class DelegatingTreeExpansionModel 
    implements TreeExpansionModel {

        private TreeExpansionModel[] models;
        private HashMap classNameToModel = new HashMap ();


        /**
         * Creates new instance of DelegatingTableModel for given list of 
         * TableModels.
         *
         * @param models a list of TableModels
         */
        DelegatingTreeExpansionModel (List models) {
            this (convert (models));
        }

        private static TreeExpansionModel[] convert (List l) {
            TreeExpansionModel[] models = new TreeExpansionModel [l.size ()];
            return (TreeExpansionModel[]) l.toArray (models);
        }

        /**
         * Creates new instance of DelegatingTableModel for given array of 
         * TableModels.
         *
         * @param models a array of TableModels
         */
        DelegatingTreeExpansionModel (TreeExpansionModel[] models) {
            this.models = models;        
        }

        /**
         * Defines default state (collapsed, expanded) of given node.
         *
         * @param node a node
         * @return default state (collapsed, expanded) of given node
         */
        public boolean isExpanded (Object node) 
        throws UnknownTypeException {
            TreeExpansionModel model = (TreeExpansionModel) 
                classNameToModel.get (
                    node.getClass ().getName ()
                );
            if (model != null) 
                try {
                    return model.isExpanded (node);
                } catch (UnknownTypeException e) {
                }
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                try {
                    boolean result = models [i].isExpanded (node);
                    classNameToModel.put (node.getClass ().getName (), models [i]);
                    return result;
                } catch (UnknownTypeException e) {
                }
            }
            throw new UnknownTypeException (node);
        }    


        /**
         * Called when given node is expanded.
         *
         * @param node a expanded node
         */
        public void nodeExpanded (Object node) {
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                models [i].nodeExpanded (node);
            }
        }    

        /**
         * Called when given node is collapsed.
         *
         * @param node a collapsed node
         */
        public void nodeCollapsed (Object node) {
            int i, k = models.length;
            for (i = 0; i < k; i++) {
                models [i].nodeCollapsed (node);
            }
        }    

        public String toString () {
            return super.toString () + "\n" + toString ("    ");
        }
        
        public String toString (String n) {
            int i, k = models.length - 1;
            if (k == -1) return "";
            StringBuffer sb = new StringBuffer ();
            for (i = 0; i < k; i++) {
                sb.append (n);
                sb.append (models [i]);
                sb.append ('\n');
            }
            sb.append (n);
            sb.append (models [i]);
            return new String (sb);
        }
    }

    /**
     * Creates one {@link org.netbeans.spi.viewmodel.NodeModel}
     * from given list of NodeModels. DelegatingNodeModel asks all underlaying 
     * models for each concrete parameter, and returns first returned value.
     *
     * @author   Jan Jancura
     */
    static final class DelegatingNodeModel implements NodeModel {

        private NodeModel[] models;
        private HashMap classNameToModel = new HashMap ();


        /**
         * Creates new instance of DelegatingNodeModel for given list of 
         * NodeModels.
         *
         * @param models a list of NodeModels

            int i, k = models.length;
            for (i = 0; i < k; i++)
                models [i].removeTreeModelListener (l);
        }
    }
    
    /**
     * Implements set of tree view features.
     */
    public static class TreeFeatures {
        
        private JComponent view;
        
        private TreeFeatures (JComponent view) {
            this.view = view;
        }
        
        /**
         * Returns <code>true</code> if given node is expanded in given view.
         *
         * @param view a view created by this Models class
         * @param node a node to be checked
         * @return <code>true</code> if given node is expanded in given view
         */
        public boolean isExpanded (
            Object node
        ) {
            return ((TreeTable) view).isExpanded (node);
        }

        /**
         * Expands given list of nodes in given view.
         *
         * @param view a view created by this Models class
         * @param node a list of nodes to be expanded
         */
        public void expandNode (
            Object node
        ) {
            ((TreeTable) view).expandNode (node);
        }

        /**
         * Collapses given node in given view.
         *
         * @param view a view created by this Models class
         * @param node a node to be expanded
         */
        public void collapseNode (
            Object node
        ) {
            ((TreeTable) view).collapseNode (node);
        }
    }

    /**
     * Default implemetation of {@link CompoundModel}. It delegates all 
     * functionality to given instanceo of 
     * {@link org.netbeans.spi.viewmodel.TreeModel},
     * {@link org.netbeans.spi.viewmodel.NodeModel} and
     * {@link org.netbeans.spi.viewmodel.NodeActionsProvider}.
     *
     * @author   Jan Jancura
     */
    public static final class CompoundModel implements TreeModel, 
    NodeModel, NodeActionsProvider, TableModel, TreeExpansionModel {

        private TreeModel       treeModel;
        private NodeModel       nodeModel;
        private NodeActionsProvider nodeActionsProvider;
        private ColumnModel[]   columnModels;
        private TableModel      tableModel;
        private TreeExpansionModel treeExpansionModel;


        // init ....................................................................

        /**
         * Creates a new instance of {@link CompoundModel} for given models.
         *
         * @param treeModel a tree model to delegate on
         * @param nodeModel a node model to delegate on
         * @param nodeActionsProvider a node actions provider to delegate on
         * @param nodeActionsProvider a columns modeol to delegate on
         */
        public CompoundModel (
            TreeModel treeModel, 
            TreeExpansionModel treeExpansionModel,
            NodeModel nodeModel, 
            NodeActionsProvider nodeActionsProvider,
            List columnModels,
            TableModel tableModel
        ) {
            if (treeModel == null) throw new NullPointerException ();
            if (treeModel == null) throw new NullPointerException ();
            if (nodeModel == null) throw new NullPointerException ();
            if (tableModel == null) throw new NullPointerException ();
            if (nodeActionsProvider == null) throw new NullPointerException ();

            this.treeModel = treeModel;
            this.treeExpansionModel = treeExpansionModel;
            this.nodeModel = nodeModel;
            this.tableModel = tableModel;
            this.nodeActionsProvider = nodeActionsProvider;
            this.columnModels = (ColumnModel[]) columnModels.toArray (
                new ColumnModel [columnModels.size ()]
            );
        }


        // TreeModel ...............................................................

        /** 
         * Returns the root node of the tree or null, if the tree is empty.
         *
         * @return the root node of the tree or null
         */
        public Object getRoot () {
            return treeModel.getRoot ();
        }

        /** 
         * Returns children for given parent on given indexes.
         *
         * @param   parent a parent of returned nodes
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve dchildren for given node type
         *
         * @return  children for given parent on given indexes
         */
        public Object[] getChildren (Object parent, int from, int to) 
        throws UnknownTypeException {
            return treeModel.getChildren (parent, from, to);
        }

        /**
         * Returns number of children for given node.
         * 
         * @param   node the parent node
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve children for given node type
         *
         * @return  true if node is leaf
         */
        public int getChildrenCount (Object node) throws UnknownTypeException {
            return treeModel.getChildrenCount (node);
        }

        /**
         * Returns true if node is leaf.
         * 
         * @throws  UnknownTypeException if this TreeModel implementation is not
         *          able to resolve dchildren for given node type
         * @return  true if node is leaf
         */
        public boolean isLeaf (Object node) throws UnknownTypeException {
            return treeModel.isLeaf (node);
        }


        // NodeModel ...............................................................

        /**
         * Returns display name for given node.
         *
         * @throws  UnknownTypeException if this NodeModel implementation is not
         *          able to resolve display name for given node type
         * @return  display name for given node
         */
        public String getDisplayName (Object node) throws UnknownTypeException {
            return nodeModel.getDisplayName (node);
        }

        /**
         * Returns tooltip for given node.
         *
         * @throws  UnknownTypeException if this NodeModel implementation is not
         *          able to resolve tooltip for given node type
         * @return  tooltip for given node
         */
        public String getShortDescription (Object node) 
        throws UnknownTypeException {
            return nodeModel.getShortDescription (node);
        }

        /**
         * Returns icon for given node.
         *
         * @throws  ComputingException if the icon resolving process 
         *          is time consuming, and the value will be updated later
         * @throws  UnknownTypeException if this NodeModel implementation is not
         *          able to resolve icon for given node type
         * @return  icon for given node
         */
        public String getIconBase (Object node) 
        throws UnknownTypeException {
            return nodeModel.getIconBase (node);
        }


        // NodeActionsProvider .....................................................

        /**
         * Performs default action for given node.
         *
         * @throws  UnknownTypeException if this NodeActionsProvider implementation 
         *          is not able to resolve actions for given node type
         * @return  display name for given node
         */
        public void performDefaultAction (Object node) throws UnknownTypeException {
            nodeActionsProvider.performDefaultAction (node);
        }

        /**
         * Returns set of actions for given node.
         *
         * @throws  UnknownTypeException if this NodeActionsProvider implementation 
         *          is not able to resolve actions for given node type
         * @return  display name for given node
         */
        public Action[] getActions (Object node) throws UnknownTypeException {
            return nodeActionsProvider.getActions (node);
        }


        // ColumnsModel ............................................................

        /**
         * Returns sorted array of 
         * {@link org.netbeans.spi.viewmodel.ColumnModel}s.
         *
         * @return sorted array of ColumnModels
         */
        public ColumnModel[] getColumns () {
            return columnModels;
        }


        // TableModel ..............................................................

        public Object getValueAt (Object node, String columnID) throws 
        UnknownTypeException {
            return tableModel.getValueAt (node, columnID);
        }

        public boolean isReadOnly (Object node, String columnID) throws 
        UnknownTypeException {
            return tableModel.isReadOnly (node, columnID);
        }

        public void setValueAt (Object node, String columnID, Object value) throws 
        UnknownTypeException {
            tableModel.setValueAt (node, columnID, value);
        }


        // TreeExpansionModel ......................................................

        /**
         * Defines default state (collapsed, expanded) of given node.
         *
         * @param node a node
         * @return default state (collapsed, expanded) of given node
         */
        public boolean isExpanded (Object node) throws UnknownTypeException {
            if (treeExpansionModel == null) return false;
            return treeExpansionModel.isExpanded (node);
        }

        /**
         * Called when given node is expanded.
         *
         * @param node a expanded node
         */
        public void nodeExpanded (Object node) {
            if (treeExpansionModel != null)
                treeExpansionModel.nodeExpanded (node);
        }

        /**
         * Called when given node is collapsed.
         *
         * @param node a collapsed node
         */
        public void nodeCollapsed (Object node) {
            if (treeExpansionModel != null)
                treeExpansionModel.nodeCollapsed (node);
        }


        // listeners ...............................................................

        /** 
         * Registers given listener.
         * 
         * @param l the listener to add
         */
        public void addTreeModelListener (TreeModelListener l) {
            treeModel.addTreeModelListener (l);
            nodeModel.addTreeModelListener (l);
            nodeActionsProvider.addTreeModelListener (l);
            tableModel.addTreeModelListener (l);
        }

        /** 
         * Unregisters given listener.
         *
         * @param l the listener to remove
         */
        public void removeTreeModelListener (TreeModelListener l) {
            treeModel.removeTreeModelListener (l);
            nodeModel.removeTreeModelListener (l);
            nodeActionsProvider.removeTreeModelListener (l);
            tableModel.removeTreeModelListener (l);
        }

        public String toString () {
            return super.toString () + 
                   "\n  TreeModel = " + treeModel +
                   "\n  NodeModel = " + nodeModel +
                   "\n  TableModel = " + tableModel +
                   "\n  NodeActionsProvider = " + nodeActionsProvider +
                   "\n  ColumnsModel = " + columnModels;
        }
    }
}

Lines 22-28 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/NodeActionsProvider.java (-1 / +1 lines)
22	*	22	*
23	* @author Jan Jancura	23	* @author Jan Jancura
24	*/	24	*/
25	public interface NodeActionsProvider {	25	public interface NodeActionsProvider extends Model {
26		26
27		27
28	/**	28	/**

Lines 23-29 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/NodeActionsProviderFilter.java (-1 / +1 lines)
23	*	23	*
24	* @author Jan Jancura	24	* @author Jan Jancura
25	*/	25	*/
26	public interface NodeActionsProviderFilter {	26	public interface NodeActionsProviderFilter extends Model {
27		27
28		28
29	/**	29	/**

Lines 20-26 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/NodeModel.java (-1 / +1 lines)
20	*	20	*
21	* @author Jan Jancura	21	* @author Jan Jancura
22	*/	22	*/
23	public interface NodeModel {	23	public interface NodeModel extends Model {
24		24
25	/**	25	/**
26	* Returns display name for given node.	26	* Returns display name for given node.

Lines 20-26 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/NodeModelFilter.java (-1 / +1 lines)
20	*	20	*
21	* @author Jan Jancura	21	* @author Jan Jancura
22	*/	22	*/
23	public interface NodeModelFilter {	23	public interface NodeModelFilter extends Model {
24		24
25	/**	25	/**
26	* Returns filterred display name for given node. You should not	26	* Returns filterred display name for given node. You should not

Lines 23-29 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/TableModel.java (-1 / +1 lines)
23	*	23	*
24	* @author Jan Jancura	24	* @author Jan Jancura
25	*/	25	*/
26	public interface TableModel {	26	public interface TableModel extends Model {
27		27
28		28
29	/**	29	/**

Lines 25-31 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/TableModelFilter.java (-1 / +1 lines)
25	*	25	*
26	* @author Jan Jancura	26	* @author Jan Jancura
27	*/	27	*/
28	public interface TableModelFilter {	28	public interface TableModelFilter extends Model {
29		29
30		30
31	/**	31	/**

Lines 20-26 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/TreeModel.java (-1 / +1 lines)
20	*	20	*
21	* @author Jan Jancura	21	* @author Jan Jancura
22	*/	22	*/
23	public interface TreeModel {	23	public interface TreeModel extends Model {
24		24
25	/**	25	/**
26	* Constant for root node. This root node should be used if root node	26	* Constant for root node. This root node should be used if root node

Lines 21-27 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/TreeModelFilter.java (-1 / +1 lines)
21	*	21	*
22	* @author Jan Jancura	22	* @author Jan Jancura
23	*/	23	*/
24	public interface TreeModelFilter {	24	public interface TreeModelFilter extends Model {
25		25
26		26
27	/**	27	/**

Lines 1-4 Link Here

(-)debuggerjpda/ui/src/META-INF/debugger/netbeans-JPDASession/WatchesView/org.netbeans.spi.viewmodel.NodeActionsProvider (-1 lines)
1	org.netbeans.modules.debugger.jpda.ui.models.WatchesActionsProvider	1	org.netbeans.modules.debugger.jpda.ui.models.WatchesActionsProvider
2	org.netbeans.modules.debugger.jpda.ui.FixedWatchesManager
3	org.netbeans.modules.debugger.jpda.ui.models.VariablesActionsProvider	2	org.netbeans.modules.debugger.jpda.ui.models.VariablesActionsProvider
4	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI	3	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI

Lines 1-3 Link Here

(-)debuggerjpda/ui/src/META-INF/debugger/netbeans-JPDASession/WatchesView/org.netbeans.spi.viewmodel.NodeModel (-1 lines)
1	org.netbeans.modules.debugger.jpda.ui.models.WatchesNodeModel	1	org.netbeans.modules.debugger.jpda.ui.models.WatchesNodeModel
2	org.netbeans.modules.debugger.jpda.ui.FixedWatchesManager
3	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI	2	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI

Line 1 Link Here

(-)debuggerjpda/ui/src/META-INF/debugger/netbeans-JPDASession/WatchesView/org.netbeans.spi.viewmodel.NodeModelFilter (+1 lines)
1	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilter	1	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilter
		2	org.netbeans.modules.debugger.jpda.ui.FixedWatchesManager

Lines 1-3 Link Here

(-)debuggerjpda/ui/src/META-INF/debugger/netbeans-JPDASession/WatchesView/org.netbeans.spi.viewmodel.TableModel (-2 / +1 lines)
1	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI	1	org.netbeans.modules.debugger.jpda.ui.models.VariablesTreeModelFilterSI
2	org.netbeans.modules.debugger.jpda.ui.models.VariablesTableModel	2	org.netbeans.modules.debugger.jpda.ui.models.VariablesTableModel
3	org.netbeans.modules.debugger.jpda.ui.FixedWatchesManager




import java.util.*;

/**
 * Manages lifecycle and presentation of fixed watches. Should be 
 * registered as an action provider in both
 * locals and watches views and as a tree model filter in the watches view.
 *
 * @author Jan Jancura, Maros Sandor
 */
public class FixedWatchesManager implements TreeModelFilter, 
NodeActionsProviderFilter, NodeModelFilter {
            
    public static final String FIXED_WATCH =
        "org/netbeans/modules/debugger/resources/watchesView/FixedWatch";
    private final Action DELETE_ACTION = Models.createAction (
        NbBundle.getBundle (FixedWatchesManager.class).getString 
            ("CTL_DeleteFixedWatch_Label"),
        new Models.ActionPerformer () {
            public boolean isEnabled (Object node) {
                return true;

        );
    };
    private final Action CREATE_FIXED_WATCH_ACTION = Models.createAction (
        NbBundle.getBundle (FixedWatchesManager.class).getString 
            ("CTL_CreateFixedWatch_Label"),
        new Models.ActionPerformer () {
            public boolean isEnabled (Object node) {
                return true;

    );
        
        
    private Map             fixedWatches = new HashMap ();
    private HashSet         listeners;
    private ContextProvider contextProvider;

    
    public FixedWatchesManager (ContextProvider contextProvider) {
        this.contextProvider = contextProvider;
    }

    private static String loc(String key) {
        return NbBundle.getBundle(FixedWatchesManager.class).getString(key);
    }
    
    // NodeActionsProvider .....................................................

    public void performDefaultAction (Object node) throws UnknownTypeException {
        if (!(node instanceof FixedWatch)) 
            throw new UnknownTypeException (node);
    }

    public Action[] getActions (Object node) throws UnknownTypeException {
        if (node instanceof FixedWatch) {
            return new Action[] {
                DELETE_ACTION
            };
        }
        throw new UnknownTypeException(node);
    }

    
    // NodeActionsProviderFilter ...............................................
    
    public void performDefaultAction (NodeActionsProvider original, Object node) 
    throws UnknownTypeException {
        original.performDefaultAction (node);
    }

    public Action[] getActions (NodeActionsProvider original, Object node) 
    throws UnknownTypeException {
        Action [] actions = original.getActions(node);
        List myActions = new ArrayList();
        if (node instanceof Variable) {
            myActions.add (CREATE_FIXED_WATCH_ACTION);
        } else if (node instanceof JPDAWatch) {
            myActions.add (CREATE_FIXED_WATCH_ACTION);
        } else if (node instanceof FixedWatch) {
            myActions.add (DELETE_ACTION);
        } else {
            return actions;
        }
        myActions.addAll(Arrays.asList(actions));
        return (Action[]) myActions.toArray(new Action[myActions.size()]);
    }
    

    // TreeModelFilter .........................................................

        int to
    ) throws UnknownTypeException {
        if (parent == TreeModel.ROOT) {
            if (fixedWatches.size () == 0) 
                () == 0) 
                return original.getChildren (parent, from, to);

            int fixedSize = fixedWatches.size ();
            int originalFrom = from - fixedSize;
            int originalTo = to - fixedSize;
            if (originalFrom < 0) originalFrom = 0;

            Object[] children;
            if (originalTo > originalFrom) {
                children = original.getChildren
                    (parent, originalFrom, originalTo);

            }
            Object [] allChildren = new Object [children.length + fixedSize];

            fixedWatches.keySet ().toArray (allChildren);
            System.arraycopy (
                children, 
                0, 

            System.arraycopy (allChildren, from, fallChildren, 0, to - from);
            return fallChildren;
        }
        if (parent instanceof FixedWatch) {
            Variable v = ((FixedWatch) parent).getVariable ();
            return (v != null) ? 
                original.getChildren (v, from, to) : 
                new Object [0];
        }
        return original.getChildren (parent, from, to);
    }


    ) throws UnknownTypeException {
        if (parent == TreeModel.ROOT) {
            int chc = original.getChildrenCount (parent);
            if (fixedWatches == null) return chc;
            return chc + fixedWatches.size ();
        }
        if (parent instanceof FixedWatch) {
            Variable v = ((FixedWatch) parent).getVariable ();
            return (v != null) ? original.getChildrenCount (v) : 0;
        }
        return original.getChildrenCount (parent);
    }

    public boolean isLeaf (TreeModel original, Object node) 
    throws UnknownTypeException {
        if (node instanceof FixedWatch) {
            FixedWatch fw = (FixedWatch) node;
            if (fw.getVariable () == null) 
                return true;
            return original.isLeaf (fw.getVariable ());
        }
        return original.isLeaf (node);
    }


        newListeners.remove (l);
        listeners = newListeners;
    }

    
    // NodeActionsProviderFilter ...............................................

    public void performDefaultAction (
        NodeActionsProvider original, 
        Object node
    ) throws UnknownTypeException {
        original.performDefaultAction (node);
                ((FixedWatch) row).getVariable (),
                columnID
            );
        throw new UnknownTypeException (row);
    }
    
    public boolean isReadOnly (Object row, String columnID) throws 
    UnknownTypeException {
        if (row instanceof FixedWatch)
            return getOriginalModel ().isReadOnly (
                ((FixedWatch) row).getVariable (),
                columnID
            );
        throw new UnknownTypeException (row);
    }

    public Action[] getActions (NodeActionsProvider original, Object node) 
    throws UnknownTypeException {
        Action [] actions = original.getActions (node);
        List myActions = new ArrayList();
        if (fixedWatches.containsKey (node)) {
            return new Action[] {
                DELETE_ACTION
            };
            return;
        }
        if (node instanceof Variable) {
            myActions.add (CREATE_FIXED_WATCH_ACTION);
        } else 
        if (node instanceof JPDAWatch) {
            myActions.add (CREATE_FIXED_WATCH_ACTION);
        } else 
            return actions;
        myActions.addAll (Arrays.asList (actions));
        return (Action[]) myActions.toArray (new Action [myActions.size ()]);
    }
    
    
    // NodeModel ...............................................................
    
    public String getDisplayName (NodeModel original, Object node) 
    throws UnknownTypeException {
        if (fixedWatches.containsKey (node))
            return (String) fixedWatches.get (node);
        return original.getDisplayName (node);
    }
    
    public String getShortDescription (NodeModel original, Object node) 
    throws UnknownTypeException {
        if (fixedWatches.containsKey (node)) {
            Variable v = (Variable) node;
            return ((String) fixedWatches.get (node)) + 
                " = (" + v.getType () + ") " + 
                v.getValue ();
        }
        return original.getShortDescription (node);
    }
    
    public String getIconBase (NodeModel original, Object node) 
    throws UnknownTypeException {
        if (fixedWatches.containsKey (node))
            return FIXED_WATCH;
        return original.getIconBase (node);
    }
    
    

    private void createFixedWatch (Object node) {
        if (node instanceof JPDAWatch) {
            JPDAWatch jw = (JPDAWatch) node;
            addFixedWatch (jw.getExpression (), jw);
        } else {
            Variable variable = (Variable) node;
            String name = null;

            } else {
                name = "unnamed";
            }
            addFixedWatch (name, variable);
        }
    }

    private void addFixedWatch (String name, Variable variable) {
        fixedWatches.put (variable, name);
        fireModelChanged ();
        fixedWatches.add(fw);
        fireModelChanged();
    }

    private void fireModelChanged () {

            TreeModelListener listener = (TreeModelListener) i.next();
            listener.treeChanged();;
        }
    }
    
    private TableModel original;
    private TableModel getOriginalModel () {
        if (original == null)
            original = Models.createCompoundTableModel (
                Models.createCompoundTableModel (
                    contextProvider.lookup ("WatchesView", TableModel.class)
                ),
                contextProvider.lookup ("WatchesView", TableModelFilter.class)
            );
        return original;
    }
}

Lines 58-65 Link Here

(-)debuggerjpda/ui/src/org/netbeans/modules/debugger/jpda/ui/models/VariablesTableModel.java (-2 lines)
58	if ( columnID.equals (LOCALS_TYPE_COLUMN_ID) \|\|	58	if ( columnID.equals (LOCALS_TYPE_COLUMN_ID) \|\|
59	columnID.equals (WATCH_TYPE_COLUMN_ID)	59	columnID.equals (WATCH_TYPE_COLUMN_ID)
60	) {	60	) {
61	if (row instanceof JPDAWatch)
62	Thread.dumpStack();
63	if (row instanceof Variable)	61	if (row instanceof Variable)
64	return getShort (((Variable) row).getType ());	62	return getShort (((Variable) row).getType ());
65	} else	63	} else

Lines 44-51 Link Here

(-)debuggerjpda/ui/src/org/netbeans/modules/debugger/jpda/ui/views/ClassesView.java (-2 / +1 lines)
44	return;	44	return;
45	if (tree == null) {	45	if (tree == null) {
46	setLayout (new BorderLayout ());	46	setLayout (new BorderLayout ());
47	tree = Models.createView	47	tree = Models.createView (Models.EMPTY_MODEL);
48	(null, null, null, null, new ArrayList ());
49	tree.setName ("ClassesView");	48	tree.setName ("ClassesView");
50	add (tree, "Center"); //NOI18N	49	add (tree, "Center"); //NOI18N
51	}	50	}

Lines 41-48 Link Here

(-)debuggerjpda/ui/src/org/netbeans/modules/debugger/jpda/ui/views/SourcesView.java (-2 / +1 lines)
41	return;	41	return;
42	if (tree == null) {	42	if (tree == null) {
43	setLayout (new BorderLayout ());	43	setLayout (new BorderLayout ());
44	tree = Models.createView	44	tree = Models.createView (Models.EMPTY_MODEL);
45	(null, null, null, null, new ArrayList ());
46	tree.setName ("SourcesView");	45	tree.setName ("SourcesView");
47	add (tree, "Center"); //NOI18N	46	add (tree, "Center"); //NOI18N
48	}	47	}




import org.netbeans.api.debugger.DebuggerEngine;
import org.netbeans.api.debugger.DebuggerManager;
import org.netbeans.api.debugger.DebuggerManagerAdapter;
import org.netbeans.spi.viewmodel.Model;
import org.netbeans.spi.viewmodel.Models;
import org.netbeans.spi.viewmodel.ColumnModel;
import org.netbeans.spi.viewmodel.TableModelFilter;

import org.netbeans.spi.viewmodel.NodeModel;
import org.netbeans.spi.viewmodel.NodeModelFilter;
import org.netbeans.spi.viewmodel.TableModel;
import org.netbeans.spi.viewmodel.TreeExpansionModel;
import org.netbeans.spi.viewmodel.TreeModel;
import org.netbeans.spi.viewmodel.TreeModelFilter;
import org.netbeans.spi.viewmodel.TreeModelListener;

            DebuggerManager.PROP_CURRENT_ENGINE,
            this
        );
        Models.setModelsToView (view, Models.EMPTY_MODEL);
            view, null, null, null, null, Collections.EMPTY_LIST
        );
    }

    public void propertyChange (PropertyChangeEvent e) {

    }
    
    private void updateModel () {
        DebuggerManager dm = DebuggerManager.getDebuggerManager ();
        DebuggerEngine e = dm.getCurrentEngine ();
        ArrayList l = new ArrayList ();
        if (e != null) {
            l.addAll (e.lookup (viewType, TreeModel.class));
            l.addAll (e.lookup (viewType, TreeModelFilter.class));
            l.addAll (e.lookup (viewType, TreeExpansionModel.class));
            l.addAll (e.lookup (viewType, NodeModel.class));
            l.addAll (e.lookup (viewType, NodeModelFilter.class));
            l.addAll (e.lookup (viewType, TableModel.class));
            l.addAll (e.lookup (viewType, TableModelFilter.class));
            l.addAll (e.lookup (viewType, NodeActionsProvider.class));
            l.addAll (e.lookup (viewType, NodeActionsProviderFilter.class));
            l.addAll (e.lookup (viewType, ColumnModel.class));
            l.addAll (e.lookup (viewType, Model.class));
        }
        l.addAll (dm.lookup (viewType, TreeModel.class));
        l.addAll (dm.lookup (viewType, TreeModelFilter.class));
        l.addAll (dm.lookup (viewType, TreeExpansionModel.class));
        l.addAll (dm.lookup (viewType, NodeModel.class));
        l.addAll (dm.lookup (viewType, NodeModelFilter.class));
        l.addAll (dm.lookup (viewType, TableModel.class));
        l.addAll (dm.lookup (viewType, TableModelFilter.class));
        l.addAll (dm.lookup (viewType, NodeActionsProvider.class));
        l.addAll (dm.lookup (viewType, NodeActionsProviderFilter.class));
        l.addAll (dm.lookup (viewType, ColumnModel.class));
        l.addAll (dm.lookup (viewType, Model.class));
        
        Models.setModelsToView (view, Models.createCompoundModel (l));
            view, 
            Models.createCompoundTreeModel (
                tm, 
                loadModels (TreeModelFilter.class)
            ),
            Models.createCompoundNodeModel (
                Models.createCompoundNodeModel (
                    l
                ),
                loadModels (NodeModelFilter.class)
            ),
            Models.createCompoundTableModel (
                Models.createCompoundTableModel (
                    loadModels (TableModel.class)
                ),
                loadModels (TableModelFilter.class)
            ),
            Models.createCompoundNodeActionsProvider (
                Models.createCompoundNodeActionsProvider (
                    loadModels (NodeActionsProvider.class)
                ),
                loadModels (NodeActionsProviderFilter.class)
            ),
            loadModels (ColumnModel.class)
        );
                    
    }
    
    private Object loadModel (Class modelType) {
        DebuggerEngine e = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        Object m = null;
        if (e != null)
            m = e.lookupFirst (viewType, modelType);
        if (m == null)
            m = DebuggerManager.getDebuggerManager ().
                lookupFirst (viewType, modelType);
        return m;
    }

    private List loadModels (Class modelType) {
        DebuggerEngine e = DebuggerManager.getDebuggerManager ().
            getCurrentEngine ();
        List l = new ArrayList ();
        if (e != null)
            l.addAll (e.lookup (viewType, modelType));
        l.addAll (DebuggerManager.getDebuggerManager ().
            lookup (viewType, modelType));
        return l;
    }

    

Return to bug 46167

Lines 27-32 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/views/ViewModelListener.java (-64 / +30 lines)
27	import org.netbeans.api.debugger.DebuggerEngine;	27	import org.netbeans.api.debugger.DebuggerEngine;
28	import org.netbeans.api.debugger.DebuggerManager;	28	import org.netbeans.api.debugger.DebuggerManager;
29	import org.netbeans.api.debugger.DebuggerManagerAdapter;	29	import org.netbeans.api.debugger.DebuggerManagerAdapter;
		30	import org.netbeans.spi.viewmodel.Model;
30	import org.netbeans.spi.viewmodel.Models;	31	import org.netbeans.spi.viewmodel.Models;
31	import org.netbeans.spi.viewmodel.ColumnModel;	32	import org.netbeans.spi.viewmodel.ColumnModel;
32	import org.netbeans.spi.viewmodel.TableModelFilter;	33	import org.netbeans.spi.viewmodel.TableModelFilter;
Lines 35-40 Link Here
35	import org.netbeans.spi.viewmodel.NodeModel;	36	import org.netbeans.spi.viewmodel.NodeModel;
36	import org.netbeans.spi.viewmodel.NodeModelFilter;	37	import org.netbeans.spi.viewmodel.NodeModelFilter;
37	import org.netbeans.spi.viewmodel.TableModel;	38	import org.netbeans.spi.viewmodel.TableModel;
		39	import org.netbeans.spi.viewmodel.TreeExpansionModel;
38	import org.netbeans.spi.viewmodel.TreeModel;	40	import org.netbeans.spi.viewmodel.TreeModel;
39	import org.netbeans.spi.viewmodel.TreeModelFilter;	41	import org.netbeans.spi.viewmodel.TreeModelFilter;
40	import org.netbeans.spi.viewmodel.TreeModelListener;	42	import org.netbeans.spi.viewmodel.TreeModelListener;
Lines 76-86 Link Here
76	);	78	);
77	Models.setModelsToView (	79	Models.setModelsToView (
78	view,	80	view,
79	Models.EMPTY_TREE_MODEL,	81	Models.EMPTY_MODEL
80	Models.EMPTY_NODE_MODEL,
81	Models.EMPTY_TABLE_MODEL,
82	Models.EMPTY_NODE_ACTIONS_PROVIDER,
83	Collections.EMPTY_LIST
84	);	82	);
85	}	83	}
86		84
Lines 89-155 Link Here
89	}	87	}
90		88
91	private void updateModel () {	89	private void updateModel () {
92	TreeModel tm = (TreeModel) loadModel (TreeModel.class);	90	DebuggerManager dm = DebuggerManager.getDebuggerManager ();
93	if (tm == null)	91	DebuggerEngine e = dm.getCurrentEngine ();
94	tm = Models.EMPTY_TREE_MODEL;	92	ArrayList l = new ArrayList ();
95	List l = loadModels (NodeModel.class);	93	if (e != null) {
96	l.add (new EmptyModel ());	94	l.addAll (e.lookup (viewType, TreeModel.class));
97		95	l.addAll (e.lookup (viewType, TreeModelFilter.class));
98	if (verbose) {	96	l.addAll (e.lookup (viewType, TreeExpansionModel.class));
99	System.out.println ("");	97	l.addAll (e.lookup (viewType, NodeModel.class));
100	System.out.println (viewType + " models:");	98	l.addAll (e.lookup (viewType, NodeModelFilter.class));
		99	l.addAll (e.lookup (viewType, TableModel.class));
		100	l.addAll (e.lookup (viewType, TableModelFilter.class));
		101	l.addAll (e.lookup (viewType, NodeActionsProvider.class));
		102	l.addAll (e.lookup (viewType, NodeActionsProviderFilter.class));
		103	l.addAll (e.lookup (viewType, ColumnModel.class));
		104	l.addAll (e.lookup (viewType, Model.class));
101	}	105	}
		106	l.addAll (dm.lookup (viewType, TreeModel.class));
		107	l.addAll (dm.lookup (viewType, TreeModelFilter.class));
		108	l.addAll (dm.lookup (viewType, TreeExpansionModel.class));
		109	l.addAll (dm.lookup (viewType, NodeModel.class));
		110	l.addAll (dm.lookup (viewType, NodeModelFilter.class));
		111	l.addAll (dm.lookup (viewType, TableModel.class));
		112	l.addAll (dm.lookup (viewType, TableModelFilter.class));
		113	l.addAll (dm.lookup (viewType, NodeActionsProvider.class));
		114	l.addAll (dm.lookup (viewType, NodeActionsProviderFilter.class));
		115	l.addAll (dm.lookup (viewType, ColumnModel.class));
		116	l.addAll (dm.lookup (viewType, Model.class));
102		117
103	Models.setModelsToView (	118	Models.setModelsToView (view, Models.createCompoundModel (l));
104	view,
105	Models.createCompoundTreeModel (
106	tm,
107	loadModels (TreeModelFilter.class)
108	),
109	Models.createCompoundNodeModel (
110	Models.createCompoundNodeModel (
111	l
112	),
113	loadModels (NodeModelFilter.class)
114	),
115	Models.createCompoundTableModel (
116	Models.createCompoundTableModel (
117	loadModels (TableModel.class)
118	),
119	loadModels (TableModelFilter.class)
120	),
121	Models.createCompoundNodeActionsProvider (
122	Models.createCompoundNodeActionsProvider (
123	loadModels (NodeActionsProvider.class)
124	),
125	loadModels (NodeActionsProviderFilter.class)
126	),
127	loadModels (ColumnModel.class)
128	);
129
130	}
131
132	private Object loadModel (Class modelType) {
133	DebuggerEngine e = DebuggerManager.getDebuggerManager ().
134	getCurrentEngine ();
135	Object m = null;
136	if (e != null)
137	m = e.lookupFirst (viewType, modelType);
138	if (m == null)
139	m = DebuggerManager.getDebuggerManager ().
140	lookupFirst (viewType, modelType);
141	return m;
142	}
143
144	private List loadModels (Class modelType) {
145	DebuggerEngine e = DebuggerManager.getDebuggerManager ().
146	getCurrentEngine ();
147	List l = new ArrayList ();
148	if (e != null)
149	l.addAll (e.lookup (viewType, modelType));
150	l.addAll (DebuggerManager.getDebuggerManager ().
151	lookup (viewType, modelType));
152	return l;
153	}	119	}
154		120
155		121

Lines 23-28 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/modules/viewmodel/TreeTable.java (-6 / +68 lines)
23	import javax.swing.JPanel;	23	import javax.swing.JPanel;
24	import javax.swing.JScrollPane;	24	import javax.swing.JScrollPane;
25	import javax.swing.JTable;	25	import javax.swing.JTable;
		26	import javax.swing.JTree;
26	import javax.swing.SwingUtilities;	27	import javax.swing.SwingUtilities;
27	import javax.swing.event.TreeExpansionListener;	28	import javax.swing.event.TreeExpansionListener;
28	import javax.swing.event.TreeExpansionEvent;	29	import javax.swing.event.TreeExpansionEvent;
Lines 35-40 Link Here
35		36
36	import org.netbeans.spi.viewmodel.Models;	37	import org.netbeans.spi.viewmodel.Models;
37	import org.netbeans.spi.viewmodel.ColumnModel;	38	import org.netbeans.spi.viewmodel.ColumnModel;
		39	import org.netbeans.spi.viewmodel.UnknownTypeException;
38	import org.openide.explorer.ExplorerActions;	40	import org.openide.explorer.ExplorerActions;
39		41
40	import org.openide.explorer.ExplorerManager;	42	import org.openide.explorer.ExplorerManager;
Lines 61-73 Link Here
61	* @author Jan Jancura	63	* @author Jan Jancura
62	*/	64	*/
63	public class TreeTable extends JPanel implements	65	public class TreeTable extends JPanel implements
64	ExplorerManager.Provider, PropertyChangeListener {	66	ExplorerManager.Provider, PropertyChangeListener, TreeExpansionListener {
65		67
66	private ExplorerManager explorerManager;	68	private ExplorerManager explorerManager;
67	private MyTreeTable treeTable;	69	private MyTreeTable treeTable;
68	private Node.Property[] columns;	70	private Node.Property[] columns;
69	private List expandedPaths = new ArrayList ();	71	private List expandedPaths = new ArrayList ();
70	private TreeModelRoot currentTreeModelRoot;	72	private TreeModelRoot currentTreeModelRoot;
		73	private Models.CompoundModel model;
		74
71		75
72	private ExplorerActions explorerActions = new ExplorerActions ();	76	private ExplorerActions explorerActions = new ExplorerActions ();
73	{explorerActions.setConfirmDelete (false);}	77	{explorerActions.setConfirmDelete (false);}
Lines 83-91 Link Here
83	treeTable.setHorizontalScrollBarPolicy	87	treeTable.setHorizontalScrollBarPolicy
84	(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);	88	(JScrollPane.HORIZONTAL_SCROLLBAR_AS_NEEDED);
85	add (treeTable, "Center"); //NOI18N	89	add (treeTable, "Center"); //NOI18N
		90	treeTable.getTree ().addTreeExpansionListener (this);
86	}	91	}
87		92
88	public void setModel (CompoundModel model) {	93	public void setModel (Models.CompoundModel model) {
		94	this.model = model;
89		95
90	// 1) destroy old model	96	// 1) destroy old model
91	if (currentTreeModelRoot != null)	97	if (currentTreeModelRoot != null)
Lines 107-113 Link Here
107	columns = createColumns (model);	113	columns = createColumns (model);
108	treeTable.setProperties (columns);	114	treeTable.setProperties (columns);
109		115
110		116	treeTable.setToolTipText ("tttttttttttttttttttttttt");
		117	setToolTipText ("aaaaaaaaaaaaaaaaaaaaa");
111	// try {	118	// try {
112	// treeTable.setToolTipText (model.getShortDescription (	119	// treeTable.setToolTipText (model.getShortDescription (
113	// model.getRoot ()	120	// model.getRoot ()
Lines 118-124 Link Here
118	// }	125	// }
119		126
120	// 5) set root node for given model	127	// 5) set root node for given model
121	currentTreeModelRoot = new TreeModelRoot (model);	128	currentTreeModelRoot = new TreeModelRoot (model, this);
122	getExplorerManager ().setRootContext (	129	getExplorerManager ().setRootContext (
123	currentTreeModelRoot.getRootNode ()	130	currentTreeModelRoot.getRootNode ()
124	);	131	);
Lines 130-136 Link Here
130	final List backupPath = new ArrayList(expandedPaths);	137	final List backupPath = new ArrayList(expandedPaths);
131	SwingUtilities.invokeLater(new Runnable() {	138	SwingUtilities.invokeLater(new Runnable() {
132	public void run() {	139	public void run() {
133	treeTable.expandNodes (backupPath);	140	if (backupPath.size () == 0)
		141	try {
		142	expandDefault (
		143	TreeTable.this.model.getChildren
		144	(TreeTable.this.model.getRoot (), 0, 0));
		145	} catch (UnknownTypeException ex) {
		146
		147	}
		148	else
		149	treeTable.expandNodes (backupPath);
134	}	150	}
135	});	151	});
136	if (ep.size () > 0) expandedPaths = ep;	152	if (ep.size () > 0) expandedPaths = ep;
Lines 159-164 Link Here
159	}	175	}
160	}	176	}
161		177
		178	/**
		179	* Called whenever an item in the tree has been expanded.
		180	*/
		181	public void treeExpanded (TreeExpansionEvent event) {
		182	TreeModelNode tmn = (TreeModelNode) Visualizer.findNode
		183	(event.getPath ().getLastPathComponent ());
		184	model.nodeExpanded (tmn.getObject ());
		185	}
		186
		187	/**
		188	* Called whenever an item in the tree has been collapsed.
		189	*/
		190	public void treeCollapsed (TreeExpansionEvent event) {
		191	TreeModelNode tmn = (TreeModelNode) Visualizer.findNode
		192	(event.getPath ().getLastPathComponent ());
		193	model.nodeCollapsed (tmn.getObject ());
		194	}
		195
162	private boolean equalNodes () {	196	private boolean equalNodes () {
163	Node[] ns1 = TopComponent.getRegistry ().getCurrentNodes ();	197	Node[] ns1 = TopComponent.getRegistry ().getCurrentNodes ();
164	Node[] ns2 = getExplorerManager ().getSelectedNodes ();	198	Node[] ns2 = getExplorerManager ().getSelectedNodes ();
Lines 171-177 Link Here
171	return true;	205	return true;
172	}	206	}
173		207
174	private Node.Property[] createColumns (CompoundModel model) {	208	private Node.Property[] createColumns (Models.CompoundModel model) {
175	ColumnModel[] cs = model.getColumns ();	209	ColumnModel[] cs = model.getColumns ();
176	int i, k = cs.length;	210	int i, k = cs.length;
177	Node.Property[] columns = new Column [k];	211	Node.Property[] columns = new Column [k];
Lines 240-245 Link Here
240	}	274	}
241	}	275	}
242		276
		277	private void expandDefault (Object[] nodes) {
		278	int i, k = nodes.length;
		279	for (i = 0; i < k; i++)
		280	try {
		281	if (model.isExpanded (nodes [i]))
		282	expandNode (nodes [i]);
		283	} catch (UnknownTypeException ex) {
		284	}
		285	}
		286
243	/** Requests focus for the tree component. Overrides superclass method. */	287	/** Requests focus for the tree component. Overrides superclass method. */
244	public boolean requestFocusInWindow () {	288	public boolean requestFocusInWindow () {
245	super.requestFocusInWindow ();	289	super.requestFocusInWindow ();
Lines 257-263 Link Here
257	TopComponent.getRegistry ().removePropertyChangeListener (this);	301	TopComponent.getRegistry ().removePropertyChangeListener (this);
258	getExplorerManager ().removePropertyChangeListener (this);	302	getExplorerManager ().removePropertyChangeListener (this);
259	}	303	}
		304
		305	public boolean isExpanded (Object node) {
		306	Node n = currentTreeModelRoot.findNode (node);
		307	return treeTable.isExpanded (n);
		308	}
		309
		310	public void expandNode (Object node) {
		311	Node n = currentTreeModelRoot.findNode (node);
		312	treeTable.expandNode (n);
		313	}
260		314
		315	public void collapseNode (Object node) {
		316	Node n = currentTreeModelRoot.findNode (node);
		317	treeTable.collapseNode (n);
		318	}
261		319
262	private static class MyTreeTable extends TreeTableView {	320	private static class MyTreeTable extends TreeTableView {
263	MyTreeTable () {	321	MyTreeTable () {
Lines 268-273 Link Here
268		326
269	JTable getTable () {	327	JTable getTable () {
270	return treeTable;	328	return treeTable;
		329	}
		330
		331	JTree getTree () {
		332	return tree;
271	}	333	}
272		334
273	public List getExpandedPaths () {	335	public List getExpandedPaths () {

Lines 22-27 Link Here

(-)debuggerjpda/ui/src/org/netbeans/modules/debugger/jpda/ui/views/ViewModelListener.java (-62 / +30 lines)
22	import org.netbeans.api.debugger.DebuggerEngine;	22	import org.netbeans.api.debugger.DebuggerEngine;
23	import org.netbeans.api.debugger.DebuggerManager;	23	import org.netbeans.api.debugger.DebuggerManager;
24	import org.netbeans.api.debugger.DebuggerManagerAdapter;	24	import org.netbeans.api.debugger.DebuggerManagerAdapter;
		25	import org.netbeans.spi.viewmodel.Model;
25	import org.netbeans.spi.viewmodel.Models;	26	import org.netbeans.spi.viewmodel.Models;
26	import org.netbeans.spi.viewmodel.ColumnModel;	27	import org.netbeans.spi.viewmodel.ColumnModel;
27	import org.netbeans.spi.viewmodel.TableModelFilter;	28	import org.netbeans.spi.viewmodel.TableModelFilter;
Lines 30-35 Link Here
30	import org.netbeans.spi.viewmodel.NodeModel;	31	import org.netbeans.spi.viewmodel.NodeModel;
31	import org.netbeans.spi.viewmodel.NodeModelFilter;	32	import org.netbeans.spi.viewmodel.NodeModelFilter;
32	import org.netbeans.spi.viewmodel.TableModel;	33	import org.netbeans.spi.viewmodel.TableModel;
		34	import org.netbeans.spi.viewmodel.TreeExpansionModel;
33	import org.netbeans.spi.viewmodel.TreeModel;	35	import org.netbeans.spi.viewmodel.TreeModel;
34	import org.netbeans.spi.viewmodel.TreeModelFilter;	36	import org.netbeans.spi.viewmodel.TreeModelFilter;
35	import org.netbeans.spi.viewmodel.TreeModelListener;	37	import org.netbeans.spi.viewmodel.TreeModelListener;
Lines 69-77 Link Here
69	DebuggerManager.PROP_CURRENT_ENGINE,	71	DebuggerManager.PROP_CURRENT_ENGINE,
70	this	72	this
71	);	73	);
72	Models.setModelsToView (	74	Models.setModelsToView (view, Models.EMPTY_MODEL);
73	view, null, null, null, null, Collections.EMPTY_LIST
74	);
75	}	75	}
76		76
77	public void propertyChange (PropertyChangeEvent e) {	77	public void propertyChange (PropertyChangeEvent e) {
Lines 79-145 Link Here
79	}	79	}
80		80
81	private void updateModel () {	81	private void updateModel () {
82	TreeModel tm = (TreeModel) loadModel (TreeModel.class);	82	DebuggerManager dm = DebuggerManager.getDebuggerManager ();
83	if (tm == null)	83	DebuggerEngine e = dm.getCurrentEngine ();
84	tm = Models.EMPTY_TREE_MODEL;	84	ArrayList l = new ArrayList ();
85	List l = loadModels (NodeModel.class);	85	if (e != null) {
86	l.add (new EmptyModel ());	86	l.addAll (e.lookup (viewType, TreeModel.class));
87		87	l.addAll (e.lookup (viewType, TreeModelFilter.class));
88	if (verbose) {	88	l.addAll (e.lookup (viewType, TreeExpansionModel.class));
89	System.out.println ("");	89	l.addAll (e.lookup (viewType, NodeModel.class));
90	System.out.println (viewType + " models:");	90	l.addAll (e.lookup (viewType, NodeModelFilter.class));
		91	l.addAll (e.lookup (viewType, TableModel.class));
		92	l.addAll (e.lookup (viewType, TableModelFilter.class));
		93	l.addAll (e.lookup (viewType, NodeActionsProvider.class));
		94	l.addAll (e.lookup (viewType, NodeActionsProviderFilter.class));
		95	l.addAll (e.lookup (viewType, ColumnModel.class));
		96	l.addAll (e.lookup (viewType, Model.class));
91	}	97	}
		98	l.addAll (dm.lookup (viewType, TreeModel.class));
		99	l.addAll (dm.lookup (viewType, TreeModelFilter.class));
		100	l.addAll (dm.lookup (viewType, TreeExpansionModel.class));
		101	l.addAll (dm.lookup (viewType, NodeModel.class));
		102	l.addAll (dm.lookup (viewType, NodeModelFilter.class));
		103	l.addAll (dm.lookup (viewType, TableModel.class));
		104	l.addAll (dm.lookup (viewType, TableModelFilter.class));
		105	l.addAll (dm.lookup (viewType, NodeActionsProvider.class));
		106	l.addAll (dm.lookup (viewType, NodeActionsProviderFilter.class));
		107	l.addAll (dm.lookup (viewType, ColumnModel.class));
		108	l.addAll (dm.lookup (viewType, Model.class));
92		109
93	Models.setModelsToView (	110	Models.setModelsToView (view, Models.createCompoundModel (l));
94	view,
95	Models.createCompoundTreeModel (
96	tm,
97	loadModels (TreeModelFilter.class)
98	),
99	Models.createCompoundNodeModel (
100	Models.createCompoundNodeModel (
101	l
102	),
103	loadModels (NodeModelFilter.class)
104	),
105	Models.createCompoundTableModel (
106	Models.createCompoundTableModel (
107	loadModels (TableModel.class)
108	),
109	loadModels (TableModelFilter.class)
110	),
111	Models.createCompoundNodeActionsProvider (
112	Models.createCompoundNodeActionsProvider (
113	loadModels (NodeActionsProvider.class)
114	),
115	loadModels (NodeActionsProviderFilter.class)
116	),
117	loadModels (ColumnModel.class)
118	);
119
120	}
121
122	private Object loadModel (Class modelType) {
123	DebuggerEngine e = DebuggerManager.getDebuggerManager ().
124	getCurrentEngine ();
125	Object m = null;
126	if (e != null)
127	m = e.lookupFirst (viewType, modelType);
128	if (m == null)
129	m = DebuggerManager.getDebuggerManager ().
130	lookupFirst (viewType, modelType);
131	return m;
132	}
133
134	private List loadModels (Class modelType) {
135	DebuggerEngine e = DebuggerManager.getDebuggerManager ().
136	getCurrentEngine ();
137	List l = new ArrayList ();
138	if (e != null)
139	l.addAll (e.lookup (viewType, modelType));
140	l.addAll (DebuggerManager.getDebuggerManager ().
141	lookup (viewType, modelType));
142	return l;
143	}	111	}
144		112
145		113

Lines 36-47 Link Here

(-)debuggercore/src/org/netbeans/modules/debugger/ui/models/SessionsTableModel.java (-6 / +6 lines)
36		36
37		37
38	public SessionsTableModel () {	38	public SessionsTableModel () {
39	Session session = DebuggerManager.getDebuggerManager ().	39	// Session session = DebuggerManager.getDebuggerManager ().
40	getCurrentSession ();	40	// getCurrentSession ();
41	session.addPropertyChangeListener (	41	// session.addPropertyChangeListener (
42	Session.PROP_CURRENT_LANGUAGE,	42	// Session.PROP_CURRENT_LANGUAGE,
43	this	43	// this
44	);	44	// );
45	}	45	}
46		46
47	public Object getValueAt (Object row, String columnID) throws	47	public Object getValueAt (Object row, String columnID) throws

Lines 18-23 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/modules/viewmodel/TreeModelNode.java (-48 / +24 lines)
18	import java.beans.PropertyEditor;	18	import java.beans.PropertyEditor;
19	import java.lang.IllegalAccessException;	19	import java.lang.IllegalAccessException;
20	import java.lang.ref.WeakReference;	20	import java.lang.ref.WeakReference;
		21	import java.util.Arrays;
21	import java.util.Collections;	22	import java.util.Collections;
22	import java.util.HashMap;	23	import java.util.HashMap;
23	import java.util.Map;	24	import java.util.Map;
Lines 25-32 Link Here
25	import javax.swing.AbstractAction;	26	import javax.swing.AbstractAction;
26	import javax.swing.Action;	27	import javax.swing.Action;
27	import javax.swing.KeyStroke;	28	import javax.swing.KeyStroke;
		29	import javax.swing.SwingUtilities;
28		30
29	import org.netbeans.spi.viewmodel.ColumnModel;	31	import org.netbeans.spi.viewmodel.ColumnModel;
		32	import org.netbeans.spi.viewmodel.Models;
30	import org.netbeans.spi.viewmodel.UnknownTypeException;	33	import org.netbeans.spi.viewmodel.UnknownTypeException;
31		34
32	import org.openide.nodes.AbstractNode;	35	import org.openide.nodes.AbstractNode;
Lines 47-53 Link Here
47		50
48	// variables ...............................................................	51	// variables ...............................................................
49		52
50	private CompoundModel model;	53	private Models.CompoundModel model;
51	private TreeModelRoot treeModelRoot;	54	private TreeModelRoot treeModelRoot;
52	private Object object;	55	private Object object;
53		56
Lines 63-71 Link Here
63	* Creates root of call stack for given producer.	66	* Creates root of call stack for given producer.
64	*/	67	*/
65	public TreeModelNode (	68	public TreeModelNode (
66	CompoundModel model,	69	final Models.CompoundModel model,
67	TreeModelRoot treeModelRoot,	70	final TreeModelRoot treeModelRoot,
68	Object object	71	final Object object
69	) {	72	) {
70	super (	73	super (
71	createChildren (model, treeModelRoot, object),	74	createChildren (model, treeModelRoot, object),
Lines 94-100 Link Here
94	}	97	}
95		98
96	private static Children createChildren (	99	private static Children createChildren (
97	CompoundModel model,	100	Models.CompoundModel model,
98	TreeModelRoot treeModelRoot,	101	TreeModelRoot treeModelRoot,
99	Object object	102	Object object
100	) {	103	) {
Lines 114-159 Link Here
114	}	117	}
115	}	118	}
116		119
117	// public String getName () {
118	// try {
119	// if (name == null) {
120	// name = model.getDisplayName (object);
121	// if (name == null)
122	// throw new NullPointerException (
123	// "Model: " + model + ".getDisplayName (" + object +
124	// ") = null!"
125	// );
126	// }
127	// return name;
128	// } catch (UnknownTypeException e) {
129	// e.printStackTrace ();
130	// System.out.println (model);
131	// System.out.println ();
132	// return object.toString ();
133	// } catch (final ComputingException ex) {
134	// name = "";
135	// RequestProcessor.getDefault ().post (new Runnable () {
136	// public void run () {
137	// name = (String) ex.getValue ();
138	// if (name == null) {
139	// name = "?";
140	// throw new NullPointerException (
141	// "Model: " + model + ".getDisplayName (" + object +
142	// ") = null!"
143	// );
144	// }
145	// setName (name);
146	// setDisplayName (name);
147	// }
148	// });
149	// return "";
150	// }
151	// }
152	//
153	// public String getDisplayName () {
154	// return getName ();
155	// }
156
157	public String getShortDescription () {	120	public String getShortDescription () {
158	if (shortDescription == null) {	121	if (shortDescription == null) {
159	RequestProcessor.getDefault ().post (new Runnable () {	122	RequestProcessor.getDefault ().post (new Runnable () {
Lines 312-325 Link Here
312	private static final class TreeModelChildren extends Children.Keys {	275	private static final class TreeModelChildren extends Children.Keys {
313		276
314	private boolean initialezed = false;	277	private boolean initialezed = false;
315	private CompoundModel model;	278	private Models.CompoundModel model;
316	private TreeModelRoot treeModelRoot;	279	private TreeModelRoot treeModelRoot;
317	private Object object;	280	private Object object;
318	private WeakHashMap objectToNode = new WeakHashMap ();	281	private WeakHashMap objectToNode = new WeakHashMap ();
319		282
320		283
321	TreeModelChildren (	284	TreeModelChildren (
322	CompoundModel model,	285	Models.CompoundModel model,
323	TreeModelRoot treeModelRoot,	286	TreeModelRoot treeModelRoot,
324	Object object	287	Object object
325	) {	288	) {
Lines 352-357 Link Here
352	System.out.println ();	315	System.out.println ();
353	}	316	}
354	setKeys (new Object [0]);	317	setKeys (new Object [0]);
		318	return;
355	}	319	}
356	}	320	}
357	});	321	});
Lines 359-365 Link Here
359		323
360	void refreshChildren (int count) {	324	void refreshChildren (int count) {
361	try {	325	try {
362	Object[] ch = model.getChildren (	326	final Object[] ch = model.getChildren (
363	object,	327	object,
364	0,	328	0,
365	count	329	count
Lines 382-387 Link Here
382	}	346	}
383	objectToNode = newObjectToNode;	347	objectToNode = newObjectToNode;
384	setKeys (ch);	348	setKeys (ch);
		349
		350	SwingUtilities.invokeLater (new Runnable () {
		351	public void run () {
		352	int i, k = ch.length;
		353	for (i = 0; i < k; i++)
		354	try {
		355	if (model.isExpanded (ch [i]))
		356	treeModelRoot.getTreeTable ().expandNode (ch [i]);
		357	} catch (UnknownTypeException ex) {
		358	}
		359	}
		360	});
385	} catch (UnknownTypeException e) {	361	} catch (UnknownTypeException e) {
386	setKeys (new Object [0]);	362	setKeys (new Object [0]);
387	if (!(object instanceof String)) {	363	if (!(object instanceof String)) {

Lines 18-23 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/modules/viewmodel/TreeModelRoot.java (-3 / +10 lines)
18	import java.util.Iterator;	18	import java.util.Iterator;
19	import java.util.WeakHashMap;	19	import java.util.WeakHashMap;
20	import javax.swing.SwingUtilities;	20	import javax.swing.SwingUtilities;
		21	import org.netbeans.spi.viewmodel.Models;
21		22
22	import org.netbeans.spi.viewmodel.TreeModel;	23	import org.netbeans.spi.viewmodel.TreeModel;
23	import org.netbeans.spi.viewmodel.TreeModelListener;	24	import org.netbeans.spi.viewmodel.TreeModelListener;
Lines 38-52 Link Here
38		39
39	// variables ...............................................................	40	// variables ...............................................................
40		41
41	private CompoundModel model;	42	private Models.CompoundModel model;
42	private TreeModelNode rootNode;	43	private TreeModelNode rootNode;
43	private WeakHashMap objectToNode = new WeakHashMap ();	44	private WeakHashMap objectToNode = new WeakHashMap ();
		45	private TreeTable treeTable;
44		46
45		47
46	public TreeModelRoot (CompoundModel model) {	48	public TreeModelRoot (Models.CompoundModel model, TreeTable treeTable) {
47	this.model = model;	49	this.model = model;
		50	this.treeTable = treeTable;
48	model.addTreeModelListener (this);	51	model.addTreeModelListener (this);
49	}	52	}
		53
		54	public TreeTable getTreeTable () {
		55	return treeTable;
		56	}
50		57
51	public TreeModelNode getRootNode () {	58	public TreeModelNode getRootNode () {
52	if (rootNode == null)	59	if (rootNode == null)
Lines 58-64 Link Here
58	objectToNode.put (o, new WeakReference (n));	65	objectToNode.put (o, new WeakReference (n));
59	}	66	}
60		67
61	private TreeModelNode findNode (Object o) {	68	TreeModelNode findNode (Object o) {
62	WeakReference wr = (WeakReference) objectToNode.get (o);	69	WeakReference wr = (WeakReference) objectToNode.get (o);
63	if (wr == null) return null;	70	if (wr == null) return null;
64	return (TreeModelNode) wr.get ();	71	return (TreeModelNode) wr.get ();

Lines 26-43 Link Here

(-)debuggerjpda/ui/src/org/netbeans/modules/debugger/jpda/ui/FixedWatchesManager.java (-136 / +60 lines)
26	import java.util.*;	26	import java.util.*;
27		27
28	/**	28	/**
29	* Manages lifecycle and presentation of fixed watches. Should be registered as an action provider in both	29	* Manages lifecycle and presentation of fixed watches. Should be
		30	* registered as an action provider in both
30	* locals and watches views and as a tree model filter in the watches view.	31	* locals and watches views and as a tree model filter in the watches view.
31	*	32	*
32	* @author Jan Jancura, Maros Sandor	33	* @author Jan Jancura, Maros Sandor
33	*/	34	*/
34	public class FixedWatchesManager implements TreeModelFilter,	35	public class FixedWatchesManager implements TreeModelFilter,
35	NodeActionsProvider, NodeActionsProviderFilter, TableModel, NodeModel {	36	NodeActionsProviderFilter, NodeModelFilter {
36		37
37	public static final String FIXED_WATCH =	38	public static final String FIXED_WATCH =
38	"org/netbeans/modules/debugger/resources/watchesView/FixedWatch";	39	"org/netbeans/modules/debugger/resources/watchesView/FixedWatch";
39	private final Action DELETE_ACTION = Models.createAction (	40	private final Action DELETE_ACTION = Models.createAction (
40	loc("CTL_DeleteFixedWatch_Label"),	41	NbBundle.getBundle (FixedWatchesManager.class).getString
		42	("CTL_DeleteFixedWatch_Label"),
41	new Models.ActionPerformer () {	43	new Models.ActionPerformer () {
42	public boolean isEnabled (Object node) {	44	public boolean isEnabled (Object node) {
43	return true;	45	return true;
Lines 58-64 Link Here
58	);	60	);
59	};	61	};
60	private final Action CREATE_FIXED_WATCH_ACTION = Models.createAction (	62	private final Action CREATE_FIXED_WATCH_ACTION = Models.createAction (
61	loc("CTL_CreateFixedWatch_Label"),	63	NbBundle.getBundle (FixedWatchesManager.class).getString
		64	("CTL_CreateFixedWatch_Label"),
62	new Models.ActionPerformer () {	65	new Models.ActionPerformer () {
63	public boolean isEnabled (Object node) {	66	public boolean isEnabled (Object node) {
64	return true;	67	return true;
Lines 73-131 Link Here
73	);	76	);
74		77
75		78
76	private List fixedWatches;	79	private Map fixedWatches = new HashMap ();
77	private HashSet listeners;	80	private HashSet listeners;
78	private ContextProvider contextProvider; // not used at the moment	81	private ContextProvider contextProvider;
79		82
80		83
81	public FixedWatchesManager (ContextProvider contextProvider) {	84	public FixedWatchesManager (ContextProvider contextProvider) {
82	this.contextProvider = contextProvider;	85	this.contextProvider = contextProvider;
83	}	86	}
84
85	private static String loc(String key) {
86	return NbBundle.getBundle(FixedWatchesManager.class).getString(key);
87	}
88
89	// NodeActionsProvider .....................................................
90
91	public void performDefaultAction (Object node) throws UnknownTypeException {
92	if (!(node instanceof FixedWatch))
93	throw new UnknownTypeException (node);
94	}
95
96	public Action[] getActions (Object node) throws UnknownTypeException {
97	if (node instanceof FixedWatch) {
98	return new Action[] {
99	DELETE_ACTION
100	};
101	}
102	throw new UnknownTypeException(node);
103	}
104
105
106	// NodeActionsProviderFilter ...............................................
107
108	public void performDefaultAction (NodeActionsProvider original, Object node)
109	throws UnknownTypeException {
110	original.performDefaultAction (node);
111	}
112
113	public Action[] getActions (NodeActionsProvider original, Object node)
114	throws UnknownTypeException {
115	Action [] actions = original.getActions(node);
116	List myActions = new ArrayList();
117	if (node instanceof Variable) {
118	myActions.add (CREATE_FIXED_WATCH_ACTION);
119	} else if (node instanceof JPDAWatch) {
120	myActions.add (CREATE_FIXED_WATCH_ACTION);
121	} else if (node instanceof FixedWatch) {
122	myActions.add (DELETE_ACTION);
123	} else {
124	return actions;
125	}
126	myActions.addAll(Arrays.asList(actions));
127	return (Action[]) myActions.toArray(new Action[myActions.size()]);
128	}
129		87
130		88
131	// TreeModelFilter .........................................................	89	// TreeModelFilter .........................................................
Lines 141-156 Link Here
141	int to	99	int to
142	) throws UnknownTypeException {	100	) throws UnknownTypeException {
143	if (parent == TreeModel.ROOT) {	101	if (parent == TreeModel.ROOT) {
144	if (fixedWatches == null \|\| fixedWatches.size	102	if (fixedWatches.size () == 0)
145	() == 0)
146	return original.getChildren (parent, from, to);	103	return original.getChildren (parent, from, to);
147		104
148	int fixedSize = fixedWatches.size();	105	int fixedSize = fixedWatches.size ();
149	int originalFrom = from - fixedSize;	106	int originalFrom = from - fixedSize;
150	int originalTo = to - fixedSize;	107	int originalTo = to - fixedSize;
151	if (originalFrom < 0) originalFrom = 0;	108	if (originalFrom < 0) originalFrom = 0;
152		109
153	Object [] children;	110	Object[] children;
154	if (originalTo > originalFrom) {	111	if (originalTo > originalFrom) {
155	children = original.getChildren	112	children = original.getChildren
156	(parent, originalFrom, originalTo);	113	(parent, originalFrom, originalTo);
Lines 159-165 Link Here
159	}	116	}
160	Object [] allChildren = new Object [children.length + fixedSize];	117	Object [] allChildren = new Object [children.length + fixedSize];
161		118
162	fixedWatches.toArray (allChildren);	119	fixedWatches.keySet ().toArray (allChildren);
163	System.arraycopy (	120	System.arraycopy (
164	children,	121	children,
165	0,	122	0,
Lines 171-182 Link Here
171	System.arraycopy (allChildren, from, fallChildren, 0, to - from);	128	System.arraycopy (allChildren, from, fallChildren, 0, to - from);
172	return fallChildren;	129	return fallChildren;
173	}	130	}
174	if (parent instanceof FixedWatch) {
175	Variable v = ((FixedWatch) parent).getVariable ();
176	return (v != null) ?
177	original.getChildren (v, from, to) :
178	new Object [0];
179	}
180	return original.getChildren (parent, from, to);	131	return original.getChildren (parent, from, to);
181	}	132	}
182		133
Lines 186-209 Link Here
186	) throws UnknownTypeException {	137	) throws UnknownTypeException {
187	if (parent == TreeModel.ROOT) {	138	if (parent == TreeModel.ROOT) {
188	int chc = original.getChildrenCount (parent);	139	int chc = original.getChildrenCount (parent);
189	if (fixedWatches == null) return chc;
190	return chc + fixedWatches.size ();	140	return chc + fixedWatches.size ();
191	}	141	}
192	if (parent instanceof FixedWatch) {
193	Variable v = ((FixedWatch) parent).getVariable ();
194	return (v != null) ? original.getChildrenCount (v) : 0;
195	}
196	return original.getChildrenCount (parent);	142	return original.getChildrenCount (parent);
197	}	143	}
198		144
199	public boolean isLeaf (TreeModel original, Object node)	145	public boolean isLeaf (TreeModel original, Object node)
200	throws UnknownTypeException {	146	throws UnknownTypeException {
201	if (node instanceof FixedWatch) {
202	FixedWatch fw = (FixedWatch) node;
203	if (fw.getVariable () == null)
204	return true;
205	return original.isLeaf (fw.getVariable ());
206	}
207	return original.isLeaf (node);	147	return original.isLeaf (node);
208	}	148	}
209		149
Lines 220-284 Link Here
220	newListeners.remove (l);	160	newListeners.remove (l);
221	listeners = newListeners;	161	listeners = newListeners;
222	}	162	}
		163
223		164
224		165	// NodeActionsProviderFilter ...............................................
225	// TableModel ..............................................................	166
226		167	public void performDefaultAction (
227	public Object getValueAt (Object row, String columnID) throws	168	NodeActionsProvider original,
228	UnknownTypeException {	169	Object node
229	if (row instanceof FixedWatch)	170	) throws UnknownTypeException {
230	return getOriginalModel ().getValueAt (	171	original.performDefaultAction (node);
231	((FixedWatch) row).getVariable (),
232	columnID
233	);
234	throw new UnknownTypeException (row);
235	}
236
237	public boolean isReadOnly (Object row, String columnID) throws
238	UnknownTypeException {
239	if (row instanceof FixedWatch)
240	return getOriginalModel ().isReadOnly (
241	((FixedWatch) row).getVariable (),
242	columnID
243	);
244	throw new UnknownTypeException (row);
245	}	172	}
246		173
247	public void setValueAt (Object row, String columnID, Object value)	174	public Action[] getActions (NodeActionsProvider original, Object node)
248	throws UnknownTypeException {	175	throws UnknownTypeException {
249	if (row instanceof FixedWatch) {	176	Action [] actions = original.getActions (node);
250	getOriginalModel ().setValueAt (	177	List myActions = new ArrayList();
251	((FixedWatch) row).getVariable (),	178	if (fixedWatches.containsKey (node)) {
252	columnID,	179	return new Action[] {
253	value	180	DELETE_ACTION
254	);	181	};
255	return;
256	}	182	}
257	throw new UnknownTypeException (row);	183	if (node instanceof Variable) {
		184	myActions.add (CREATE_FIXED_WATCH_ACTION);
		185	} else
		186	if (node instanceof JPDAWatch) {
		187	myActions.add (CREATE_FIXED_WATCH_ACTION);
		188	} else
		189	return actions;
		190	myActions.addAll (Arrays.asList (actions));
		191	return (Action[]) myActions.toArray (new Action [myActions.size ()]);
258	}	192	}
259		193
260		194
261	// NodeModel ...............................................................	195	// NodeModel ...............................................................
262		196
263	public String getDisplayName (Object o) throws UnknownTypeException {	197	public String getDisplayName (NodeModel original, Object node)
264	if (o instanceof FixedWatch)	198	throws UnknownTypeException {
265	return ((FixedWatch) o).getName();	199	if (fixedWatches.containsKey (node))
266	throw new UnknownTypeException (o);	200	return (String) fixedWatches.get (node);
		201	return original.getDisplayName (node);
267	}	202	}
268		203
269	public String getShortDescription (Object o) throws UnknownTypeException {	204	public String getShortDescription (NodeModel original, Object node)
270	if (o instanceof FixedWatch) {	205	throws UnknownTypeException {
271	FixedWatch fw = (FixedWatch) o;	206	if (fixedWatches.containsKey (node)) {
272	return fw.getName () + " = (" + fw.getType () + ") " +	207	Variable v = (Variable) node;
273	fw.getValue ();	208	return ((String) fixedWatches.get (node)) +
		209	" = (" + v.getType () + ") " +
		210	v.getValue ();
274	}	211	}
275	throw new UnknownTypeException (o);	212	return original.getShortDescription (node);
276	}	213	}
277		214
278	public String getIconBase (Object node) throws UnknownTypeException {	215	public String getIconBase (NodeModel original, Object node)
279	if (node instanceof FixedWatch)	216	throws UnknownTypeException {
		217	if (fixedWatches.containsKey (node))
280	return FIXED_WATCH;	218	return FIXED_WATCH;
281	throw new UnknownTypeException (node);	219	return original.getIconBase (node);
282	}	220	}
283		221
284		222
Lines 287-293 Link Here
287	private void createFixedWatch (Object node) {	225	private void createFixedWatch (Object node) {
288	if (node instanceof JPDAWatch) {	226	if (node instanceof JPDAWatch) {
289	JPDAWatch jw = (JPDAWatch) node;	227	JPDAWatch jw = (JPDAWatch) node;
290	createFixedWatch (jw.getExpression (), jw);	228	addFixedWatch (jw.getExpression (), jw);
291	} else {	229	} else {
292	Variable variable = (Variable) node;	230	Variable variable = (Variable) node;
293	String name = null;	231	String name = null;
Lines 302-316 Link Here
302	} else {	240	} else {
303	name = "unnamed";	241	name = "unnamed";
304	}	242	}
305	createFixedWatch(name, variable);	243	addFixedWatch (name, variable);
306	}	244	}
307	}	245	}
308		246
309	private void createFixedWatch (String name, Variable variable) {	247	private void addFixedWatch (String name, Variable variable) {
310	if (fixedWatches == null) fixedWatches = new ArrayList();	248	fixedWatches.put (variable, name);
311	FixedWatch fw = new FixedWatch(name, variable);	249	fireModelChanged ();
312	fixedWatches.add(fw);
313	fireModelChanged();
314	}	250	}
315		251
316	private void fireModelChanged () {	252	private void fireModelChanged () {
Lines 319-335 Link Here
319	TreeModelListener listener = (TreeModelListener) i.next();	255	TreeModelListener listener = (TreeModelListener) i.next();
320	listener.treeChanged();;	256	listener.treeChanged();;
321	}	257	}
322	}
323
324	private TableModel original;
325	private TableModel getOriginalModel () {
326	if (original == null)
327	original = Models.createCompoundTableModel (
328	Models.createCompoundTableModel (
329	contextProvider.lookup ("WatchesView", TableModel.class)
330	),
331	contextProvider.lookup ("WatchesView", TableModelFilter.class)
332	);
333	return original;
334	}	258	}
335	}	259	}