Attachment #19740 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	}




        <class package="org.netbeans.spi.viewmodel" name="NoInformationException" />
        <issue number="53073"/>
    </change>
    <change>
        <api name="ViewModelAPI"/>
        <summary>Access to tree node expansion added.</summary>
        <date day="13" month="1" year="2005"/>
        <author login="jjancura"/>
        <compatibility binary="incompatible" source="incompatible" deletion="yes" addition="yes" modification="yes"/>
        <description>
                This change has been done to cover user requirement #46167.
                List of changes:
                    1) new TreeExpansionModel introduced
                    2) new class Models.TreeFeatures contains tree expansion methods.
                During implementation of this user requirement I have discovered important problem in ViewModel API. 
                There is no possibility to add a new model to it. List of changes fixing this problem:
                    1) Models.createView (...) and Models.setModelsToView (...) methods do not use fixed set of models as parameters,
                       but they use Models.CompoundModel.
                    2) Models.CompoundModel is final class implementing all currently supported models. The only way how to create
                       a new instance of it is Models.createCompoundModel (List listOfModels). It allows future additions of new
                       models.
                    3) Methods Models.createCompoundTreeModel (...), Models.createCompoundNodeModel (...), 
                       Models.createCompoundTableModel (...), Models.createCompoundNodeActionsProvider (...), and field
                       Models.EMPTY_TREE_MODEL has been removed as useless.
                How to update your code using these exceptions:
                    No changes required for most of clients. You should change your code only if you are providing some 
                    new view based on ViewModel. In this case you should put all your model instances to one list, 
                    and call Models.createCompountModel (list), in place of calling create*Model* methods.
        </description>
        <class package="org.netbeans.spi.viewmodel" name="Models" />
        <class package="org.netbeans.spi.viewmodel" name="Models.CompoundModel" />
        <class package="org.netbeans.spi.viewmodel" name="Models.TreeFeatures" />
        <class package="org.netbeans.spi.viewmodel" name="TreeExpansionModel" />
        <issue number="46167"/>
    </change>

</changes>





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 () {

                        name = (String) object;
                        setName (name);
                        setDisplayName (name);
//                        setIconBase ("org/openide/resources/actions/empty");
                    } else {
                        e.printStackTrace ();
                        System.out.println (model);

    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);
            }
        });
    }
    
    /**
     * Creates one {@link CompoundModel} from given list of models.
     * 
     * @param models a list of models
     * @return {@link CompoundModel} encapsulating given list of models
     */
    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

            int i, k = models.length;
            for (i = 0; i < k; i++)
                models [i].removeTreeModelListener (l);
        }
    }
    
    /**
     * Implements set of tree view features.
     */
    public static final 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);
        }
    }

    /**
     * This model encapsulates all currently supported models.
     *
     * @see Models#createCompoundModel
     * @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
         */
        private 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	/**




 content="text/html; charset=iso-8859-1">
  <meta name="GENERATOR"
 content="Mozilla/4.76 [en] (Windows NT 5.0; U) [Netscape]">
  <title>View Model API</title>
<!--
  --                 Sun Public License Notice
  -- 

  -- Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
  -- Microsystems, Inc. All Rights Reserved.
  -->
  <meta content="Jan Jancura" name="author">
</head>
<body style="color: rgb(0, 0, 0);" link="#0000ee" alink="#0000ee"
 vlink="#551a8b">

 alt="Tree Model Example 1" style="width: 401px; height: 355px;"
 align="right"><br>    public Object getRoot () {<br>        return ROOT;<br>    }<br>    <br>    public Object[] getChildren (Object parent, int from, int to) {<br>        if (parent == ROOT)<br>            return File.listRoots ();<br>        return ((File) parent).listFiles ();<br>    }<br>    <br>    public boolean isLeaf (Object node) {<br>        if (node == ROOT)<br>            return false;<br>        return ((File) node).isFile ();<br>    }<br>}<br></pre>
And create a TreeView for this model:
<pre style="background-color: rgb(255, 255, 102);">    JComponent treeView = Models.createView (<br>        Models.createCompoundModel (<br>	    Arrays.asList (new Model[] {<br>                new TreeModelImpl (),      // TreeModel<br>                new ArrayList ()           // list of ColumnModel s<br>            })<br>        )<br>    );</pre>
See <a href="../../../../examples/TreeModelExample1.java">TreeModelExample1</a>.<br>
<h3>Step 2.</h3>
NodeModel implementation can define name, icon and tooltip for tree

<pre style="background-color: rgb(255, 255, 102);">public class NodeActionsProviderImpl implements NodeActionsProvider {<br><br>    public Action[] getActions (final Object node) {<br>        return new Action [] {<br>            new AbstractAction ("Open") {<br>                public void actionPerformed (ActionEvent e) {<br>                    performDefaultAction (node);<br>                }<br>            },<br>            new AbstractAction ("Delete") {<br>                public void actionPerformed (ActionEvent e) {<br>                    ((File) node).delete ();<br>                }<br>            }<br>        };<br>    }<br>    <br>    public void performDefaultAction (Object node) {<br>        try {<br>            JFrame f = new JFrame ("View");<br>            f.getContentPane ().add (new JEditorPane (((File) node).toURL ()));<br>            f.pack ();<br>            f.show ();<br>        } catch (Exception e) {<br>            e.printStackTrace();<br>        }<br>    }<br>}</pre>
See <a href="../../../../examples/TreeModelExample3.java">TreeModelExample3</a>.<br>
<br>
<div style="text-align: center;"><img
 src="../../../../examples/TreeModelExample3.JPG" title=""
 alt="Tree Model Example 3" style="width: 642px; height: 438px;"><br>
</div>
<h3>Step 4.</h3>
TableModel and ColumnModel adds support for additional columns to tree
view.<br>

<pre style="background-color: rgb(255, 255, 102);">    ArrayList columns = new ArrayList ();<img
 src="../../../../examples/TreeModelExample4.JPG" title=""
 alt="Tree Model Example 4" style="width: 384px; height: 278px;"
 align="right"><br>    columns.add (new ColumnModel () {<br>        public String getID () { return "sizeID"; }<br>        public String getDisplayName () { return "size"; }<br>        public Class getType () { return String.class; }<br>    });<br>    JComponent treeTableView = Models.createView (<br>        Models.createCompoundModel (<br>            Arrays.asList (new Model[] {<br>                new TreeModelImpl (),           // TreeModel<br>                new NodeModelImpl (),           // NodeModel<br>                new TableModelImpl (),          // TableModel<br>                new NodeActionsProviderImpl (), // NodeActionsProvider<br>                columns                         // list of ColumnModel s<br>            })<br>        )<br>    );<br><br></pre>
See <a href="../../../../examples/TreeModelExample4.java">TreeModelExample4</a>.<br>
<br>
<br>

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 103-108 Link Here

(-)debuggercore/viewmodel/apichanges.xml (+32 lines)
103	<class package="org.netbeans.spi.viewmodel" name="NoInformationException" />	103	<class package="org.netbeans.spi.viewmodel" name="NoInformationException" />
104	<issue number="53073"/>	104	<issue number="53073"/>
105	</change>	105	</change>
		106	<change>
		107	<api name="ViewModelAPI"/>
		108	<summary>Access to tree node expansion added.</summary>
		109	<date day="13" month="1" year="2005"/>
		110	<author login="jjancura"/>
		111	<compatibility binary="incompatible" source="incompatible" deletion="yes" addition="yes" modification="yes"/>
		112	<description>
		113	This change has been done to cover user requirement #46167.
		114	List of changes:
		115	1) new TreeExpansionModel introduced
		116	2) new class Models.TreeFeatures contains tree expansion methods.
		117	During implementation of this user requirement I have discovered important problem in ViewModel API.
		118	There is no possibility to add a new model to it. List of changes fixing this problem:
		119	1) Models.createView (...) and Models.setModelsToView (...) methods do not use fixed set of models as parameters,
		120	but they use Models.CompoundModel.
		121	2) Models.CompoundModel is final class implementing all currently supported models. The only way how to create
		122	a new instance of it is Models.createCompoundModel (List listOfModels). It allows future additions of new
		123	models.
		124	3) Methods Models.createCompoundTreeModel (...), Models.createCompoundNodeModel (...),
		125	Models.createCompoundTableModel (...), Models.createCompoundNodeActionsProvider (...), and field
		126	Models.EMPTY_TREE_MODEL has been removed as useless.
		127	How to update your code using these exceptions:
		128	No changes required for most of clients. You should change your code only if you are providing some
		129	new view based on ViewModel. In this case you should put all your model instances to one list,
		130	and call Models.createCompountModel (list), in place of calling createModel methods.
		131	</description>
		132	<class package="org.netbeans.spi.viewmodel" name="Models" />
		133	<class package="org.netbeans.spi.viewmodel" name="Models.CompoundModel" />
		134	<class package="org.netbeans.spi.viewmodel" name="Models.TreeFeatures" />
		135	<class package="org.netbeans.spi.viewmodel" name="TreeExpansionModel" />
		136	<issue number="46167"/>
		137	</change>
106		138
107	</changes>	139	</changes>
108		140

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 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 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 18-23 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/modules/viewmodel/TreeModelNode.java (-49 / +25 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 289-295 Link Here
289	name = (String) object;	252	name = (String) object;
290	setName (name);	253	setName (name);
291	setDisplayName (name);	254	setDisplayName (name);
292	setIconBase ("org/openide/resources/actions/empty");	255	// setIconBase ("org/openide/resources/actions/empty");
293	} else {	256	} else {
294	e.printStackTrace ();	257	e.printStackTrace ();
295	System.out.println (model);	258	System.out.println (model);
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 5-11 Link Here

(-)debuggercore/viewmodel/src/org/netbeans/spi/viewmodel/package.html (-4 / +7 lines)
5	content="text/html; charset=iso-8859-1">	5	content="text/html; charset=iso-8859-1">
6	<meta name="GENERATOR"	6	<meta name="GENERATOR"
7	content="Mozilla/4.76 [en] (Windows NT 5.0; U) [Netscape]">	7	content="Mozilla/4.76 [en] (Windows NT 5.0; U) [Netscape]">
8	<title>package</title>	8	<title>View Model API</title>
9	<!--	9	<!--
10	-- Sun Public License Notice	10	-- Sun Public License Notice
11	--	11	--
Lines 18-23 Link Here
18	-- Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun	18	-- Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
19	-- Microsystems, Inc. All Rights Reserved.	19	-- Microsystems, Inc. All Rights Reserved.
20	-->	20	-->
		21	<meta content="Jan Jancura" name="author">
21	</head>	22	</head>
22	<body style="color: rgb(0, 0, 0);" link="#0000ee" alink="#0000ee"	23	<body style="color: rgb(0, 0, 0);" link="#0000ee" alink="#0000ee"
23	vlink="#551a8b">	24	vlink="#551a8b">
Lines 48-54 Link Here
48	alt="Tree Model Example 1" style="width: 401px; height: 355px;"	49	alt="Tree Model Example 1" style="width: 401px; height: 355px;"
49	align="right"><br> public Object getRoot () {<br> return ROOT;<br> }<br> <br> public Object[] getChildren (Object parent, int from, int to) {<br> if (parent == ROOT)<br> return File.listRoots ();<br> return ((File) parent).listFiles ();<br> }<br> <br> public boolean isLeaf (Object node) {<br> if (node == ROOT)<br> return false;<br> return ((File) node).isFile ();<br> }<br>}<br></pre>	50	align="right"><br> public Object getRoot () {<br> return ROOT;<br> }<br> <br> public Object[] getChildren (Object parent, int from, int to) {<br> if (parent == ROOT)<br> return File.listRoots ();<br> return ((File) parent).listFiles ();<br> }<br> <br> public boolean isLeaf (Object node) {<br> if (node == ROOT)<br> return false;<br> return ((File) node).isFile ();<br> }<br>}<br></pre>
50	And create a TreeView for this model:	51	And create a TreeView for this model:
51	<pre style="background-color: rgb(255, 255, 102);"> JComponent treeView = Models.createView (<br> new TreeModelImpl (), // TreeModel<br> null, // NodeModel<br> null, // TableModel<br> null, // NodeActionsProvider<br> new ArrayList () // list of ColumnModel s<br> );</pre>	52	<pre style="background-color: rgb(255, 255, 102);"> JComponent treeView = Models.createView (<br> Models.createCompoundModel (<br> Arrays.asList (new Model[] {<br> new TreeModelImpl (), // TreeModel<br> new ArrayList () // list of ColumnModel s<br> })<br> )<br> );</pre>
52	See <a href="../../../../examples/TreeModelExample1.java">TreeModelExample1</a>.<br>	53	See <a href="../../../../examples/TreeModelExample1.java">TreeModelExample1</a>.<br>
53	<h3>Step 2.</h3>	54	<h3>Step 2.</h3>
54	NodeModel implementation can define name, icon and tooltip for tree	55	NodeModel implementation can define name, icon and tooltip for tree
Lines 64-71 Link Here
64	<pre style="background-color: rgb(255, 255, 102);">public class NodeActionsProviderImpl implements NodeActionsProvider {<br><br> public Action[] getActions (final Object node) {<br> return new Action [] {<br> new AbstractAction ("Open") {<br> public void actionPerformed (ActionEvent e) {<br> performDefaultAction (node);<br> }<br> },<br> new AbstractAction ("Delete") {<br> public void actionPerformed (ActionEvent e) {<br> ((File) node).delete ();<br> }<br> }<br> };<br> }<br> <br> public void performDefaultAction (Object node) {<br> try {<br> JFrame f = new JFrame ("View");<br> f.getContentPane ().add (new JEditorPane (((File) node).toURL ()));<br> f.pack ();<br> f.show ();<br> } catch (Exception e) {<br> e.printStackTrace();<br> }<br> }<br>}</pre>	65	<pre style="background-color: rgb(255, 255, 102);">public class NodeActionsProviderImpl implements NodeActionsProvider {<br><br> public Action[] getActions (final Object node) {<br> return new Action [] {<br> new AbstractAction ("Open") {<br> public void actionPerformed (ActionEvent e) {<br> performDefaultAction (node);<br> }<br> },<br> new AbstractAction ("Delete") {<br> public void actionPerformed (ActionEvent e) {<br> ((File) node).delete ();<br> }<br> }<br> };<br> }<br> <br> public void performDefaultAction (Object node) {<br> try {<br> JFrame f = new JFrame ("View");<br> f.getContentPane ().add (new JEditorPane (((File) node).toURL ()));<br> f.pack ();<br> f.show ();<br> } catch (Exception e) {<br> e.printStackTrace();<br> }<br> }<br>}</pre>
65	See <a href="../../../../examples/TreeModelExample3.java">TreeModelExample3</a>.<br>	66	See <a href="../../../../examples/TreeModelExample3.java">TreeModelExample3</a>.<br>
66	<br>	67	<br>
67	<img src="../../../../examples/TreeModelExample3.JPG" title=""	68	<div style="text-align: center;"><img
		69	src="../../../../examples/TreeModelExample3.JPG" title=""
68	alt="Tree Model Example 3" style="width: 642px; height: 438px;"><br>	70	alt="Tree Model Example 3" style="width: 642px; height: 438px;"><br>
		71	</div>
69	<h3>Step 4.</h3>	72	<h3>Step 4.</h3>
70	TableModel and ColumnModel adds support for additional columns to tree	73	TableModel and ColumnModel adds support for additional columns to tree
71	view.<br>	74	view.<br>
Lines 74-80 Link Here
74	<pre style="background-color: rgb(255, 255, 102);"> ArrayList columns = new ArrayList ();<img	77	<pre style="background-color: rgb(255, 255, 102);"> ArrayList columns = new ArrayList ();<img
75	src="../../../../examples/TreeModelExample4.JPG" title=""	78	src="../../../../examples/TreeModelExample4.JPG" title=""
76	alt="Tree Model Example 4" style="width: 384px; height: 278px;"	79	alt="Tree Model Example 4" style="width: 384px; height: 278px;"
77	align="right"><br> columns.add (new ColumnModel () {<br> public String getID () { return "sizeID"; }<br> public String getDisplayName () { return "size"; }<br> public Class getType () { return String.class; }<br> });<br> JComponent treeTableView = Models.createView (<br> new TreeModelImpl (), // TreeModel<br> new NodeModelImpl (), // NodeModel<br> new TableModelImpl (), // TableModel<br> new NodeActionsProviderImpl (), // NodeActionsProvider<br> columns // list of ColumnModel s<br> );<br><br></pre>	80	align="right"><br> columns.add (new ColumnModel () {<br> public String getID () { return "sizeID"; }<br> public String getDisplayName () { return "size"; }<br> public Class getType () { return String.class; }<br> });<br> JComponent treeTableView = Models.createView (<br> Models.createCompoundModel (<br> Arrays.asList (new Model[] {<br> new TreeModelImpl (), // TreeModel<br> new NodeModelImpl (), // NodeModel<br> new TableModelImpl (), // TableModel<br> new NodeActionsProviderImpl (), // NodeActionsProvider<br> columns // list of ColumnModel s<br> })<br> )<br> );<br><br></pre>
78	See <a href="../../../../examples/TreeModelExample4.java">TreeModelExample4</a>.<br>	81	See <a href="../../../../examples/TreeModelExample4.java">TreeModelExample4</a>.<br>
79	<br>	82	<br>
80	<br>	83	<br>

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	}