Initial import from SVN

1 files changed, 582 insertions, 0 deletions

diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/TreeAssociation.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/TreeAssociation.java
new file mode 100644
index 0000000..728643b
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/TreeAssociation.java
@@ -0,0 +1,582 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing;
+
+import java.awt.EventQueue;
+import java.awt.Rectangle;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.Vector;
+
+import javax.swing.JTree;
+import javax.swing.event.TreeExpansionEvent;
+import javax.swing.event.TreeExpansionListener;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeWillExpandListener;
+import javax.swing.tree.ExpandVetoException;
+import javax.swing.tree.TreePath;
+
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.ui.EODisplayGroup;
+
+/**
+* TreeAssociation is a TreeModelAssociation further
+* customized for JTrees.  It binds a JTree to a display group's
+* list of displayable objects, each of which may have
+* a list of child objects managed by another display
+* group, and so on.  TreeAssociation works exactly
+* like a ListAssociation, with the additional capability
+* to specify a "Children" aspect, that will allow child
+* objects to be retrieved from a parent display group.
+* Note that the children aspect requires the bound
+* display group to have a DataSource that can vend a
+* DataSource appropriate for the bound key  That data
+* source is then used to create data sources for
+* child nodes, and so on.
+*
+* <ul>
+*
+* <li>titles: a property convertable to a string for
+* display in the nodes of the tree.  The objects in
+* the bound display group will be used to populate the
+* initial root nodes of the tree (more accurately,
+* children of the offscreen root node in the tree).</li>
+*
+* <li>children: a property of a node value that returns
+* zero, one or many objects, each of which will correspond
+* to a child node for the corresponding node in the tree.
+* The data source of the bound display group is replaced 
+* a data source that populates the display group with
+* the visible nodes in the tree component as determined by 
+* calling fetchObjectsIntoChildrenGroup.
+* If this aspect is not bound, the tree behaves like a list.
+* <br><br>
+* Binding this aspect with a null display group is the same
+* as binding it with the titles display group.  
+* In this configuration the contents of the titles 
+* display group will be replaced with the visible nodes in the
+* tree component, as specified above, replacing the existing 
+* data source.  
+* <br><br>
+* In that case, the display groups for the nodes in
+* the tree will still use the original data source
+* for resolving their children key, and programmatically
+* setting the contents of the display group will still 
+* repopulate the root nodes of the tree.
+* </li>
+*
+* <li>isLeaf: a property of a node value that returns
+* a value convertable to a boolean value (aside from
+* an actual boolean value, zeroes evaluate to true,
+* as does any String containing "yes" or "true" or that
+* is convertable to a number equal to zero; other values
+* evaluate to false).  
+* <br><br>
+* If the isLeaf aspect is not bound,
+* the tree must force nodes to load their children to
+* determine whether they are leaf nodes (in effect
+* loading the grandchildren for any expanded node).
+* If bound, child loading is deferred until the node
+* is actually expanded.  
+* <br><br>
+* For example, binding this value to a null
+* display group and the key "false" will result in a
+* deferred-loading tree that works much like Windows
+* Explorer's network volume browser - all nodes appear
+* with "pluses" until they are expanded.
+* <br><br>
+* Note that the display group is ignored: the property
+* will be applied directly to the object corresponding
+* to the node.</li>
+*
+* </ul>
+*
+* All other usage is as TreeModelAssociation.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class TreeAssociation extends TreeModelAssociation
+    implements FocusListener, TreeExpansionListener, TreeWillExpandListener, Runnable
+{
+    private boolean isExpanding;
+    private Vector nodeQueue;
+    private Vector structureQueue;
+    private boolean isRunning;
+    
+    /**
+    * Constructor expecting a JTree.
+    */
+    public TreeAssociation ( Object anObject )
+    {
+        super( anObject );
+        init();
+    }
+
+    /**
+    * Constructor expecting a JTree or similar component
+    * and specifying a label for the root node.
+    */
+    public TreeAssociation( Object anObject, Object aRootLabel )
+    {
+        super( anObject );
+        init();
+        rootLabel = aRootLabel;
+        rootNode.setUserObject( aRootLabel );
+    }
+    
+    // convenience
+    private JTree component()
+    {
+        return (JTree) object();
+    }
+
+    /**
+    * Called by both constructors.
+    */
+    protected void init()
+    {
+        isExpanding = false;
+        isRunning = false;
+        nodeQueue = new Vector();
+        structureQueue = new Vector();
+        component().addFocusListener( this );
+        component().addTreeExpansionListener( this );
+        component().addTreeWillExpandListener( this );
+    }
+
+    /**
+    * Returns whether this class can control the specified
+    * object.
+    */
+    public static boolean isUsableWithObject ( Object anObject )
+    {
+        return ( anObject instanceof JTree );
+    }
+
+    /**
+    * Overridden to not fire events during initial population.
+    */
+    public void establishConnection ()
+    {
+        isExpanding = true;
+        super.establishConnection();
+        isExpanding = false;
+    }
+    
+    // interface TreeSelectionListener
+
+    public void valueChanged(TreeSelectionEvent e)
+    {
+        if ( ! isListening ) return;
+// NOTE: This approach causes focus rectangle to perceptibly trail
+// the selection rectangle, presumably because we're called after the
+// new selection has been processed but before the focus is processed.
+// Users don't like it, so we're going with a preference to use
+// invokeLater.
+/*
+        // paint immediately before updating the display group and
+        //   before any potentially lengthy second-order effects happen:
+        //   this improves user-perceived responsiveness of big apps
+        if ( object() instanceof javax.swing.JComponent )
+        {
+            javax.swing.JComponent component = (javax.swing.JComponent)object();
+            component.paintImmediately( component.getBounds() );
+        }
+        selectFromSelectionModel();
+*/
+
+// NOTE: This approach uses invoke later to cause the update of
+// the display group (which could be lengthly if that in turn
+// causes other things to update) to happen after the tree repaints.
+// Users like this because it "feels faster", but developers have
+// to remember that if they listen to tree selection events they
+// will have to do a similar invoke later if they check the display
+// group.
+
+        Runnable select = new Runnable()
+        {
+            public void run()
+            {
+                selectFromSelectionModel();
+            }
+        };
+        
+        if ( selectionPaintedImmediately )
+        {
+            if ( object() instanceof java.awt.Component )
+            {
+                ((java.awt.Component)object()).repaint();
+            }
+            EventQueue.invokeLater( select );
+        }
+        else
+        {
+            select.run();
+        }
+    }
+
+    /**
+    * Overridden to check whether the node is visible 
+    * in the tree on screen.  Offscreen in a scrollpane
+    * does not count.
+    */
+    public boolean isVisible(Object node)
+    {
+        JTree tree = (JTree) object();
+        TreePath path = ((DisplayGroupNode)node).treePath();
+        if ( tree.isVisible( path ) )
+        {
+            Rectangle rowRect = tree.getPathBounds( path );
+            if ( rowRect != null )
+            {
+                Rectangle visible = tree.getVisibleRect();
+                if ( visible != null )
+                {
+//System.out.println( "isVisible: intersects: " + visible.intersects( rowRect ) );        
+                    return visible.intersects( rowRect );
+                }
+            }
+        }
+//System.out.println( "isVisible: false" );        
+        return false;
+    }
+
+    /**
+    * Fires a tree nodes changed event to all listeners.
+    * Provided as a convenience if you need to make manual
+    * changes to the tree model.
+    */
+    public void fireTreeNodesChanged(final Object source,
+                                     final Object[] path,
+                                     final int[] childIndices,
+                                     final Object[] children)
+    {
+        if ( !isExpanding )
+        {
+            for ( int i = 0; i < children.length; i++ )
+            {
+                nodeQueue.add( children[i] );
+            }
+            if ( !isRunning )
+            {
+                isRunning = true;
+                EventQueue.invokeLater( this );
+            }
+        }
+    }
+
+    /**
+    * Fires a tree nodes inserted event to all listeners.
+    * Provided as a convenience if you need to make manual
+    * changes to the tree model.
+    */
+    public void fireTreeNodesInserted(Object source,
+                                     Object[] path,
+                                     int[] childIndices,
+                                     Object[] children)
+    {
+        if ( !isExpanding )
+        {
+            super.fireTreeNodesInserted( source, path, childIndices, children );
+            EventQueue.invokeLater( this );
+        }
+    }
+
+    /**
+    * Fires a tree nodes removed event to all listeners.
+    * Provided as a convenience if you need to make manual
+    * changes to the tree model.
+    */
+    public void fireTreeNodesRemoved(Object source,
+                                    Object[] path,
+                                    int[] childIndices,
+                                    Object[] children)
+    {
+        if ( !isExpanding )
+        {
+            super.fireTreeNodesRemoved( source, path, childIndices, children );
+            EventQueue.invokeLater( this );
+        }
+    }
+
+    /**
+    * Fires a tree structure changed event to all listeners.
+    * Provided as a convenience if you need to make manual
+    * changes to the tree model.
+    */
+    public void fireTreeStructureChanged(Object source,
+                                    Object[] path,
+                                    int[] childIndices,
+                                    Object[] children)
+    {
+        if ( !isExpanding )
+        {
+            structureQueue.add( path[path.length-1] );
+            if ( !isRunning )
+            {
+                isRunning = true;
+                EventQueue.invokeLater( this );
+            }
+        }
+    }
+
+    /**
+    * Overridden to return all visible rows in the tree.
+    */
+    public NSArray objectsFetchedIntoChildrenGroup()
+    {
+        JTree tree = (JTree) object();
+        NSMutableArray objectList = new NSMutableArray();
+        
+        int count = tree.getRowCount();
+        for ( int i = 0; i < count; i++ )
+        {
+            objectList.add(  
+                ((DisplayGroupNode) tree.getPathForRow( i ).getLastPathComponent()).object() );
+        }
+
+//new net.wotonomy.ui.swing.util.StackTraceInspector( Integer.toString( objectList.size() )  );
+        return objectList;
+    }
+
+    // interface FocusListener
+    
+	/**
+	* Notifies of beginning of edit.
+	*/
+    public void focusGained(FocusEvent evt)
+    {
+		Object o;
+		EODisplayGroup displayGroup;
+        Enumeration e = aspects().objectEnumerator();
+		while ( e.hasMoreElements() )
+		{
+			displayGroup =
+				displayGroupForAspect( e.nextElement().toString() );
+			if ( displayGroup != null )
+			{
+				displayGroup.associationDidBeginEditing( this );
+			}
+		}
+    }
+
+	/**
+	* Updates object on focus lost and notifies of end of edit.
+	*/
+    public void focusLost(FocusEvent evt)
+    {
+        if ( ! component().isEditing() )
+        {
+            Object o;
+            EODisplayGroup displayGroup;
+            Enumeration e = aspects().objectEnumerator();
+            while ( e.hasMoreElements() )
+            {
+                displayGroup =
+                    displayGroupForAspect( e.nextElement().toString() );
+                if ( displayGroup != null )
+                {
+                    displayGroup.associationDidEndEditing( this );
+                }
+            }
+        }
+    }
+    
+    // interface TreeWillExpandListener
+    
+    public void treeWillExpand(TreeExpansionEvent event)
+                    throws ExpandVetoException
+    {
+        isExpanding = true;
+    }
+                    
+    public void treeWillCollapse(TreeExpansionEvent event)
+                      throws ExpandVetoException                    
+    {
+        // do nothing
+    }
+                    
+    // interface TreeExpansionListener
+    
+    /**
+    * Updates the children display group, if any.
+    */
+    public void treeExpanded(TreeExpansionEvent event)
+    { //System.out.println( "treeExpanded: " + event.getPath().getLastPathComponent() );        
+        isExpanding = false;
+        if ( childrenDisplayGroup != null )
+        {
+            removeAsListener(); // prevent data source refetch: see fetchObjects()
+            childrenDisplayGroup.fetch();
+            addAsListener();
+        }
+    }
+    
+    /**
+    * Updates the children display group, if any.
+    */
+    public void treeCollapsed(TreeExpansionEvent event)
+    {
+        if ( childrenDisplayGroup != null )
+        {
+            removeAsListener(); // prevent data source refetch: see fetchObjects()
+            childrenDisplayGroup.fetch();
+            addAsListener();
+        }
+    }
+    
+    // interface Runnable
+    
+    /**
+    * Fires any queued node changed and structure changed events.
+    * Typically invoked on a delayed event loop.
+    */
+    public void run()
+    {
+        DisplayGroupNode node;    
+        int index;
+        Iterator i;
+        
+        i = nodeQueue.iterator();
+        while ( i.hasNext() )
+        {
+            node = (DisplayGroupNode) i.next();
+            index = ((DisplayGroupNode)node.parentGroup).getIndex( node );
+            if ( ( index != -1 )
+            && ( node.treePath().getParentPath() != null ) )
+            {
+                super.fireTreeNodesChanged( 
+                    node,
+                    node.treePath().getParentPath().getPath(),
+                    new int[] { index },
+                    new Object[] { node } );
+            }
+        }
+        nodeQueue.clear();
+        
+        i = structureQueue.iterator();
+        while ( i.hasNext() )
+        {
+            node = (DisplayGroupNode) i.next();
+            super.fireTreeStructureChanged( 
+                node,
+                node.treePath().getPath(),
+                null,
+                null );
+        }
+        structureQueue.clear();
+        
+        isRunning = false;
+/*      
+        EventQueue.invokeLater( new Runnable() { public void run() {
+            ((JTree)object()).treeDidChange();
+            ((JTree)object()).getParent().invalidate();
+            ((JTree)object()).getParent().validate();
+            ((JTree)object()).getParent().update( ((JTree)object()).getGraphics() );
+            
+//            ((JTree)object()).getParent().doLayout();
+//            ((JTree)object()).getParent().repaint();
+//            ((JTree)object()).repaint();
+//            ((JTree)object()).updateUI();
+        } } );
+*/       
+    }
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:19:05  cgruber
+ * Update imports and maven dependencies.
+ *
+ * Revision 1.1  2006/02/16 13:22:22  cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.55  2004/02/05 02:18:50  mpowers
+ * Super was calling back into this class before init() was called.
+ *
+ * Revision 1.54  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.53  2003/06/03 14:49:48  mpowers
+ * Now correctly calculating isVisible based on the component visible rect.
+ * Now deferring node changed events to a later event queue to allow repaints
+ * to happen after all changes have taken effect.
+ *
+ * Revision 1.52  2002/05/03 21:41:18  mpowers
+ * No longer clearing the selection model when updating from display group:
+ * we now only modify if a change needs to be made.
+ * No longer listening for selection change during firing of delete events:
+ * delete events cause JTree's to update their selection model.
+ * Fix for paintsSelectionImmediately: TreeAssociation.processRecentChanges()
+ * must happen after the screen is painted, or the selection is not displayed.
+ *
+ * Revision 1.51  2002/04/19 21:18:45  mpowers
+ * Removed tree event coalescing, which was causing way too many problems.
+ * The fireChangeEvent algorithm is way faster than before, so we should
+ * still be better off than before.  At least now, we don't have to track
+ * whether the view component has encountered a particular node.
+ *
+ * Revision 1.49  2002/04/12 21:05:58  mpowers
+ * Now distinguishing changes in titles group even better.
+ *
+ * Revision 1.48  2002/04/12 20:36:31  mpowers
+ * Now distinguishing between changes made on titles group by tree expansion
+ * versus external changes which should cause us to repopulate root nodes.
+ *
+ * Revision 1.47  2002/04/10 21:20:04  mpowers
+ * Better handling for tree nodes when working with editing contexts.
+ * Better handling for invalidation.  No longer broadcasting events
+ * when nodes have not been "registered" in the tree.
+ *
+ * Revision 1.46  2002/03/27 20:44:53  mpowers
+ * Added isVisible test for node.
+ *
+ * Revision 1.45  2002/03/08 23:19:57  mpowers
+ * Refactoring of DelegatingTreeDataSource to facilitate binding of titles
+ * and children aspects to the same display group.
+ *
+ * Revision 1.44  2002/03/07 23:04:36  mpowers
+ * Refining TreeColumnAssociation.
+ *
+ * Revision 1.43  2002/03/06 13:04:15  mpowers
+ * Implemented cascading qualifiers in tree nodes.
+ *
+ * Revision 1.42  2002/03/05 23:18:28  mpowers
+ * Added documentation.
+ * Added isSelectionPaintedImmediate and isSelectionTracking attributes
+ * to TableAssociation.
+ * Added getTableAssociation to TableColumnAssociation.
+ *
+ * Revision 1.41  2002/03/01 23:42:08  mpowers
+ * Implemented TreeColumnAssociation, and updated documentation.
+ *
+ * Revision 1.40  2002/03/01 20:41:39  mpowers
+ * Now a focus listener and an expansion listener.
+ *
+ * Revision 1.39  2002/02/27 23:19:17  mpowers
+ * Refactoring of TreeAssociation to create TreeModelAssociation parent.
+ *
+ *
+ */
+