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