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