Initial import from SVN

1 files changed, 1518 insertions, 0 deletions

diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DisplayGroupNode.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DisplayGroupNode.java
new file mode 100644
index 0000000..1756285
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DisplayGroupNode.java
@@ -0,0 +1,1518 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2001 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.Component;
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Vector;
+
+import javax.swing.tree.TreePath;
+
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.control.EODelayedObserver;
+import net.wotonomy.control.EOEditingContext;
+import net.wotonomy.control.EOObjectStore;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.control.EOQualifier;
+import net.wotonomy.control.PropertyDataSource;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSDictionary;
+import net.wotonomy.foundation.NSMutableDictionary;
+import net.wotonomy.foundation.NSNotification;
+import net.wotonomy.foundation.internal.ValueConverter;
+import net.wotonomy.foundation.internal.WotonomyException;
+import net.wotonomy.ui.EODisplayGroup;
+import net.wotonomy.ui.swing.TreeModelAssociation.DelegatingTreeDataSource;
+
+/**
+* DisplayGroupNodes are used as nodes in the
+* TreeModelAssociation's implementation of TreeModel,
+* and is tightly coupled with TreeModelAssociation
+* and MasterDetailAssociation. <br><br>
+*
+* Even though it is no longer package access,
+* don't rely on this class because we want to
+* have the option of completely replacing this
+* approach in the future.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+    abstract public class DisplayGroupNode
+        extends EODisplayGroup
+    {
+        protected TreeModelAssociation parentAssociation;
+        protected EODelayedObserver targetObserver;
+        protected NSMutableDictionary childNodes;
+        protected EODisplayGroup parentGroup;
+        protected Object target;
+        protected boolean isFetched;
+        protected boolean isFetchNeeded;
+        protected boolean useParentOrderings;
+        protected boolean useParentQualifier;
+
+        /**
+        * Constructor for all nodes.
+        * Root node must have a null target.
+        */
+        public DisplayGroupNode(
+            TreeModelAssociation aParentAssociation,
+            EODisplayGroup aParentGroup,
+            Object aTarget )
+        {
+//new net.wotonomy.ui.swing.util.StackTraceInspector( ""+aTarget );
+//System.out.println( "DisplayGroupNode.new: " + aTarget );            
+            parentAssociation = aParentAssociation;
+            target = null;
+            targetObserver = null;
+            parentGroup = aParentGroup;
+            childNodes = new NSMutableDictionary();
+            isFetched = false;
+            isFetchNeeded = false;
+            useParentOrderings = true;
+            useParentQualifier = true;
+
+            EODataSource parentSource = null;
+            if ( parentGroup != null )
+            {
+                parentSource = parentGroup.dataSource();
+            }
+            else
+            if ( parentAssociation.titlesDisplayGroup != null )
+            {
+                parentSource = parentAssociation.titlesDisplayGroup.dataSource();
+            }
+
+            // create child datasource
+            if ( aTarget != null ) // not root node
+            {
+                if ( parentAssociation.childrenKey != null )
+                {
+                    if ( parentSource == null )
+                    {
+                        throw new WotonomyException(
+                            "Need a data source when children aspect is bound." );
+                    }
+
+                    NSArray displayedObjects = parentGroup.displayedObjects();
+                    EODataSource childSource = parentSource.dataSourceQualifiedByKey(
+                        parentAssociation.childrenKey );
+                    childSource.qualifyWithRelationshipKey(
+                        parentAssociation.childrenKey, aTarget );
+
+                    // create new display group using child data source
+                    this.setDataSource( childSource );
+
+                    // establish observer for target object
+                    setTarget( aTarget );
+                }
+                else // only titles is bound
+                {
+                    // establish observer for target object
+                    setTarget( aTarget );
+                    
+                    setDataSource( new PropertyDataSource() 
+                    {
+                        public NSArray fetchObjects()
+                        {
+                            return new NSArray();
+                        }
+                    } );
+                }
+            }
+            else // else root node
+            {
+                // root node uses PropertyDataSource by default
+                if ( parentSource == null )
+                {
+                    setDataSource( new PropertyDataSource() 
+                    {
+                        public NSArray fetchObjects()
+                        {
+                            if ( parentGroup != null )
+                            {
+                                return parentGroup.displayedObjects();
+                            }
+                            return null;
+                        }
+                    } );
+                }
+                else
+                {
+                    // root node uses parent source directly
+                    setDataSource( parentSource );
+                }
+            }
+        }
+        
+        /**
+        * Overridden to unregister as an editor of the editing context,
+        * since we don't directly present a user interface.
+        */
+        public void setDataSource ( EODataSource aDataSource )
+        {
+            super.setDataSource( aDataSource );
+            if ( ( aDataSource != null )
+            &&   ( aDataSource.editingContext() != null ) )
+            {
+                aDataSource.editingContext().removeEditor( this );
+            }
+        }
+        
+        /**
+        * Returns whether the node should call fetch().
+        */
+        protected boolean isFetched()
+        {
+            if ( isFetchNeeded() )
+            {
+                setFetchNeeded( false );
+                fetch();
+            }
+            return isFetched;
+        }
+
+        /**
+        * Sets whether the node should call fetch().
+        */
+        protected void setFetched( boolean fetched )
+        {
+//System.out.println( "DisplayGroupNode.setFetched: " + fetched + " : " + this + " : " + target );
+//net.wotonomy.ui.swing.util.StackTraceInspector.printShortStackTrace();
+            isFetched = fetched;
+        }
+
+        /**
+        * Returns whether the node is in need of a refetch.
+        */
+        protected boolean isFetchNeeded()
+        {
+            return isFetchNeeded;
+        }
+
+        /**
+        * Returns whether the node should call fetch().
+        */
+        protected void setFetchNeeded( boolean fetchNeeded )
+        {
+//System.out.println( "DisplayGroupNode.setFetchNeeded: " + fetchNeeded + " : " + this + " : " + target );
+//net.wotonomy.ui.swing.util.StackTraceInspector.printShortStackTrace();
+            isFetchNeeded = fetchNeeded;
+        }
+
+        /**
+        * Subclasses should override this method to fire an appropriate insertion event.
+        */
+        protected void fireNodesInserted( Object[] path, int[] indexes, Object[] objects )
+        {
+//System.out.println( "fireNodesInserted: " + this );            
+            parentAssociation.fireTreeNodesInserted(
+                this, path, indexes, objects );
+        }
+
+        /**
+        * Subclasses should override this method to fire an appropriate change event.
+        */
+        protected void fireNodesChanged( Object[] path, int[] indexes, Object[] objects )
+        {
+//System.out.println( "fireNodesChanged: " + this );            
+            parentAssociation.fireTreeNodesChanged(
+                this, path, indexes, objects );
+        }
+
+        /**
+        * Subclasses should override this method to fire an appropriate deletion event.
+        */
+        protected void fireNodesRemoved( Object[] path, int[] indexes, Object[] objects )
+        {
+//System.out.println( "fireNodesRemoved: " + this );            
+            parentAssociation.fireTreeNodesRemoved(
+                this, path, indexes, objects );
+        }
+
+        /**
+        * Subclasses should override this method to fire an appropriate event.
+        */
+        protected void fireStructureChanged( Object[] path, int[] indexes, Object[] objects )
+        {
+            parentAssociation.fireTreeStructureChanged(
+                this, path, indexes, objects );
+        }
+
+        /**
+        * Overridden to broadcast a tree event after super executes.
+        */
+        public void insertObjectAtIndex ( Object anObject, int anIndex )
+        {
+            int count = getChildCount(); // gets old count
+            if ( target == null )
+            {
+                // if root node, forward to parent:
+                // circumventing delegating data source, if any
+                EODataSource dataSource = parentGroup.dataSource();
+                if ( dataSource instanceof DelegatingTreeDataSource )
+                {
+                    parentGroup.setDataSource( 
+                        ((DelegatingTreeDataSource)dataSource).delegateDataSource );
+                }
+                parentGroup.insertObjectAtIndex( anObject, anIndex );
+                if ( dataSource instanceof DelegatingTreeDataSource )
+                {
+                    parentGroup.setDataSource( dataSource );
+                }
+                return; // prevent event from firing (?)
+            }
+            else // not root node
+            {
+                super.insertObjectAtIndex( anObject, anIndex );
+            }
+        }
+
+        /**
+        * Overridden to broadcast a tree event after super executes.
+        */
+        public boolean deleteObjectAtIndex ( int anIndex )
+        {
+            boolean result;
+            Object node = getChildNodeAt( anIndex );
+            if ( target == null )
+            {
+                // if root node, forward to parent:
+                result = parentGroup.deleteObjectAtIndex( anIndex );
+            }
+            else // not root node
+            {
+                result = super.deleteObjectAtIndex( anIndex );
+            }
+
+            return result;
+        }
+
+        /**
+        * Returns the child node that corresponds to the
+        * specified index, creating it if necessary.
+        * The index must be within bounds or an exception
+        * is thrown.
+        */
+        public DisplayGroupNode getChildNodeAt( int anIndex )
+        {
+            boolean wasFetched = isFetched();
+            if ( ! wasFetched ) fetch();
+            Object o = displayedObjects.objectAtIndex( anIndex );
+            DisplayGroupNode result = getChildNodeForObject( o );
+            if ( result == null )
+            {
+                result = createChildNodeForObject( o );
+            }
+            return result;
+        }
+
+        /**
+        * Returns a child node that corresponds to the
+        * specified object, returning null if not found.
+        */
+        protected DisplayGroupNode getChildNodeForObject( Object anObject )
+        {
+            return (DisplayGroupNode) 
+                childNodes.objectForKey( new ReferenceKey( anObject ) );
+        }
+
+        /**
+        * Creates a child node that corresponds to the
+        * specified object.
+        */
+        private DisplayGroupNode createChildNodeForObject( Object anObject )
+        {
+            DisplayGroupNode result = parentAssociation.createNode( this, anObject );
+            childNodes.setObjectForKey( result, new ReferenceKey( anObject ) );
+            return result;
+        }
+
+        /**
+        * Returns a tree path of all DisplayGroupNodes leading
+        * to this node, including the root node (but excluding the
+        * titles display group).
+        */
+        public TreePath treePath()
+        {
+            List path = new LinkedList();
+            EODisplayGroup node = this;
+            while ( node instanceof DisplayGroupNode )
+            {
+                // insert at head of list
+                path.add( 0, node );
+                node = ((DisplayGroupNode)node).parentGroup;
+            }
+            return new TreePath( path.toArray() );
+        }
+
+        /**
+        * Overridden to return the parent group's
+        * sort ordering if useParentOrderings is true.
+        * useParentOrderings is true by default.
+        */
+        public NSArray sortOrderings()
+        {
+            if ( ( useParentOrderings )
+            && ( parentGroup != null ) )
+            {
+                return parentGroup.sortOrderings();
+            }
+            return super.sortOrderings();
+        }
+
+        /**
+        * Overridden to set useParentOrderings to false,
+        * or true if aList is null.
+        */
+        public void setSortOrderings ( List aList )
+        {
+            if ( aList == null )
+            {
+                useParentOrderings = true;
+            }
+            else
+            {
+                useParentOrderings = false;
+                super.setSortOrderings( aList );
+            }
+        }
+
+        /**
+        * Overridden to return the parent group's
+        * qualifier if useParentQualifier is true.
+        * useParentQualifier is true by default.
+        */
+        public EOQualifier qualifier()
+        {
+            if ( ( useParentQualifier )
+            && ( parentGroup != null ) )
+            {
+                return parentGroup.qualifier();
+            }
+            return super.qualifier();
+        }
+
+        /**
+        * Overridden to set useParentQualifier to false,
+        * or true if aList is null.
+        */
+        public void setQualifier ( EOQualifier aQualifier )
+        {
+            if ( aQualifier == null )
+            {
+                useParentQualifier = true;
+            }
+            else
+            {
+                useParentQualifier = false;
+                super.setQualifier( aQualifier );
+            }
+        }
+
+        /**
+        * Overridden to set isFetched to true.
+        */
+        public boolean fetch()
+        { 
+//System.out.println( "DisplayGroupNode.fetch: " + this + " : " );
+//if ( getClass().getName().indexOf( "Activity" ) != -1 )
+//{
+//    new net.wotonomy.ui.swing.util.StackTraceInspector( this.toString() );
+//}
+            // set flag
+            setFetched( true );
+
+            // skip root node
+            if ( target == null ) return true;
+
+            // requalify
+            dataSource().qualifyWithRelationshipKey(
+                parentAssociation.childrenKey, target );
+
+            // call to super
+            return super.fetch();
+
+//boolean result = super.fetch();
+//System.out.println( displayedObjects() );
+//return result;
+        }
+
+        /**
+        * Returns the object at the appropriate index
+        * in the parent display group.
+        */
+        public Object object()
+        {
+            // if root node
+            if ( target == null )
+            {
+                return parentAssociation.rootLabel();
+            }
+            return target;
+        }
+
+        /**
+        * Returns the string value of the title property
+        * on the object in the parent display group corresponding
+        * to this index.  The tree renderer asks JTrees to
+        * call this method to retrieve a value for display.
+        */
+        public String toString()
+        {
+            Object result = getUserObject();
+            if ( result == null ) result = "[null]";
+            return result.toString();
+        }
+
+        // parts of interface TreeNode
+
+        public int getChildCount()
+        {
+            if ( ! isFetched() ) fetch();
+//if ( toString().indexOf("154.16406")!=-1){           
+//System.out.println( "getChildCount: " + displayedObjects.count() + " : " + this );            
+//new RuntimeException().printStackTrace();
+//net.wotonomy.ui.swing.util.StackTraceInspector.printShortStackTrace();
+//}
+            return displayedObjects.count();
+        }
+
+        public int getIndex(DisplayGroupNode node)
+        {
+            if ( ! isFetched() ) fetch();
+            return displayedObjects.indexOfObject(
+                ((DisplayGroupNode)node).target );
+        }
+
+        public boolean getAllowsChildren()
+        {
+            return true;
+        }
+
+        public boolean isLeaf()
+        {
+            // if not root node and isLeaf aspect is bound
+            if ( ( target != null )
+            &&   ( parentGroup != null )
+            &&   ( parentAssociation.leafKey != null ) )
+            {
+                Object value;
+                if ( parentAssociation.leafDisplayGroup != null )
+                {
+                    value = parentGroup.valueForObject(
+                        target, parentAssociation.leafKey );
+                }
+                else
+                {
+                    value = parentAssociation.leafKey;
+                }
+
+                // getBoolean returns true for zero, among other things
+                Object result = ValueConverter.getBoolean( value );
+                if ( result != null )
+                {
+                    return ((Boolean)result).booleanValue();
+                }
+            }
+
+            // otherwise, we have to fetch and return count
+            return ( getChildCount() == 0 );
+        }
+
+        public Enumeration children()
+        {
+            int count = getChildCount();
+            Vector v = new Vector();
+            for ( int i = 0; i < count; i++ )
+            {
+                v.add( getChildNodeAt( i ) );
+            }
+            return v.elements();
+        }
+
+        // parts of interface MutableTreeNode
+
+        public void insert(DisplayGroupNode aChild, int anIndex)
+        {
+            insertObjectAtIndex(
+                ((DisplayGroupNode)aChild).object(), anIndex );
+        }
+
+        public void remove(int index)
+        {
+            deleteObjectAtIndex( index );
+        }
+
+        /**
+        * Removes the node at the index corresponding
+        * to the index of the object.
+        */
+        public void remove(DisplayGroupNode node)
+        {
+            remove( getIndex( node ) );
+        }
+
+        /**
+        * Removes our object from the parent display group.
+        */
+        public void removeFromParent()
+        {
+            int index = parentGroup.displayedObjects().indexOfIdenticalObject( target );
+            if ( index != NSArray.NotFound )
+            {
+                parentGroup.deleteObjectAtIndex( index );
+            }
+            else
+            {
+                throw new WotonomyException(
+                    "Object not found in parent group: " + target );
+            }
+        }
+
+        /**
+        * Removes our object from the parent display group
+        * and adds it to the end of the specified node's children.
+        */
+        public void setParent(DisplayGroupNode newParent)
+        {
+            removeFromParent();
+            newParent.insertObjectAtIndex(
+                object(), newParent.displayedObjects.size() );
+        }
+
+        /**
+        * Returns the value of the displayed property in the parent display group
+        * at the index that corresponds to the index of this node.
+        */
+        public Object getUserObject()
+        {
+            return valueForKey( parentAssociation.titlesKey );
+        }
+
+        /**
+        * Sets the value of the displayed property in the parent display group
+        * at the index that corresponds to the index of this node.
+        */
+        public void setUserObject( Object aValue )
+        {
+            setValueForKey( aValue, parentAssociation.titlesKey );
+        }
+
+        /**
+        * Returns a value from the object in the parent display group
+        * at the index that corresponds to the index of this node.
+        * For the root node, if the titles key is specified, the root
+        * label is returned, otherwise null is returned.
+        */
+        public Object valueForKey( String aKey )
+        {
+            // if root node
+            if ( target == null )
+            {
+                // compare by ref is okay for strings
+                if ( aKey == parentAssociation.titlesKey )
+                {
+                    return parentAssociation.rootLabel();
+                }
+                return null;
+            }
+            return parentGroup.valueForObject( target, aKey );
+        }
+
+        /**
+        * Sets a value on the object in the parent display group
+        * at the index that corresponds to the index of this node.
+        * For the root node, this method only works if aKey is the
+        * titlesAspect's key, otherwise does nothing.
+        */
+        public void setValueForKey(Object aValue, String aKey)
+        {
+            // if root node, return.
+            if ( target == null )
+            {
+                // compare by ref is okay for strings
+                if ( aKey == parentAssociation.titlesKey )
+                {
+                    parentAssociation.setRootLabel( aValue );
+
+                    // how to handle root node? tree event docs don't say.
+                    fireNodesChanged ( treePath().getPath(),
+                        new int[] { 0 },
+                        new Object[] { this } );
+                }
+                return;
+            }
+
+            parentGroup.setValueForObject(
+                aValue, target, aKey );
+        }
+
+        /**
+        * Perform any clean up in this method.
+        * The node will not be reused after this method is called.
+        * This implementation removes itself from the parent's
+        * set of child nodes, sets target and datasource to null,
+        * and then calls disposeChildNodes().
+        */
+        protected void dispose()
+        { //System.out.println( "dispose: " + this.getClass().getName() + " : " + this );
+            if ( parentGroup != null )
+            { 
+                ((DisplayGroupNode)parentGroup).childNodes.remove( 
+                    new ReferenceKey( target ) );
+            }
+            setTarget( (Object) null );
+            setDataSource( null );
+            disposeChildNodes();
+        }
+        
+        /**
+        * Calls dispose() on all child nodes.
+        */
+        protected void disposeChildNodes()
+        {
+            Iterator i = new LinkedList(childNodes.values()).iterator();
+            while ( i.hasNext() )
+            {
+                ((DisplayGroupNode) i.next()).dispose();
+            }
+        }
+        
+        /**
+        * Called after the target object posts a change notification.
+        * This implementation re-fetches which triggers
+        * updateDisplayedObjects to broadcast any tree events.
+        * This method marks the parent object as changed if:
+        * (1) this object is not registered in the editing context
+        * of the titles display group's data source (if any), AND
+        * (2) the children key is not in the list of attributes
+        * of the parent object's EOClassDescription.
+        */
+        public void targetChanged()
+        {
+            // if not root node
+            if ( target != null )
+            {
+                // if we're not root and not fetched, stop here.
+                //FIXME: with this, some nodes have old values when moved.
+                //FIXME: without this, nodes are unnecessarily fetched.
+                //FIXME: might have parent modify isFetched of certain child nodes.
+                if ( isFetched() )
+                {
+                    fetch();
+                }
+                else // not fetched - just update the display
+                {
+                    updateDisplayedObjects();
+                }
+/*
+//disabling this for performance reasons:
+//might reenable later or find an alternate approach
+                // check to see if we need to mark the parent object as changed
+                EOEditingContext context = dataSource().editingContext();
+                if ( ( context == null )
+                || ( context.globalIDForObject( target ) == null ) )
+                {
+                    DisplayGroupNode parentNode = (DisplayGroupNode) parentGroup;
+                    if ( parentNode.target != null )
+                    {
+                        // only notify if childrenKey is an attribute of parentDesc
+                        //     (and therefore not a toOne or toMany relationship)
+                        EOClassDescription parentDesc =
+                            EOClassDescription.classDescriptionForClass(
+                                parentNode.target.getClass() );
+                        if ( parentDesc.attributeKeys().contains( parentAssociation.childrenKey ) )
+                        {
+                            // only notify if no context is already observing the object
+                            //     and we are an attribute key
+                            EOObserverCenter.notifyObserversObjectWillChange( parentNode.target );
+                        }
+                    }
+                }
+*/
+            }
+            else // root node
+            {
+                setObjectArray( parentAssociation.titlesDisplayGroup.displayedObjects() );
+            }
+
+            // finally, broadcast change event for this node
+            //   even though we're not sure if the displayed value changed.
+            fireNodeChanged();
+        }
+
+        /**
+        * Fires a change event for this node.
+        */
+        public void fireNodeChanged()
+        {
+            // if not root node
+            if ( target != null )
+            {
+                int index = ((DisplayGroupNode)parentGroup).getIndex( this );
+                if ( ( index != -1 )
+                && ( treePath().getParentPath() != null ) )
+                {
+                    fireNodesChanged (
+                    treePath().getParentPath().getPath(),
+                    new int[] { index },
+                    new Object[] { this } );
+                }
+            }
+        }
+
+Object[] previouslyDisplayedObjects = new Object[0];
+        /**
+        * Overridden to call to super, fire any tree events, and then 
+        * call updateDisplayedObjects on all fetched child nodes.
+        * This method compares this node's displayed objects against
+        * the list of child nodes, synchronizes them, and then broadcasts
+        * only the necessary events to bring the view component up to date.
+        */
+        public void updateDisplayedObjects()
+        { 
+//System.out.println( "updateDisplayedObjects: " + " : " + this );
+//net.wotonomy.ui.swing.util.StackTraceInspector.printShortStackTrace();
+//new RuntimeException().printStackTrace();
+            super.updateDisplayedObjects();
+
+            // diff lists
+            boolean proceed = true;
+            Object[] oldObjects = previouslyDisplayedObjects;
+            Object[] newObjects = displayedObjects.toArray();
+            if ( oldObjects.length == newObjects.length )
+            {
+                proceed = false;
+                for ( int i = 0; i < newObjects.length; i++ )
+                {
+                    if ( oldObjects[i] != newObjects[i] )
+                    {
+                        proceed = true;
+                        break;
+                    }
+                }
+            }
+            
+            // this should be set before firing the change events
+            //    in case some clients end up calling this again.
+            previouslyDisplayedObjects = newObjects;
+
+            DisplayGroupNode node;
+            Iterator i = childNodes.values().iterator();
+            while ( i.hasNext() )
+            {
+                node = (DisplayGroupNode) i.next();
+                if ( !node.isFetchNeeded() )
+                {
+                    node.updateDisplayedObjects();
+                }
+            }
+            
+            if ( proceed )
+            {
+//System.out.println( "DisplayGroupNode.firingEventsForChanges: " );                
+//new RuntimeException().printStackTrace();
+                fireEventsForChanges( oldObjects, newObjects );
+            }
+
+        }
+
+        /**
+        * Called by processRecentChanges to analyze the 
+        * differences between the lists and broadcast the
+        * appropriate events.
+        */
+        protected void fireEventsForChanges(
+            Object[] oldObjects, Object[] newObjects )
+        {
+            // structure changed causes havoc while 
+            //  establishing connection in some cases
+            //if ( oldObjects.length == 0 || newObjects.length == 0 )
+            //{
+            //    fireStructureChanged( treePath().getPath(), null, null );
+            //    return;
+            //}           
+            
+            int insertCount = 0;            
+            int deleteCount = 0;            
+            Object[] inserts = new Object[ newObjects.length ]; 
+            Object[] deletes = new Object[ oldObjects.length ]; 
+            
+            int i;
+            int n = -1, o = -1; // last match
+            int n1 = 0, o1 = 0; // current match test
+            int n2 = 0, o2 = 0; // scan ahead
+
+            while ( o1 < oldObjects.length && n1 < newObjects.length )
+            {  
+                if ( newObjects[n1] == oldObjects[o1] )
+                {  
+                    // mark as match and continue
+                    o = o1;
+                    n = n1;
+                }
+                else 
+                {
+                    // scan ahead for the next match, if any
+                    o2 = o1;
+                    n2 = n1;
+
+                    while ( o2 < oldObjects.length || n2 < newObjects.length )
+                    {  
+                        if ( o2 < oldObjects.length && newObjects[n1] == oldObjects[o2] )
+                        {
+                            // run o1 to o2: mark as deletes
+                            for ( i = o1; i < o2; i++ )
+                            { // System.out.println( "delete : " + i );
+                                deletes[i] = oldObjects[i];
+                                deleteCount++;
+                            }
+                            o1 = o2; // reset test
+                            o = o1; // set match
+                            n = n1; // set match
+                            break;
+                        }
+                        if ( n2 < newObjects.length && newObjects[n2] == oldObjects[o1] )
+                        {
+                            // run n1 to n2: mark as inserts
+                            for ( i = n1; i < n2; i++ )
+                            { // System.out.println( "insert : " + i  );
+                                inserts[i] = newObjects[i];
+                                insertCount++;
+                            }
+                            n1 = n2; // reset test
+                            n = n1; // set match
+                            o = o1; // set match
+                            break;
+                        }
+                        o2++;
+                        n2++;
+                    }
+                }
+                if (n != n1)
+                {
+                    inserts[n1] = newObjects[n1];
+                    insertCount++;
+                    deletes[o1] = oldObjects[o1];
+                    deleteCount++;
+                    //increment even though no match:
+                    //the new object was marked as inserted and
+                    //the old object was marked as deleted.
+                    n = n1;
+                    o = o1;
+                }
+                o1++;
+                n1++;
+            }
+            
+            // run o to end of oldObjects: mark as deletes
+            for ( i = o+1; i < oldObjects.length; i++ )
+            { // System.out.println( "delete : " + i  );
+                deletes[i] = oldObjects[i];
+                deleteCount++;
+            }
+        
+            // run n to end of newObjects: mark as inserts
+            for ( i = n+1; i < newObjects.length; i++ )
+            { // System.out.println( "insert : " + i  );
+                inserts[i] = newObjects[i];
+                insertCount++;
+            }
+
+//System.out.println( "done   : " 
+//+ o + " : " + o1 + " : " + o2 + " :: " + n + " : " + n1 + " : " + n2 );
+//System.out.println( new NSArray( newObjects ) );
+//System.out.println( new NSArray( inserts ) );
+//System.out.println( new NSArray( deletes ) );
+//System.out.println( new NSArray( oldObjects ) );
+                
+            int c;
+            Object[] nodes;
+            int[] indices;
+
+            // broadcast delete event
+            c = 0;
+            nodes = new Object[ deleteCount ];
+            indices = new int[ deleteCount ];
+            for ( i = 0; i < deletes.length; i++ )
+            {
+                if ( deletes[i] != null )
+                {
+                    indices[c] = i;
+                    nodes[c] = getChildNodeForObject( deletes[i] );
+                    c++;
+                }
+            }
+            if ( c > 0 )
+            {
+//                fireNodeChanged(); // force the jtree to get the correct child count
+                fireNodesRemoved( treePath().getPath(), indices, nodes );
+            }
+            deletes = nodes; // retain for dispose check
+            
+            // broadcast insert event
+            c = 0;
+            nodes = new Object[ insertCount ];
+            indices = new int[ insertCount ];
+            for ( i = 0; i < inserts.length; i++ )
+            {
+                if ( inserts[i] != null )
+                {
+                    indices[c] = i;
+                    nodes[c] = getChildNodeForObject( inserts[i] );
+                    if ( nodes[c] == null )
+                    {
+                        nodes[c] = createChildNodeForObject( newObjects[i] );
+                    }
+                    c++;
+                }
+            }
+            if ( c > 0 )
+            {
+                fireNodesInserted( treePath().getPath(), indices, nodes );
+            }
+
+            // dispose any delete nodes not on insert list
+            int j;
+            boolean found;
+            for ( i = 0; i < deletes.length; i++ )
+            {
+                for ( j = 0; j < nodes.length; j++ )
+                {
+                    if ( deletes[i] == nodes[j] ) break;
+                }
+                
+                // did not break early, so not found, so dispose
+                if ( j == nodes.length )
+                {
+                    ((DisplayGroupNode)deletes[i]).dispose();
+                }
+            }
+        }
+
+        /**
+        * Sets the target object and creates an registers a target observer.
+        * If target was not previously null, the existing observer is unregistered.
+        * Protected access so subclasses and TreeModelAssociation can update our target.
+        */
+        public void setTarget( Object aTarget )
+        {
+            if ( target != null )
+            {
+                EOObserverCenter.removeObserver( targetObserver, target );
+                targetObserver.discardPendingNotification();
+            }
+
+            if ( aTarget != null )
+            {
+                target = aTarget;
+                targetObserver = new TargetObserver( this );
+                EOObserverCenter.addObserver( targetObserver, target );
+            }
+        }
+
+    /**
+    * Returns the parent display group, or null if parent is root.
+    */
+    public DisplayGroupNode getParentGroup()
+    {
+        if ( parentGroup instanceof DisplayGroupNode )
+        {
+            return (DisplayGroupNode)parentGroup;
+        }
+        // presumably the root node
+        return null;
+    }
+        
+    /**
+    * Gets all descendants of the this node.
+    */
+    public List getDescendants()
+    {
+        return getDescendants( this, true );
+    }
+
+    /**
+    * Gets only the descendants of the this node
+    * whose children has been loaded - no fetching
+    * will occur.  Useful for load-on-demand trees.
+    */
+    public List getLoadedDescendants()
+    {
+        return getDescendants( this, false );
+    }
+
+        // breadth first traversal implementation
+
+    /**
+    * Returns a list of all descendants of the
+    * specified node. Unfetched nodes are traversed
+    * only if forceLoad is true.
+    * This implementation is a breadth-first traversal
+    * of the nodes starting at the specified node.
+    */
+    static private List getDescendants( DisplayGroupNode aNode, boolean forceLoad )
+    {
+        if ( !forceLoad && !aNode.isFetched ) return NSArray.EmptyArray;
+        
+        LinkedList result = new LinkedList();
+        LinkedList queue = new LinkedList();
+
+        queue.add( aNode );
+        while ( ! queue.isEmpty() )
+        {
+            checkNode( (DisplayGroupNode) queue.removeFirst(),
+                queue, result, forceLoad );
+        }
+
+        return result;
+    }
+
+    /**
+    * Adds each fetched child node of the specified node to
+    * the result set (optionally forcing the child node to load)
+    * and adding child node to the end of the queue.
+    */
+    static private void checkNode( DisplayGroupNode aNode,
+        LinkedList aQueue, LinkedList aResult, boolean forceLoad )
+    {
+        DisplayGroupNode child;
+        int count = aNode.getChildCount();
+
+        for ( int i = 0; i < count; i++ )
+        {
+            child = aNode.getChildNodeAt( i );
+
+            // add to queue if node has fetched children
+            if ( ( !child.isFetched ) && ( forceLoad ) )
+            {
+                child.fetch();
+            }
+            if ( child.isFetched )
+            {
+                aQueue.addLast( child );
+            }
+
+            aResult.add( child );
+        }
+    }
+
+    /**
+    * Overridden to not fetch on InvalidateAllObjectsInStoreNotification
+    * unless we've already been fetched, preserving the load-on-demand
+    * functionality.
+    */
+    public void objectsInvalidatedInEditingContext( NSNotification aNotification )
+    {
+        if ( EOObjectStore.InvalidatedAllObjectsInStoreNotification
+            .equals( aNotification.name() ) )
+        {
+//System.out.println( "DisplayGroupNode.objectsInvalidatedInEditingContext: " + aNotification.name() );        
+                if ( parentAssociation.isVisible( this ) && targetObserver != null ) 
+                {
+                    targetObserver.objectWillChange( target ); // force ui to update
+                    fireNodeChanged();
+                }
+                else // make sure we fetch children when we do become visible
+                    setFetchNeeded( true ); 
+                return;
+        }
+        else
+        if ( ( EOEditingContext.ObjectsChangedInEditingContextNotification
+            .equals( aNotification.name() ) )
+        ||   ( EOEditingContext.EditingContextDidSaveChangesNotification
+            .equals( aNotification.name() ) ) )
+        {
+            int index;
+            Enumeration e;
+            boolean didChange = false;
+            NSDictionary userInfo = aNotification.userInfo();
+
+            // if our target object was deleted
+            NSArray deletes = (NSArray) userInfo.objectForKey(
+                EOObjectStore.DeletedKey );
+            if ( deletes.indexOfIdenticalObject( target ) != NSArray.NotFound )
+            {
+//System.out.println( "DisplayGroupNode.objectsInvalidatedInEditingContext: delete: " + this + " : " + aNotification.name() );        
+                if ( parentAssociation.isVisible( this ) && targetObserver != null ) 
+                {
+                    targetObserver.objectWillChange( target ); // force ui to update
+                    fireNodeChanged();
+                }
+                else // make sure we fetch children when we do become visible
+                    setFetchNeeded( true ); 
+                return;
+            }
+
+            // if our target object was invalidated
+            NSArray invalidates = (NSArray) userInfo.objectForKey(
+                EOObjectStore.InvalidatedKey );
+            if ( invalidates != null &&
+                 invalidates.indexOfIdenticalObject( target ) != NSArray.NotFound )
+            {
+//System.out.println( "DisplayGroupNode.objectsInvalidatedInEditingContext: invalidate: " + this + " : " + aNotification.name() );        
+                if ( parentAssociation.isVisible( this ) && targetObserver != null ) 
+                {
+                    targetObserver.objectWillChange( target ); // force ui to update
+                    fireNodeChanged();
+                }
+                else // make sure we fetch children when we do become visible
+                    setFetchNeeded( true ); 
+                return;
+            }
+            
+            // if our target object was updated, set fetchNeeded plus fire changed event
+            NSArray updates = (NSArray) userInfo.objectForKey(
+                EOObjectStore.UpdatedKey );
+            if ( updates.indexOfIdenticalObject( target ) != NSArray.NotFound )
+            {
+                if ( parentAssociation.isVisible( this ) && targetObserver != null ) 
+                {
+                    targetObserver.objectWillChange( target ); // force ui to update
+                    fireNodeChanged();
+                    if ( object() instanceof Component ) ((Component)object()).repaint();
+                }
+                else // make sure we fetch children when we do become visible
+                    setFetchNeeded( true ); 
+                return;
+            }
+        }
+
+        super.objectsInvalidatedInEditingContext( aNotification );
+
+    }
+
+    // inner classes
+
+    /**
+    * Private class used to force a hashmap to
+    * perform key comparisons by reference.
+    */
+    private class ReferenceKey
+    {
+        private int hashCode;
+        private Object referent;
+
+        public ReferenceKey( Object anObject )
+        {
+            referent = anObject;
+            hashCode = anObject.hashCode();
+        }
+
+        /**
+        * Returns the actual key's hash code.
+        */
+        public int hashCode()
+        {
+            return hashCode;
+        }
+
+        /**
+        * Compares by reference.
+        */
+        public boolean equals( Object anObject )
+        {
+            if ( anObject instanceof ReferenceKey )
+            {
+                return ((ReferenceKey)anObject).referent == referent;
+            }
+            return false;
+        }
+    }
+
+    /**
+    * A private class to observe the target object of this node.
+    */
+    private class TargetObserver extends EODelayedObserver
+    {
+        Reference ref;
+
+        /**
+        * Pass in the display group node that will be updated
+        * when the target changes.
+        */
+        public TargetObserver( DisplayGroupNode aDisplayGroup )
+        {
+            ref = new WeakReference( aDisplayGroup );
+        }
+
+        /**
+        * Repopulate our display group, and calculate the deltas
+        * so we can broadcast appropriate events.
+        */
+        public void subjectChanged ()
+        {
+            DisplayGroupNode node = (DisplayGroupNode) ref.get();
+            if ( node == null ) return; // node is null if gc'd.
+            //FIXME: should un-register self from observer center??
+
+            node.targetChanged();
+        }
+    }
+
+}
+/*
+ * $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.64  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.63  2003/06/06 14:20:07  mpowers
+ * getLoadedDescendants was forcing a fetch of the node it was called on.
+ *
+ * Revision 1.62  2003/06/03 14:48:33  mpowers
+ * Clean-up of notification handling for updates/invalidation/etc.
+ * Now fetching immediately on notification if the node is visible.
+ * This averts the infamous IndexOutOfBoundsException that occurs
+ * if fetching happens during repaint, because the BasicTreeUI is
+ * caching the number of child nodes before painting begins.
+ *
+ * Revision 1.61  2003/01/18 23:33:29  mpowers
+ * Fixing the build.
+ *
+ * Revision 1.60  2002/05/31 15:03:10  mpowers
+ * Fixes for the previous fix.  Fat props to yjcheung.
+ *
+ * Revision 1.59  2002/05/28 15:31:36  mpowers
+ * Fix for updateDisplayedObjects for a subtle case where a node appears in
+ * the position that another node was moved from.
+ *
+ * Revision 1.58  2002/05/24 14:42:02  mpowers
+ * Prevent repeat events from firing if firing events loops back.
+ *
+ * Revision 1.57  2002/04/23 19:12:28  mpowers
+ * Reimplemented fireEventsForChanges.  Fitter and happier.
+ *
+ * Revision 1.56  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.55  2002/04/19 20:53:22  mpowers
+ * Now firing event fewer events in fireEventsForChanges.
+ *
+ * Revision 1.54  2002/04/15 21:52:50  mpowers
+ * Tightening up TreeModelAssociation and DisplayGroupNode.
+ * Now only firing root structure changed once.
+ * Now disposing of root's children.
+ * Better event coalescing.
+ *
+ * Revision 1.53  2002/04/12 20:35:20  mpowers
+ * Now correctly setting parent display group and data source on creation.
+ *
+ * Revision 1.52  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.51  2002/04/03 20:13:36  mpowers
+ * Now differentiating between node instantiation caused by model expansion
+ * (user initiated) and by modifications to the model.
+ * Dispose now disposes all children.
+ *
+ * Revision 1.50  2002/03/23 16:20:27  mpowers
+ * Optimized processRecentChanges, minimized tree events.
+ *
+ * Revision 1.49  2002/03/11 03:15:06  mpowers
+ * Optimized processRecentChanges, minimize event firing, coalescing changes.
+ * Still need a better diff algorithm to avoid removing nodes.
+ *
+ * Revision 1.48  2002/03/10 00:59:39  mpowers
+ * Interim version: coalesces calls to process recent changes.
+ * Still does not handle rearranged nodes.
+ *
+ * Revision 1.47  2002/03/09 17:33:45  mpowers
+ * Nodes now track their child nodes by reference, not index.
+ *
+ * Revision 1.46  2002/03/08 23:19:07  mpowers
+ * Added getParentGroup to DisplayGroupNode.
+ *
+ * Revision 1.45  2002/03/06 13:04:16  mpowers
+ * Implemented cascading qualifiers in tree nodes.
+ *
+ * Revision 1.44  2002/02/27 23:19:17  mpowers
+ * Refactoring of TreeAssociation to create TreeModelAssociation parent.
+ *
+ * Revision 1.42  2002/02/19 22:28:46  mpowers
+ * DisplayGroupNodes immediately unregister themselves as editors.
+ *
+ * Revision 1.41  2002/02/13 16:27:38  mpowers
+ * Exposing setTarget.
+ *
+ * Revision 1.40  2001/11/02 20:55:46  mpowers
+ * Now using fixed index to send node removed events.  This preserves the
+ * expanded state of the nodes in the corresponding jtree.
+ *
+ * Revision 1.39  2001/09/21 21:09:25  mpowers
+ * Exposed more fields as protected.
+ *
+ * Revision 1.38  2001/09/19 15:36:08  mpowers
+ * Refined behavior for isFetched after notification handling.
+ *
+ * Revision 1.37  2001/09/13 14:51:18  mpowers
+ * DisplayGroupNodes now dispose themselves and mark their parent for update
+ * when they receive notification that their target has been deleted.
+ *
+ * Revision 1.36  2001/09/10 14:10:24  mpowers
+ * Fix for notification handling.
+ *
+ * Revision 1.35  2001/07/30 16:17:01  mpowers
+ * Minor code cleanup.
+ *
+ * Revision 1.34  2001/07/18 22:13:39  mpowers
+ * getLoadedDescendants now works as advertised.
+ * Now correctly handling invalidateAllObjects notification.
+ *
+ * Revision 1.33  2001/07/18 13:03:32  mpowers
+ * TreeNodes now refetch only on demand.  Previously, once a node had
+ * been fetched, it was always refetched after an invalidate, even if
+ * the node was not being displayed.
+ *
+ * Revision 1.32  2001/06/18 14:10:28  mpowers
+ * Cleaned up event firing: no longer firing insert or remove events twice.
+ *
+ * Revision 1.31  2001/06/09 16:15:39  mpowers
+ * Revised the targetChanged scheme because oldObjects and newObjects were
+ * identical after the target object is invalidated.
+ *
+ * Revision 1.30  2001/05/21 22:17:19  mpowers
+ * Fix for tree out-of-synch problems when nodes are inserted.
+ *
+ * Revision 1.29  2001/05/18 21:07:46  mpowers
+ * Playing with refresh options.
+ *
+ * Revision 1.28  2001/05/14 15:25:43  mpowers
+ * DisplayGroupNodes now only respond to InvalidateAllObjectsInStore
+ * if they are already fetched.
+ *
+ * Revision 1.27  2001/05/08 19:55:58  mpowers
+ * Fix for node children not refreshing after sibling was inserted.
+ *
+ * Revision 1.26  2001/05/08 18:47:34  mpowers
+ * Minor fixes for d3.
+ *
+ * Revision 1.25  2001/05/06 22:22:55  mpowers
+ * Debugging.
+ *
+ * Revision 1.24  2001/05/04 14:42:58  mpowers
+ * Now getting stored values in KeyValueCoding.
+ * MasterDetail now marks dirty based on whether it's an attribute
+ * or relation.
+ * Implemented editing context marker.
+ *
+ * Revision 1.23  2001/05/02 18:00:43  mpowers
+ * Removed debug code.
+ *
+ * Revision 1.22  2001/05/02 17:31:20  mpowers
+ * DisplayGroupNode now does a better job determining when to mark its
+ * parent dirty.
+ *
+ * Revision 1.21  2001/05/01 00:52:32  mpowers
+ * Implemented breadth-first traversal of tree for node.
+ *
+ * Revision 1.20  2001/04/26 01:15:19  mpowers
+ * Major clean-up of DisplayGroupNode: fitter, happier, more productive.
+ *
+ * Revision 1.19  2001/04/22 23:13:35  mpowers
+ * Minor bug.
+ *
+ * Revision 1.18  2001/04/22 23:05:33  mpowers
+ * Totally revised DisplayGroupNode so each object gets its own node
+ * (so the nodes are no longer fixed by index).
+ *
+ * Revision 1.17  2001/04/21 23:05:12  mpowers
+ * A fairly major revisiting.  I've decided to scrap the pass-thru approach
+ * where every node simply represents an index and not an object.
+ * The next update will have each node correspond to a specific object.
+ *
+ * Revision 1.16  2001/04/13 16:37:37  mpowers
+ * Handling bounds checking.
+ *
+ * Revision 1.15  2001/04/03 20:36:01  mpowers
+ * Fixed refaulting/reverting/invalidating to be self-consistent.
+ *
+ * Revision 1.14  2001/03/27 17:45:51  mpowers
+ * More index bounds checking.
+ *
+ * Revision 1.13  2001/03/22 21:25:42  mpowers
+ * Fixed some nasty issues with jtree's internal state and array bounds.
+ *
+ * Revision 1.12  2001/03/19 22:18:58  mpowers
+ * Root node now mirrors contents of titles display group.
+ *
+ * Revision 1.11  2001/03/19 21:38:36  mpowers
+ * Improved redisplay after edit.  Editing nodes off root now works.
+ *
+ * Revision 1.10  2001/03/09 22:08:38  mpowers
+ * Removed unused line.
+ *
+ * Revision 1.9  2001/03/07 16:41:04  mpowers
+ * Now checking size of parent displayed objects array so that we don't
+ * get array out of bounds execeptions from isLeaf() or object() when
+ * those messages are called after the TreeAssociation fires a
+ * nodesDeleted event.  I believe that JTree is mistakenly rendering
+ * those nodes one last time before erasing them.
+ *
+ * Revision 1.8  2001/03/06 23:21:27  mpowers
+ * Now only notifying parent if the object is not registered in the
+ * editing context, if any.
+ *
+ * Revision 1.7  2001/02/20 16:38:55  mpowers
+ * MasterDetailAssociations now observe their controlled display group's
+ * objects for changes to that the parent object will be marked as updated.
+ * Before, only inserts and deletes to an object's items are registered.
+ * Also, moved ObservableArray to package access.
+ *
+ * Revision 1.6  2001/02/17 16:52:05  mpowers
+ * Changes in imports to support building with jdk1.1 collections.
+ *
+ * Revision 1.5  2001/01/31 17:59:52  mpowers
+ * Fixed isLeaf aspect of TreeAssociation.
+ *
+ * Revision 1.4  2001/01/25 02:16:25  mpowers
+ * TreeAssociation now returns DisplayGroupNode.getUserObject.
+ *
+ * Revision 1.3  2001/01/24 18:14:40  mpowers
+ * Fixed problem with leaving children aspect unspecified.
+ *
+ * Revision 1.2  2001/01/24 16:35:37  mpowers
+ * Improved documentation on TreeAssociation.
+ * SortOrderings are now inherited from parent nodes.
+ * Updates after sorting are still lost on TreeController.
+ *
+ * Revision 1.1  2001/01/24 14:17:12  mpowers
+ * Major revision to TreeAssociation.  Can now add and remove nodes.
+ * DisplayGroupNode is now it's own class.
+ *
+ *
+ */
+