Initial import from SVN

10 files changed, 5062 insertions, 0 deletions

diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DebuggingDelegate.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DebuggingDelegate.java
new file mode 100644
index 0000000..8e9fae2
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DebuggingDelegate.java
@@ -0,0 +1,333 @@
+/*
+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;
+
+import java.util.List;
+
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSNotification;
+
+    /**
+    * A display group delegate that prints messages for each
+    * of the delegate methods.
+    *
+    * @author michael@mpowers.net
+    * @author $Author: cgruber $
+    * @version $Revision: 904 $
+    */
+    public class DebuggingDelegate implements EODisplayGroup.Delegate
+    {
+        /**
+        * Called when the specified data source fails
+        * to create an object for the specified display group.
+        */
+		public void displayGroupCreateObjectFailed ( 
+			EODisplayGroup aDisplayGroup,
+			EODataSource aDataSource )
+        {
+            report( "displayGroupCreateObjectFailed", 
+                aDisplayGroup,
+                new Object[] { aDataSource } );
+        }
+
+        /**
+		* Called after the specified display group's
+		* data source is changed.
+		*/
+		public void displayGroupDidChangeDataSource ( 
+			EODisplayGroup aDisplayGroup )
+        {
+            report( "displayGroupDidChangeDataSource", 
+                aDisplayGroup, 
+                new Object[] { } );
+        }
+
+		/**
+		* Called after the specified display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidChangeSelectedObjects ( 
+			EODisplayGroup aDisplayGroup )
+        {
+            report( "displayGroupDidChangeSelectedObjects", 
+                aDisplayGroup, 
+                new Object[] { } );
+        }
+
+		/**
+		* Called after the specified display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidChangeSelection ( 
+			EODisplayGroup aDisplayGroup )
+        {
+            report( "displayGroupDidChangeSelection", 
+                aDisplayGroup, 
+                new Object[] { } );
+        }
+
+		/**
+		* Called after the specified object display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidDeleteObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+            report( "displayGroupDidDeleteObject", 
+                aDisplayGroup, 
+                new Object[] { anObject } );
+        }
+
+		/**
+		* Called after the specified display group
+		* has fetched the specified object list.
+		*/
+		public void displayGroupDidFetchObjects ( 
+			EODisplayGroup aDisplayGroup,
+			List anObjectList )
+        {
+            report( "displayGroupDidFetchObjects", 
+                aDisplayGroup, 
+                new Object[] { anObjectList } );
+        }
+
+		/**
+		* Called after the specified display group
+		* has inserted the specified object into
+		* its internal object list.
+		*/
+		public void displayGroupDidInsertObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+            report( "displayGroupDidInsertObject", 
+                aDisplayGroup, 
+                new Object[] { anObject } );
+        }
+
+		/**
+		* Called after the specified display group
+		* has set the specified value for the specified
+		* object and key.
+		*/
+		public void displayGroupDidSetValueForObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object aValue,
+			Object anObject,
+			String aKey )
+        {
+            report( "displayGroupDidSetValueForObject", 
+                aDisplayGroup, 
+                new Object[] { aValue, anObject, aKey } );
+        }
+
+		/**
+		* Called by the specified display group to
+		* determine what objects should be displayed
+		* for the objects in the specified list.
+		* @return An NSArray containing the objects
+		* to be displayed for the objects in the 
+		* specified list.
+		*/
+		public NSArray displayGroupDisplayArrayForObjects ( 
+			EODisplayGroup aDisplayGroup,
+			List aList )
+        {
+            return get( "displayGroupDisplayArrayForObjects", 
+                aDisplayGroup, 
+                aList );
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to change the selection.
+        * This implementation returns true.
+		* @return True to allow the selection to change,
+		* false otherwise.
+		*/
+		public boolean displayGroupShouldChangeSelection ( 
+			EODisplayGroup aDisplayGroup,
+			List aSelectionList )
+        {
+            return ask( "displayGroupShouldChangeSelection", 
+                aDisplayGroup, 
+                new Object[] { aSelectionList } );
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to delete the specified object.
+        * This implementation returns true.
+		* @return True to allow the object to be deleted
+		* false to prevent the deletion.
+		*/
+		public boolean displayGroupShouldDeleteObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+            return ask( "displayGroupShouldDeleteObject", 
+                aDisplayGroup, 
+                new Object[] { anObject } );
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts display the specified alert to
+		* the user.
+        * This implementation returns true.
+		* @return True to allow the message to be 
+		* displayed, false if you want to handle the
+		* alert yourself and suppress the display group's
+		* notification.
+		*/
+		public boolean displayGroupShouldDisplayAlert ( 
+			EODisplayGroup aDisplayGroup,
+			String aTitle,
+			String aMessage )
+        {
+            return ask( "displayGroupShouldDisplayAlert", 
+                aDisplayGroup, 
+                new Object[] { aTitle, aMessage } );
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts fetch objects.
+        * This implementation returns true.
+		* @return True to allow the fetch to take place,
+		* false to prevent the fetch.
+		*/
+		public boolean displayGroupShouldFetch ( 
+			EODisplayGroup aDisplayGroup )
+        {
+            return ask( "displayGroupShouldFetch", 
+                aDisplayGroup, 
+                new Object[] {  } );
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to insert the specified object.
+        * This implementation returns true.
+		* @return True to allow the object to be inserted
+		* false to prevent the insertion.
+		*/
+		public boolean displayGroupShouldInsertObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject,
+			int anIndex )
+        {
+            return ask( "displayGroupShouldInsertObject", 
+                aDisplayGroup, 
+                new Object[] { anObject, new Integer( anIndex ) } );
+        }
+
+		/**
+		* No idea what this might indicate,
+		* nor what the notification indicates.
+        * This implementation returns true.
+		*/
+		public boolean displayGroupShouldRedisplay ( 
+			EODisplayGroup aDisplayGroup,
+			NSNotification aNotification )
+        {
+            return ask( "displayGroupShouldRedisplay", 
+                aDisplayGroup, 
+                new Object[] { aNotification } );
+        }
+
+		/**
+		* No idea what this might indicate,
+		* nor what the notification indicates.
+		*/
+		public boolean displayGroupShouldRefetch ( 
+			EODisplayGroup aDisplayGroup,
+			NSNotification aNotification )
+        {
+            return ask( "displayGroupShouldRefetch", 
+                aDisplayGroup, 
+                new Object[] { aNotification } );
+        }
+        
+		/**
+        * This method is called by all delegate methods that
+        * return void.
+		* This implementation calls System.out.println.
+        * Override to customize or replace the output.
+		*/
+        protected void report( String aTitle, 
+            EODisplayGroup aDisplayGroup,
+            Object[] aParameterArray )
+        {
+            String result = aTitle + " : " + aDisplayGroup;
+            for ( int i = 0; i < aParameterArray.length; i++ )
+            {   
+                result += " : " + aParameterArray[i];
+            }
+            System.out.println( result );
+        }
+        
+		/**
+        * This method is called by displayGroupDisplayArrayForObjects.
+		* This implementation calls report
+        * and returns a copy of the specified list.
+		*/
+        protected NSArray get( String aTitle, 
+            EODisplayGroup aDisplayGroup,
+            List anObjectList )
+        {
+            report( aTitle, aDisplayGroup, new Object[] { anObjectList } );
+            return new NSArray( anObjectList );
+        }
+        
+		/**
+        * This method is called by the methods that 
+        * return a boolean.
+		* This implementation calls report and return true.
+		*/
+        protected boolean ask( String aTitle, 
+            EODisplayGroup aDisplayGroup,
+            Object[] aParameterArray )
+        {
+            report( aTitle, aDisplayGroup, aParameterArray );
+            return true;
+        }
+        
+        
+    }
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.2  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.1  2001/01/24 14:37:24  mpowers
+ * Contributing a delegate useful for debugging.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DelegateAdapter.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DelegateAdapter.java
new file mode 100644
index 0000000..ed572f4
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DelegateAdapter.java
@@ -0,0 +1,257 @@
+/*
+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;
+
+import java.util.List;
+
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSNotification;
+
+    /**
+    * A convenience class for creating display group delegates.
+    * All methods of the delegate interface are implemented
+    * to do nothing.
+    *
+    * @author michael@mpowers.net
+    * @author $Author: cgruber $
+    * @version $Revision: 904 $
+    */
+    public class DelegateAdapter implements EODisplayGroup.Delegate
+    {
+        /**
+        * Called when the specified data source fails
+        * to create an object for the specified display group.
+        */
+		public void displayGroupCreateObjectFailed ( 
+			EODisplayGroup aDisplayGroup,
+			EODataSource aDataSource )
+        {
+                        
+        }
+
+        /**
+		* Called after the specified display group's
+		* data source is changed.
+		*/
+		public void displayGroupDidChangeDataSource ( 
+			EODisplayGroup aDisplayGroup )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidChangeSelectedObjects ( 
+			EODisplayGroup aDisplayGroup )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidChangeSelection ( 
+			EODisplayGroup aDisplayGroup )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified object display group's
+		* selection has changed.
+		*/
+		public void displayGroupDidDeleteObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified display group
+		* has fetched the specified object list.
+		*/
+		public void displayGroupDidFetchObjects ( 
+			EODisplayGroup aDisplayGroup,
+			List anObjectList )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified display group
+		* has inserted the specified object into
+		* its internal object list.
+		*/
+		public void displayGroupDidInsertObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+                        
+        }
+
+		/**
+		* Called after the specified display group
+		* has set the specified value for the specified
+		* object and key.
+		*/
+		public void displayGroupDidSetValueForObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object aValue,
+			Object anObject,
+			String aKey )
+        {
+                        
+        }
+
+		/**
+		* Called by the specified display group to
+		* determine what objects should be displayed
+		* for the objects in the specified list.
+		* @return An NSArray containing the objects
+		* to be displayed for the objects in the 
+		* specified list.
+		*/
+		public NSArray displayGroupDisplayArrayForObjects ( 
+			EODisplayGroup aDisplayGroup,
+			List aList )
+        {
+            return new NSArray( aList );                
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to change the selection.
+        * This implementation returns true.
+		* @return True to allow the selection to change,
+		* false otherwise.
+		*/
+		public boolean displayGroupShouldChangeSelection ( 
+			EODisplayGroup aDisplayGroup,
+			List aSelectionList )
+        {
+            return true;
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to delete the specified object.
+        * This implementation returns true.
+		* @return True to allow the object to be deleted
+		* false to prevent the deletion.
+		*/
+		public boolean displayGroupShouldDeleteObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject )
+        {
+            return true;
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts display the specified alert to
+		* the user.
+        * This implementation returns true.
+		* @return True to allow the message to be 
+		* displayed, false if you want to handle the
+		* alert yourself and suppress the display group's
+		* notification.
+		*/
+		public boolean displayGroupShouldDisplayAlert ( 
+			EODisplayGroup aDisplayGroup,
+			String aTitle,
+			String aMessage )
+        {
+            return true;
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts fetch objects.
+        * This implementation returns true.
+		* @return True to allow the fetch to take place,
+		* false to prevent the fetch.
+		*/
+		public boolean displayGroupShouldFetch ( 
+			EODisplayGroup aDisplayGroup )
+        {
+            return true;
+        }
+
+		/**
+		* Called by the specified display group before
+		* it attempts to insert the specified object.
+        * This implementation returns true.
+		* @return True to allow the object to be inserted
+		* false to prevent the insertion.
+		*/
+		public boolean displayGroupShouldInsertObject ( 
+			EODisplayGroup aDisplayGroup,
+			Object anObject,
+			int anIndex )
+        {
+            return true;
+        }
+
+		/**
+		* No idea what this might indicate,
+		* nor what the notification indicates.
+        * This implementation returns true.
+		*/
+		public boolean displayGroupShouldRedisplay ( 
+			EODisplayGroup aDisplayGroup,
+			NSNotification aNotification )
+        {
+            return true;
+        }
+
+		/**
+		* No idea what this might indicate,
+		* nor what the notification indicates.
+		*/
+		public boolean displayGroupShouldRefetch ( 
+			EODisplayGroup aDisplayGroup,
+			NSNotification aNotification )
+        {
+            return true;
+        }
+        
+    }
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.2  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.1  2001/01/24 14:23:17  mpowers
+ * Contributing DelegateAdapter.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DisplayGroup.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DisplayGroup.java
new file mode 100644
index 0000000..9fcbe34
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/DisplayGroup.java
@@ -0,0 +1,300 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+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;
+
+import java.util.List;
+import java.util.Map;
+
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.control.EOQualifier;
+
+/**
+* DisplayGroup provides an abstraction of a user interface,
+* comprising of an ordered collection of data objects, some
+* of which are displayed, and of those some are selected.
+* This class extends EODisplayGroup to provide java-friendly
+* convenience methods.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class DisplayGroup extends EODisplayGroup
+{
+    /**
+    * Returns the current data source backing this display group,
+    * or null if no dataSource is currently used.
+    */
+    public EODataSource getDataSource()
+    {
+        return super.dataSource();
+    }
+
+   /**
+    * Returns the current delegate for this display group,
+    * or null if no delegate is currently set.
+    */
+    public Object getDelegate()
+    {
+        return delegate();
+    }
+
+    /**
+    * Returns the current string matching format.
+    * If not set, defaults to "%@*".
+    */
+    public String getDefaultStringMatchFormat()
+    {
+        return defaultStringMatchFormat();
+    }
+
+    /**
+    * Returns the current string matching operator.
+    * If not set, defaults to "caseInsensitiveLike".
+    */
+    public String getdefaultStringMatchOperator()
+    {
+        return defaultStringMatchOperator();
+    }
+
+    /**
+    * Returns a Map of default values that are applied
+    * to new objects that are inserted into the list.
+    */
+    public Map getInsertedObjectDefaultValues()
+    {
+        return insertedObjectDefaultValues();
+    }
+
+    /**
+    * Returns the keys that were declared when read from
+    * an external resource file.
+    */
+    public List getLocalKeys()
+    {
+        return localKeys();
+    }
+
+    /**
+    * Returns the List of sort orderings for this display group.
+    */
+    public List getSortOrderings ()
+    {
+        return sortOrderings();
+    }
+
+    /**
+    * Returns a qualifier that will be applied all the objects
+    * in this display group to determine which objects will
+    * be displayed.
+    */
+    public EOQualifier getQualifier ()
+    {
+        return qualifier();
+    }
+
+    /**
+    * Returns a new qualifier built from the three query
+    * value maps: greater than, equal to, and less than.
+    */
+    public EOQualifier getQualifierFromQueryValues ()
+    {
+        return qualifierFromQueryValues();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to binding query values.
+    */
+    public Map getQueryBindingValues()
+    {
+        return queryBindingValues();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to operator values.
+    */
+    public Map getQueryOperatorValues()
+    {
+        return queryOperatorValues();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for equality.
+    */
+    public Map getEqualToQueryValues()
+    {
+        return equalToQueryValues();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for greater value.
+    */
+    public Map getGreaterThanQueryValues()
+    {
+        return greaterThanQueryValues();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for lesser value.
+    */
+    public Map getLessThanQueryValues()
+    {
+        return lessThanQueryValues();
+    }
+
+    /**
+    * Returns the association that is currently being edited,
+    * or null if no editing is taking place.
+    */
+    public EOAssociation getEditingAssociation ()
+    {
+        return editingAssociation();
+    }
+
+    /**
+    * Returns a List of associations that are observing
+    * this display group.
+    */
+    public List getObservingAssociations()
+    {
+        return observingAssociations();
+    }
+
+    /**
+    * Returns a List containing all objects managed by the display group.
+    * This includes those objects not visible due to disqualification.
+    */
+    public List getAllObjects()
+    {
+        return allObjects();
+    }
+
+    /**
+    * Returns a List of all objects in the display group
+    * that are currently displayed by the associations.
+    * The list is a copy of the internal displayed object list.
+    */
+    public List getDisplayedObjects()
+    {
+        return displayedObjects();
+    }
+
+    /**
+    * Returns the currently selected object, or null if
+    * there is no selection.
+    */
+    public Object getSelectedObject()
+    {
+        return selectedObject();
+    }
+
+    /**
+    * Returns a List containing all selected objects, if any.
+    * Returns an empty list if no objects are selected.
+    */
+    public List getSelectedObjects()
+    {
+        return selectedObjects();
+    }
+
+    /**
+    * Returns a List containing the indexes of all selected
+    * objects, if any.  The list contains instances of
+    * java.lang.Number; call intValue() retrieve the index.
+    */
+    public List getSelectionIndexes()
+    {
+        return selectionIndexes();
+    }
+
+    /**
+    * Returns the index of the changed object.  If more than
+    * one object has changed, -1 is returned.
+    */
+    public int getUpdatedObjectIndex()
+    {
+        return updatedObjectIndex();
+    }
+
+    /**
+    * Returns a value on the selected object for the specified key.
+    */
+    public Object getSelectedObjectValueForKey ( String aKey )
+    {
+        return selectedObjectValueForKey( aKey );
+    }
+
+    /**
+    * Returns the value for the specified key on the specified object.
+    */
+    public Object getValueForObject ( Object anObject, String aKey )
+    {
+        return valueForObject( anObject, aKey );
+    }
+
+    /**
+    * Calls valueForObject() for the object at the specified index.
+    */
+    public Object getValueForObjectAtIndex ( int anIndex, String aKey )
+    {
+        return valueForObjectAtIndex( anIndex, aKey );
+    }
+
+    /**
+    * Specifies the default string matching format for all
+    * display groups.
+    */
+    public static String getGlobalDefaultStringMatchFormat ()
+    {
+        return globalDefaultStringMatchFormat();
+    }
+
+    /**
+    * Specifies the default string matching operator for all
+    * display groups.
+    */
+    public static String getGlobalDefaultStringMatchOperator ()
+    {
+        return globalDefaultStringMatchOperator();
+    }
+}    
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.2  2002/05/17 15:01:49  mpowers
+ * Implemented dynamic lookup of delegate methods so delegates no longer
+ * need to implement the DisplayGroup.Delegate interface.
+ *
+ * Revision 1.1  2002/03/26 21:24:43  mpowers
+ * Contributing DisplayGroup as convenience for people coming from java.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EOAssociation.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EOAssociation.java
new file mode 100644
index 0000000..635c5b9
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EOAssociation.java
@@ -0,0 +1,565 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+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;
+
+import java.util.Enumeration;
+
+import net.wotonomy.control.EODelayedObserver;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.foundation.NSMutableDictionary;
+
+/**
+* Associations observe DisplayGroups and associate
+* a user interface component with one or more keys 
+* on the objects in the display group. <br><br>
+*
+* Associations are created with a ui component in
+* the constructor.  Then, one or more aspects are
+* bound to display groups and/or property keys with
+* the bindAspect() method.   Finally, the association
+* is initialized with the establishConnection() 
+* method. <br><br>
+*
+* Per the openstep convention, you do not need to 
+* retain a reference to the association after it is 
+* created; the association will be garbage-collected
+* when the ui component is garbage-collected. <br><br> 
+*
+* (Because java components don't have delegates like
+* openstep components do, java-based associations 
+* will likely need to implement some sort of listener
+* and add itself to the component's list of listeners
+* so that the component will have a strong reference
+* (and the only reference) to the association.) <br><br>
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class EOAssociation extends EODelayedObserver
+{
+	// aspect constants 
+	public static final String ActionAspect = "action";
+	public static final String EnabledAspect = "enabled";
+	public static final String SourceAspect = "source";
+	public static final String ArgumentAspect = "argument";
+	public static final String ParentAspect = "parent";
+	public static final String TitlesAspect = "titles";
+	public static final String BoldAspect = "bold";
+	public static final String SelectedObjectAspect = "selectedObject";
+	public static final String ValueAspect = "value";
+	public static final String DestinationAspect = "destination";
+	public static final String SelectedTitleAspect = "selectedTitle";
+	public static final String URLAspect = "URL";
+	public static final String ItalicAspect = "italic";
+	public static final String ChildrenAspect = "children"; // not in spec
+	public static final String IsLeafAspect = "isLeaf"; // not in spec
+	public static final String EditableAspect = "editable"; // not in spec
+	public static final String VisibleAspect = "visible"; // not in spec
+	public static final String ObjectsAspect = "objects"; // not in spec
+	public static final String LabelAspect = "label"; // not in spec
+	public static final String IconAspect = "icon"; // not in spec
+		
+	public static final String AttributeAspectSignature = "A";
+	public static final String NullAspectSignature = "";
+	public static final String AttributeToOneAspectSignature = "A1"; 
+	public static final String ToOneAspectSignature = "1";
+	public static final String AttributeToOneToManyAspectSignature = "A1M"; 
+	public static final String ToOneToManyAspectSignature = "1M";
+	public static final String AttributeToManyAspectSignature = "AM";
+	public static final String ToManyAspectSignature = "M";
+		
+    protected Object control;
+    protected NSMutableDictionary aspectToGroup;
+    protected NSMutableDictionary aspectToKey;
+
+    /**
+    * Default constructor.
+    */ 
+    public EOAssociation ()
+    {
+        aspectToGroup = new NSMutableDictionary();
+        aspectToKey = new NSMutableDictionary();
+        control = null;
+    }
+    
+    /**
+    * Constructor specifying the object to be controlled by this
+    * association.  Does not establish connection.
+    */
+    public EOAssociation ( Object anObject )
+    {
+        this();
+        control = anObject;
+    }
+    
+    /**
+    * Returns a List of aspect signatures whose contents
+    * correspond with the aspects list.  Each element is 
+    * a string whose characters represent a capability of
+    * the corresponding aspect. <ul>
+    * <li>"A" attribute: the aspect can be bound to
+    * an attribute.</li>
+    * <li>"1" to-one: the aspect can be bound to a
+    * property that returns a single object.</li>
+    * <li>"M" to-one: the aspect can be bound to a
+    * property that returns multiple objects.</li>
+    * </ul> 
+    * An empty signature "" means that the aspect can
+    * bind without needing a key.
+    * This implementation returns "A1M" for each
+    * element in the aspects array.
+    */
+    public static NSArray aspectSignatures ()
+    {
+        int size = aspects().count();
+        NSMutableArray result = new NSMutableArray();
+        for ( int i = 0; i < size; i++ )
+        {
+            result.addObject( AttributeToOneToManyAspectSignature );
+        }
+        return result;
+    }
+    
+    /**
+    * Returns a List that describes the aspects supported
+    * by this class.  Each element in the list is the string
+    * name of the aspect.  This implementation returns an
+    * empty list.
+    * 
+    * TODO: Is this static in the WebObjects published API? If not, fix.
+    */
+    public static NSArray aspects ()
+    {
+        return new NSArray();
+    }
+    
+    /**
+    * Returns all registered subclasses of EOAssociation 
+    * for which usableWithObject with the specified object
+    * returns true.  You should only call this method on 
+    * the EOAssociation class.
+    */
+    public static NSArray associationClassesForObject ( 
+        Object anObject )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+    
+    /**
+    * Returns a List of EOAssociation subclasses that,
+    * for the objects that are usable for this association,
+    * are less suitable than this association.
+    * This implementation returns an empty list.
+    */
+    public static NSArray associationClassesSuperseded ()
+    {
+        return new NSArray();
+    }
+    
+
+    /**
+    * Binds the specified aspect of this association to the
+    * specified key on the specified display group.
+    */
+    public void bindAspect ( 
+        String anAspect, EODisplayGroup aDisplayGroup, String aKey )
+    {
+		// unattach old group, if any
+		EODisplayGroup oldGroup = displayGroupForAspect( anAspect );
+		if ( oldGroup != null )
+		{
+			EOObserverCenter.removeObserver( this, oldGroup );	
+		}
+
+		// attach new group
+		if ( aDisplayGroup != null )
+		{
+			aspectToGroup.setObjectForKey( aDisplayGroup, anAspect );
+		}
+		else
+		{
+			aspectToGroup.removeObjectForKey( anAspect );	
+		}
+		// attach new key
+		if ( aKey != null )
+		{
+			aspectToKey.setObjectForKey( aKey, anAspect );
+		}
+		else
+		{
+			aspectToKey.removeObjectForKey( anAspect );
+		}
+    }
+    
+    /**
+    * Breaks the connection between this association and 
+    * its object.  Override to stop listening for events
+    * from the object, but remember to call this method.
+    * This implementation unregisters this association
+	* from observing each bound display group.
+    */
+    public void breakConnection ()
+    {
+        discardPendingNotification();
+        Enumeration e = aspectToGroup.objectEnumerator();
+		while ( e.hasMoreElements() )
+		{
+			EOObserverCenter.removeObserver( this, e.nextElement() );	
+		}
+    }
+
+    /**
+    * Returns whether this association can bind to the
+    * specified display group on the specified key for
+    * the specified aspect.  
+    * This implementation returns false.
+    */
+    public boolean canBindAspect ( 
+        String anAspect, EODisplayGroup aDisplayGroup, String aKey)
+    {
+        return false;
+    }
+    
+    /**
+    * Copies the binding for each aspect in this association
+    * that has a matching aspect in the specified association.
+    */
+    public void copyMatchingBindingsFromAssociation ( 
+        EOAssociation anAssociation )
+    {
+		//FIXME: this is broken: aspects() returns EOAssociation.aspects()
+		//NOTE: This is actually quite crazy - should this even be static? -ceg
+        NSMutableArray ourAspects = new NSMutableArray( this.aspects() );
+        NSArray theirAspects = anAssociation.aspects();
+
+        String aspect;
+        Enumeration e = ourAspects.objectEnumerator();
+        while ( e.hasMoreElements() )
+        {
+            aspect = e.nextElement().toString();
+            if ( theirAspects.containsObject( aspect ) )
+            {
+                this.bindAspect(
+                aspect,
+                anAssociation.displayGroupForAspect( aspect ),
+                anAssociation.displayGroupKeyForAspect( aspect ) );
+            }
+        }
+    }
+    
+    /**
+    * Returns the display group that is bound the specified
+    * aspect, or null if no display group is currently 
+    * bound to that aspect.
+    */
+    public EODisplayGroup displayGroupForAspect ( String anAspect )
+    {
+        return (EODisplayGroup) aspectToGroup.objectForKey( anAspect );
+    }
+    
+    /**
+    * Returns the key for the display group bound to the
+    * specified aspect, or null if no display group is currently
+    * bound to that aspect.
+    */
+    public String displayGroupKeyForAspect ( String anAspect )
+    {
+        return (String) aspectToKey.objectForKey( anAspect );
+    }
+    
+    /**
+    * The human-readable descriptive name for this association.
+    * This implementation returns the class name.
+    */
+    public String displayName () // was static - can static method get class name?
+    {
+    	String className = getClass().getName();
+	    int index = className.lastIndexOf( "." );
+	    if ( index == -1 ) return className;
+	    return className.substring( index+1 );
+    }
+
+    /**
+    * Forces this association to cause the object to 
+    * stop editing and validate the user's input.
+    * This implementation returns true.
+    * @return false if there were problems validating,
+    * or true to continue.
+    */
+    public boolean endEditing ()
+    {
+        return true;
+    }
+
+    /**
+    * Establishes a connection between this association
+    * and the controlled object.  Subclasses should populate
+	* their controlled object from the display group and begin
+    * listening for events from their controlled object here,
+	* but remember to call this method.  Any existing value
+	* in the controlled object will be overwritten.
+    * This implementation registers this assocation to 
+	* observer changes to each of the bound display groups.
+    */
+    public void establishConnection ()
+    {
+        Enumeration e = aspectToGroup.objectEnumerator();
+		while ( e.hasMoreElements() )
+		{
+			EOObserverCenter.addObserver( this, e.nextElement() );	
+		}
+    }
+    
+    /**
+    * Returns whether this class can control the specified 
+    * object.  This implementation returns false.
+    */
+    public static boolean isUsableWithObject ( Object anObject )
+    {
+        return false;
+    }
+    
+    /**
+    * Returns the object that is currently controlled by this
+    * association, or null if no object is currently controlled.
+    */
+    public Object object ()
+    {
+        return control;
+    }
+    
+    /**
+    * Returns a List of properties of the controlled object
+    * that are controlled by this class.  For example,
+    * "stringValue", or "selected".
+    * This implementation returns an empty list.
+    */
+    public static NSArray objectKeysTaken ()
+    {
+        return new NSArray();
+    }
+    
+    /**
+    * Returns the aspect that is considered primary
+    * or default.  This is typically "value" or somesuch.
+    * This implementation returns null.
+    */
+    public static String primaryAspect ()
+    {
+        return null;
+    }
+    
+    /**
+    * Writes the specified value for the display group
+    * and key currently bound to the specified aspect.
+    * This implementation calls 
+    * EODisplayGroup.setSelectedObjectValue().
+    * @return True if the value was successfully set,
+    * otherwise false.
+    */
+    public boolean setValueForAspect ( 
+        Object aValue,
+        String anAspect )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return false;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return false;
+        
+        //FIXME: is this the right method to call
+        return group.setSelectedObjectValue( aValue, key );
+    }
+    
+
+    /**
+    * Writes the specified value for the display group
+    * and key currently bound to the specified aspect,
+    * at the specified index (assuming it's an indexed
+    * property).
+    * This implementation calls 
+    * EODisplayGroup.setValueForObjectAtIndex().
+    * @return True if the value was successfully set,
+    * otherwise false.
+    */
+    public boolean setValueForAspectAtIndex ( 
+        Object aValue,
+        String anAspect,
+        int anIndex )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return false;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return false;
+        
+        //FIXME: is this the right method to call?
+        return group.setValueForObjectAtIndex( aValue, anIndex, key );
+    }
+    
+    /**
+    * Called by subclasses to notify that the user's input
+    * failed validation.  Notifies the display group for
+    * the aspect, returning the result.
+    * This implementation calls 
+    * EODisplayGroup.associationFailedToValidateValue() 
+    * with the display group's selected object.
+    * @return True if the user should be allowed to continue,
+    * meaning that the display group with handle user notification, 
+    * otherwise false meaning the caller should notify the user.
+    */
+    public boolean shouldEndEditing ( 
+        String anAspect,
+        String anInvalidInput,
+        String anErrorDescription )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return false;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return false;
+        return group.associationFailedToValidateValue(
+            this, anInvalidInput, key, 
+            group.selectedObject(), //FIXME: is this correct?
+            anErrorDescription );
+    }
+    
+    /**
+    * Called by subclasses to notify that the user's input
+    * failed validation.  Notifies the display group for
+    * the aspect, returning the result.
+    * This implementation calls 
+    * EODisplayGroup.associationFailedToValidateValue() 
+    * with the object in the display group's displayed
+    * objects array at the specified index.
+    * @return True if the user should be allowed to continue,
+    * meaning that the display group with handle user notification, 
+    * otherwise false meaning the caller should notify the user.
+    */
+    public boolean shouldEndEditingAtIndex ( 
+        String anAspect,
+        String anInvalidInput,
+        String anErrorDescription,
+        int anIndex )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return false;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return false;
+        return group.associationFailedToValidateValue(
+            this, anInvalidInput, key, 
+            group.displayedObjects().objectAtIndex( anIndex ), 
+            //FIXME: is this correct?
+            anErrorDescription );
+    }
+    
+    /**
+    * Called when either the selection or the contents of 
+    * an associated display group have changed.
+    * This implementation does nothing.
+    */
+    public void subjectChanged ()
+    {
+        // does nothing
+    }
+    
+    /**
+    * Returns the current value for the display group 
+    * and key associated with the specified aspect.
+    */
+    public Object valueForAspect ( String anAspect )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return null;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return null;
+        
+        //FIXME: is this correct?  use selected object?
+        return group.valueForObject( group.selectedObject(), key );
+    }
+    
+    /**
+    * Returns the current value for the display group 
+    * and key associated with the specified aspect,
+    * and the specified index (assuming multiple values).
+    */
+    public Object valueForAspectAtIndex ( 
+        String anAspect, int anIndex )
+    {
+        EODisplayGroup group = (EODisplayGroup)
+            aspectToGroup.objectForKey( anAspect );
+        if ( group == null ) return null;
+        String key = (String)
+            aspectToKey.objectForKey( anAspect );
+        if ( key == null ) return null;
+        
+        //FIXME: is this the right method to call?
+        return group.valueForObjectAtIndex( anIndex, key );
+    }
+    
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.7  2005/05/11 15:21:53  cgruber
+ * Change enum to enumeration, since enum is now a keyword as of Java 5.0
+ *
+ * A few other comments in the code.
+ *
+ * Revision 1.6  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.5  2003/06/06 20:29:45  mpowers
+ * Now dequeuing the association when connection is broken.
+ * Coalesced change events had been processed even after breaking connection.
+ *
+ * Revision 1.4  2001/03/06 23:43:46  mpowers
+ * Implemented icon aspect for text association.
+ *
+ * Revision 1.3  2001/02/17 16:52:05  mpowers
+ * Changes in imports to support building with jdk1.1 collections.
+ *
+ * Revision 1.2  2001/01/25 17:46:11  mpowers
+ * Clarified usage and gc expectations.
+ *
+ * Revision 1.1.1.1  2000/12/21 15:48:07  mpowers
+ * Contributing wotonomy.
+ *
+ * Revision 1.11  2000/12/20 16:25:39  michael
+ * Added log to all files.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EODisplayGroup.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EODisplayGroup.java
new file mode 100644
index 0000000..ed65b1c
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/EODisplayGroup.java
@@ -0,0 +1,2359 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Michael Powers
+
+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;
+
+import java.lang.ref.Reference;
+import java.lang.ref.WeakReference;
+import java.util.Collection;
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Observable;
+
+import javax.swing.JOptionPane;
+
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.control.EODelayedObserver;
+import net.wotonomy.control.EOEditingContext;
+import net.wotonomy.control.EOKeyValueCoding;
+import net.wotonomy.control.EOKeyValueCodingSupport;
+import net.wotonomy.control.EOObjectStore;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.control.EOObserving;
+import net.wotonomy.control.EOQualifier;
+import net.wotonomy.control.EOSortOrdering;
+import net.wotonomy.control.OrderedDataSource;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSDictionary;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.foundation.NSNotification;
+import net.wotonomy.foundation.NSNotificationCenter;
+import net.wotonomy.foundation.NSSelector;
+import net.wotonomy.foundation.internal.Duplicator;
+import net.wotonomy.foundation.internal.WotonomyException;
+
+/**
+* EODisplayGroup provides an abstraction of a user interface,
+* comprising of an ordered collection of data objects, some
+* of which are displayed, and of those some are selected.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class EODisplayGroup extends Observable
+                         implements EOObserving, EOEditingContext.Editor
+{
+    /**
+    * Notification sent when the display group is about to fetch.
+    */ 
+    public static final String DisplayGroupWillFetchNotification
+        = "DisplayGroupWillFetchNotification";
+    
+    private static boolean
+        globalDefaultForValidatesChangesImmediately = true;
+    private static String
+        globalDefaultStringMatchFormat = "caseInsensitiveLike";
+    private static String
+        globalDefaultStringMatchOperator = "%@*";
+
+    protected NSMutableArray allObjects;
+    protected NSArray allObjectsProxy;
+    protected NSMutableArray displayedObjects;
+    protected NSArray displayedObjectsProxy;
+    protected NSMutableArray selectedObjects;
+    protected NSArray selectedObjectsProxy;
+    protected NSMutableArray selectedIndexes;
+
+    private String defaultStringMatchOperator;
+    private String defaultStringMatchFormat;
+
+    private boolean validatesChangesImmediately;
+    private Object delegate;
+    private EODataSource dataSource;
+    private EOAssociation editingAssociation;
+    private EOQualifier qualifier;
+    private NSMutableArray sortOrderings;
+    private NSArray sortOrderingsProxy;
+
+    private NSArray localKeys;
+    private NSDictionary insertedObjectDefaultValues;
+    private boolean fetchesOnLoad;
+    private boolean selectsFirstObjectAfterFetch;
+    private boolean usesOptimisticRefresh;
+    private boolean inQueryMode;
+
+    // change detection: package access for helper classes
+    boolean contentsChanged;
+    boolean selectionChanged;
+    int updatedObjectIndex;
+
+    // this property is not in the spec
+    private boolean compareByReference = false;
+
+    private EOObserving lastGroupObserver;
+    
+    /**
+    * Creates a new display group.
+    */
+    public EODisplayGroup ()
+    {
+        validatesChangesImmediately =
+            globalDefaultForValidatesChangesImmediately();
+        defaultStringMatchOperator =
+            globalDefaultStringMatchFormat();
+        defaultStringMatchFormat =
+            globalDefaultStringMatchOperator();
+
+        allObjects = new ObservableArray( this );
+        allObjectsProxy = NSArray.arrayBackedByList( allObjects );
+        displayedObjects = new NSMutableArray();
+        displayedObjectsProxy = NSArray.arrayBackedByList( displayedObjects );
+        selectedObjects = new NSMutableArray();
+        selectedObjectsProxy = NSArray.arrayBackedByList( selectedObjects );
+        sortOrderings = new NSMutableArray();
+        sortOrderingsProxy = NSArray.arrayBackedByList( sortOrderings );
+        selectedIndexes = new NSMutableArray();
+
+        delegate = null;
+        dataSource = null;
+        editingAssociation = null;
+        qualifier = null;
+
+        localKeys = new NSArray(); // not implemented
+        insertedObjectDefaultValues = new NSDictionary();
+        fetchesOnLoad = false; // not implemented
+        selectsFirstObjectAfterFetch = false;
+        usesOptimisticRefresh = false;
+        inQueryMode = false; // not implemented
+
+        contentsChanged = false;
+        selectionChanged = false;
+        updatedObjectIndex = -1;
+
+        // create our private delayed observer
+        lastGroupObserver = new LastGroupObserver( this );
+        EOObserverCenter.addObserver( lastGroupObserver, this );
+    }
+
+
+
+    // specify optional data source
+
+    /**
+    * Sets the data source that will be used by
+    * this display group.
+    */
+    public void setDataSource ( EODataSource aDataSource )
+    {
+        if ( ( dataSource != null )
+        &&   ( dataSource.editingContext() != null ) )
+        {
+            // un-register for notifications from existing parent store
+            NSNotificationCenter.defaultCenter().removeObserver(
+                this, null, dataSource.editingContext() );
+            dataSource.editingContext().removeEditor( this );
+            if ( dataSource.editingContext().messageHandler() == this )
+            {
+                dataSource.editingContext().setMessageHandler( null );
+            }
+            
+        }
+
+        dataSource = aDataSource;
+
+        if ( ( dataSource != null )
+        &&   ( dataSource.editingContext() != null ) )
+        {
+            // register for notifications from parent store
+            NSNotificationCenter.defaultCenter().addObserver(
+                this, new NSSelector( "objectsInvalidatedInEditingContext",
+                    new Class[] { NSNotification.class } ),
+                null, dataSource.editingContext() );
+            
+            // add ourselves as editor
+            dataSource.editingContext().addEditor( this );
+            
+            // add ourselves as message handler if no such handler exists
+            if ( dataSource.editingContext().messageHandler() == null )
+            {
+                dataSource.editingContext().setMessageHandler( this );
+            }
+        }
+    }
+    
+    /**
+    * Returns the current data source backing this display group,
+    * or null if no dataSource is currently used.
+    */
+    public EODataSource dataSource ()
+    {
+        return dataSource;
+    }
+
+
+
+    // specify optional delegate
+
+    /**
+    * Sets the display group delegate that
+    * will be used by this display group.
+    */
+    public void setDelegate ( Object aDelegate )
+    {
+        delegate = aDelegate;
+    }
+
+   /**
+    * Returns the current delegate for this display group,
+    * or null if no delegate is currently set.
+    */
+    public Object delegate ()
+    {
+        return delegate;
+    }
+
+
+
+    // display group configuration
+
+    /**
+    * Returns the current string matching format.
+    * If not set, defaults to "%@*".
+    */
+    public String defaultStringMatchFormat ()
+    {
+        return defaultStringMatchFormat;
+    }
+
+    /**
+    * Returns the current string matching operator.
+    * If not set, defaults to "caseInsensitiveLike".
+    */
+    public String defaultStringMatchOperator ()
+    {
+        return defaultStringMatchOperator;
+    }
+
+    /**
+    * Sets the display group and associations to edit a
+    * "query by example" query object.  This method is
+    * used for target/action connections.
+    */
+    public void enterQueryMode ( Object aSender )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Returns whether this display group should immediate
+    * fetch when loaded.
+    */
+    public boolean fetchesOnLoad ()
+    {
+        return fetchesOnLoad;
+    }
+
+    /**
+    * Returns whether this display group is in "query by
+    * example" mode.
+    */
+    public boolean inQueryMode ()
+    {
+        return inQueryMode;
+    }
+
+    /**
+    * Returns a Map of default values that are applied
+    * to new objects that are inserted into the list.
+    */
+    public NSDictionary insertedObjectDefaultValues ()
+    {
+        return insertedObjectDefaultValues;
+    }
+
+    /**
+    * Returns the keys that were declared when read from
+    * an external resource file.
+    */
+    public NSArray localKeys ()
+    {
+        return localKeys;
+    }
+
+    /**
+    * Sets whether this display group will select the
+    * first object in the list after a fetch.
+    */
+    public boolean selectsFirstObjectAfterFetch ()
+    {
+        return selectsFirstObjectAfterFetch;
+    }
+
+    /**
+    * Sets the default string matching format that
+    * will be used by this display group.
+    */
+    public void setDefaultStringMatchFormat ( String aFormat )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the default string matching operator that
+    * will be used by this display group.
+    */
+    public void setDefaultStringMatchOperator ( String anOperator )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets whether this display group will fetch objects
+    * from its data source on load.
+    */
+    public void setFetchesOnLoad ( boolean willFetch )
+    {
+        fetchesOnLoad = willFetch;
+    }
+
+    /**
+    * Sets whether this display group is in "query by example"
+    * mode.  If true, all associations will bind to a special
+    * "example" object.
+    */
+    public void setInQueryMode ( boolean isInQueryMode )
+    {
+        inQueryMode = isInQueryMode;
+    }
+
+    /**
+    * Sets the mapping that contains the values that will
+    * be applied to new objects inserted into the display group.
+    */
+    public void setInsertedObjectDefaultValues ( Map aMap )
+    {
+        insertedObjectDefaultValues = new NSDictionary( aMap );
+    }
+
+    /**
+    * Sets the keys that are declared when instantiated from
+    * an external resource file.
+    */
+    public void setLocalKeys ( List aKeyList )
+    {
+        localKeys = new NSArray( (Collection) aKeyList );
+    }
+
+    /**
+    * Sets whether the first object in the list will be
+    * selected after a fetch.
+    */
+    public void setSelectsFirstObjectAfterFetch (
+        boolean selectsFirst )
+    {
+        selectsFirstObjectAfterFetch = selectsFirst;
+    }
+
+    /**
+    * Sets the order of the keys by which this display group
+    * will be ordered after a fetch or after a call to
+    * updateDisplayedObjects().  The elements in the display
+    * group will be sorted first by the first key, within
+    * the first key, by the second key, and so on.
+    */
+    public void setSortOrderings ( List aList )
+    {
+        sortOrderings.removeAllObjects();
+
+        Object o;
+        Iterator it = aList.iterator();
+        while ( it.hasNext() )
+        {
+            o = it.next();
+            // handle the convenience of specifying just a key
+            if ( ! ( o instanceof EOSortOrdering ) )
+            {
+                o = new EOSortOrdering(
+                    o.toString(), EOSortOrdering.CompareAscending );
+            }
+            sortOrderings.add( o );
+        }
+    }
+
+    /**
+    * Sets whether only changed objects are refreshed (optimistic),
+    * or whether all objects are refreshed (pessimistic, default).
+    * By default, when the display group receives notification that
+    * one of its objects has changed, updateDisplayedObjects is called.
+    */
+    public void setUsesOptimisticRefresh ( boolean isOptimistic )
+    {
+        usesOptimisticRefresh = isOptimistic;
+    }
+
+    /**
+    * Sets whether changes made by associations are validated
+    * immediately, or when changes are saved.
+    */
+    public void setValidatesChangesImmediately (
+        boolean validatesImmediately )
+    {
+        validatesChangesImmediately = validatesImmediately;
+    }
+
+    /**
+    * Returns a read-only List of sort orderings for this display group.
+    */
+    public NSArray sortOrderings ()
+    {
+        return sortOrderingsProxy;
+    }
+
+    /**
+    * Returns whether this display group refreshes only
+    * the changed objects or all objects on refresh.
+    */
+    public boolean usesOptimisticRefresh ()
+    {
+        return usesOptimisticRefresh;
+    }
+
+    /**
+    * Returns whether this display group validates changes
+    * immediately.  Otherwise, validation should occur when
+    * changes are saved.  Default is the global default,
+    * which is initially true.
+    */
+    public boolean validatesChangesImmediately ()
+    {
+        return validatesChangesImmediately;
+    }
+
+
+    // qualification
+
+    /**
+    * Returns a qualifier that will be applied all the objects
+    * in this display group to determine which objects will
+    * be displayed.
+    */
+    public EOQualifier qualifier ()
+    {
+        return qualifier;
+    }
+
+    /**
+    * Returns a new qualifier built from the three query
+    * value maps: greater than, equal to, and less than.
+    */
+    public EOQualifier qualifierFromQueryValues ()
+    {
+        //TODO: assemble qualifier from query values
+
+        return new EOQualifier()
+        {
+            // use inner class until we actually implement one
+            public EOQualifier qualifierWithBindings(
+                Map aMap,
+                boolean requireAll )
+            {
+                return null;
+            }
+            public Throwable
+            validateKeysWithRootClassDescription( Class aClass )
+            {
+                return null;
+            }
+                        public boolean evaluateWithObject(Object o)
+                        {
+                          return false;
+                        }
+        };
+    }
+
+    /**
+    * Calls qualifierFromQueryValues(), applies the result
+    * to the data source, and calls fetch().
+    */
+    public void qualifyDataSource ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Calls qualifierFromQueryValues(), sets the qualifier
+    * with setQualifier(), and calls updateDisplayedObjects().
+    */
+    public void qualifyDisplayGroup ()
+    {
+        setQualifier( qualifierFromQueryValues() );
+        updateDisplayedObjects();
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to binding query values.
+    */
+    public NSDictionary queryBindingValues ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to operator values.
+    */
+    public NSDictionary queryOperatorValues ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the qualifier that will be used by
+    * updateDisplayedObjects() to filter displayed objects.
+    */
+    public void setQualifier ( EOQualifier aQualifier )
+    {
+        qualifier = aQualifier;
+    }
+
+    /**
+    * Sets the mapping that contains the mappings of keys
+    * to binding values.
+    */
+    public void setQueryBindingValues ( Map aMap )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the mapping that contains the mappings of keys
+    * to operator values.
+    */
+    public void setQueryOperatorValues ( Map aMap )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+
+
+    // qualifier query values
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for equality.
+    */
+    public NSDictionary equalToQueryValues ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for greater value.
+    */
+    public NSDictionary greaterThanQueryValues ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Returns a Map containing the mappings of keys
+    * to query values that will be used to test for lesser value.
+    */
+    public NSDictionary lessThanQueryValues ()
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the Map that contains the mappings of keys
+    * to query values that will be used to test for equality.
+    */
+    public void setEqualToQueryValues ( Map aMap )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the mapping that contains the mappings of keys
+    * to query values that will be used to test for greater value.
+    */
+    public void setGreaterThanQueryValues ( Map aMap )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+    /**
+    * Sets the mapping that contains the mappings of keys
+    * to query values that will be used to test for lesser value.
+    */
+    public void setLessThanQueryValues ( Map aMap )
+    {
+        throw new RuntimeException( "Not implemented yet." );
+    }
+
+
+    // interface to associations
+
+    /**
+    * Called by an association when it begins editing.
+    */
+    public void associationDidBeginEditing ( EOAssociation anAssociation )
+    { // System.out.println( "EODisplayGroup.associationDidBeginEditing: " + anAssociation );        
+        if ( dataSource != null )
+        {
+            if ( dataSource.editingContext() != null )
+            {
+                dataSource.editingContext().setMessageHandler( this );
+            }
+        }
+        editingAssociation = anAssociation;
+    }
+
+    /**
+    * Called by an association when it is finished editing.
+    */
+    public void associationDidEndEditing ( EOAssociation anAssociation )
+    { // System.out.println( "EODisplayGroup.associationDidEndEditing: " + anAssociation );        
+        editingAssociation = null;
+    }
+
+    /**
+    * Called by associations to determine whether the contents
+    * of any objects have been changed.  Returns true if the
+    * contents have changed and not all observers have been
+    * notified.
+    */
+    public boolean contentsChanged ()
+    {
+        return contentsChanged;
+    }
+
+    /**
+    * Called by associations to determine whether the
+    * selection has been changed.  Returns true if the
+    * selection has changed and not all observers have
+    * been notified.
+    */
+    public boolean selectionChanged ()
+    {
+        return selectionChanged;
+    }
+
+    /**
+    * Called by an association when a user-specified value fails the association's
+    * validation rules.  This implementation returns true, unless the delegate
+    * prevents this.
+    * @return True to allow the association to handle user notification,
+    * otherwise return false to let the association know that the
+    * display group notified the user.
+    */
+    public boolean associationFailedToValidateValue (
+        EOAssociation anAssociation,
+        String aValue,
+        String aKey,
+        Object anObject,
+        String anErrorDescription )
+    {
+        Object result = notifyDelegate(
+            "displayGroupShouldDisplayAlert",
+            new Class[] { EODisplayGroup.class, String.class, String.class },
+            new Object[] { this, "Validation Failed", anErrorDescription } );
+        if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+        {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+    * Called by an association to determine whether it should enable
+    * a component that displayes a value for the specified key.
+    * @return true if an object is selected, or if
+    * the specified key is a query key.  Otherwise false.
+    */
+    public boolean enabledToSetSelectedObjectValueForKey ( String aKey )
+    {
+        if ( ( aKey != null ) && ( aKey.startsWith( "@" ) ) ) return true;
+        return ( selectedObject() != null );
+    }
+
+    
+    // association management
+
+    /**
+    * Returns the association that is currently being edited,
+    * or null if no editing is taking place.
+    */
+    public EOAssociation editingAssociation ()
+    {
+        return editingAssociation;
+    }
+
+    /**
+    * Asks the association currently editing to stop editing.
+    * @returns true if editing was stopped, false if the
+    * association refused to stop editing (if a modal dialog
+    * is displayed or a value failed to validate).
+    */
+    public boolean endEditing ()
+    {
+        if ( editingAssociation == null ) return true;
+        return editingAssociation.endEditing();
+    }
+
+    /**
+    * Returns a read-only List of associations that are observing
+    * this display group.
+    */
+    public NSArray observingAssociations ()
+    {
+        NSArray observers =
+            EOObserverCenter.observersForObject( this );
+        NSMutableArray result = new NSMutableArray();
+
+        Object o;
+        Enumeration e = observers.objectEnumerator();
+        while ( e.hasMoreElements() )
+        {
+            o = e.nextElement();
+            if ( o instanceof EOAssociation )
+            {
+                result.addObject( o );
+            }
+        }
+        return result;
+    }
+
+
+
+    // object management
+
+    /**
+    * Returns a read-only List containing all objects managed by the display group.
+    * This includes those objects not visible due to disqualification.
+    */
+    public NSArray allObjects ()
+    { //System.out.println( "avoided allocation: allObjects" );
+        return allObjectsProxy;
+    }
+
+    /**
+    * Clears the current selection.
+    * @return True is the selection was cleared,
+    * False if the selection could not be cleared
+    * @see #setSelectionIndexes
+    */
+    public boolean clearSelection ()
+    {
+        Object result = notifyDelegate(
+            "displayGroupShouldChangeSelection",
+            new Class[] { EODisplayGroup.class, List.class },
+            new Object[] { this, new NSArray( selectedObjects ) } );
+        if ( ( result != null ) && ( Boolean.FALSE.equals( result ) ) )
+        {
+            return false;
+        }
+
+        selectionChanged = true;
+        willChange();
+
+        selectedObjects.removeAllObjects();
+        selectedIndexes.removeAllObjects();
+
+        notifyDelegate(
+            "displayGroupDidChangeSelection",
+            new Class[] { EODisplayGroup.class },
+            new Object[] { this } );
+        notifyDelegate(
+            "displayGroupDidChangeSelectedObjects",
+            new Class[] { EODisplayGroup.class },
+            new Object[] { this } );
+
+        return true;
+    }
+
+    /**
+    * Deletes the object at the specified index,
+    * notifying the delegate before and after the operation,
+    * and then updating the selection if needed.
+    * @return True if delete was successful, false if the
+    * object was not deleted.
+    */
+    public boolean deleteObjectAtIndex ( int anIndex )
+    {
+        Object target = displayedObjects.objectAtIndex( anIndex );
+
+        Object result = notifyDelegate(
+            "displayGroupShouldDeleteObject",
+            new Class[] { EODisplayGroup.class, Object.class },
+            new Object[] { this, target } );
+        if ( ( result != null ) && ( Boolean.FALSE.equals( result ) ) )
+        {
+            return false;
+        }
+
+        contentsChanged = true;
+
+        deleteObjectAtIndexNoNotify( anIndex );
+
+        if ( dataSource != null )
+        {
+            dataSource.deleteObject( target );
+        }
+
+        notifyDelegate(
+            "displayGroupDidDeleteObject",
+            new Class[] { EODisplayGroup.class, Object.class },
+            new Object[] { this, target } );
+
+        return true;
+    }
+
+    private void deleteObjectAtIndexNoNotify ( int anIndex )
+    {
+        Object target = displayedObjects.objectAtIndex( anIndex );
+
+        int i;
+
+        // remove from selected objects if necessary
+        i = indexOf( selectedObjects, target );
+        if ( i != NSArray.NotFound )
+        {
+            selectionChanged = true;
+            willChange(); // notify before removing
+            selectedObjects.removeObjectAtIndex( i );
+            selectedIndexes.remove( new Integer( i ) ); // comps by value
+        }
+        else // notify - no selection change needed
+        {
+            willChange();
+        }
+
+        // remove from all objects
+        i = indexOf( allObjects, target );
+        if ( i != NSArray.NotFound )
+        {
+            allObjects.removeObjectAtIndex( i );
+        }
+        else // otherwise should never happen
+        {
+//          throw new WotonomyException(
+//              "Displayed object not found in allObjects" );
+        }
+
+        // remove from displayed objects
+        displayedObjects.removeObjectAtIndex( anIndex );
+    }
+
+    /**
+    * Deletes the currently selected objects.
+    * This implementation calls deleteObjectAtIndex() for
+    * each index in the selection list, immediately returning
+    * false if any delete operation fails.
+    * @return True if all selected objects were deleted,
+    * false if any deletion failed.
+    */
+    public boolean deleteSelection ()
+    {
+        int i;
+        boolean result = true;
+
+        Enumeration e = new NSArray( selectedObjects ).objectEnumerator();
+        while ( e.hasMoreElements() )
+        {
+            i = indexOf( displayedObjects, e.nextElement() );
+            if ( i == NSArray.NotFound )
+            {
+                // should never happen
+                throw new WotonomyException(
+                    "Selected object not found in displayedObjects" );
+            }
+            result = result && deleteObjectAtIndex( i );
+        }
+
+        return result;
+    }
+
+    /**
+    * Returns a read-only List of all objects in the display group
+    * that are currently displayed by the associations.
+    */
+    public NSArray displayedObjects ()
+    { // System.out.println( "avoided allocation: displayedObjects" );
+        return displayedObjectsProxy;
+    }
+
+    /**
+    * Requests a list of objects from the DataSource
+    * and calls setObjectArray to populate the list.
+    * More specifically, calls endEditing(), asks the
+    * delegate, fetches the objects, notifies the delegate,
+    * and populates the list.
+    */
+    public boolean fetch ()
+    {
+        endEditing();
+
+        if ( dataSource == null )
+        {
+            return false;
+        }
+
+        Object result = notifyDelegate(
+            "displayGroupShouldFetch",
+            new Class[] { EODisplayGroup.class },
+            new Object[] { this } );
+        if ( ( result != null ) && ( Boolean.FALSE.equals( result ) ) )
+        {
+            return false;
+        }
+
+        NSNotificationCenter.defaultCenter().postNotification(
+            DisplayGroupWillFetchNotification, this, new NSDictionary() );
+        
+        NSArray objectList = dataSource.fetchObjects();
+
+        notifyDelegate(
+            "displayGroupDidFetchObjects",
+            new Class[] { EODisplayGroup.class, List.class },
+            new Object[] { this, objectList } );
+            
+        if ( selectsFirstObjectAfterFetch ) 
+        {
+            //note: there's a good chance this logic ought to be in master-detail assoc:
+            // we're doing this because changes in the master object trigger a refetch
+            // on the child display group which annoyingly changes the selection.
+            NSArray original = new NSArray( allObjects );
+            setObjectArray( objectList );
+            if ( displayedObjects.size() > 0
+                && !original.equals( allObjects ) ) // don't change if no change
+            {
+                setSelectionIndexes( new NSArray( new Integer( 0 ) ) );
+            }
+        }
+        else
+        {
+            setObjectArray( objectList );
+        }
+
+        return true;
+   }
+
+    /**
+    * Creates a new object at the specified index.
+    * Calls insertObjectAtIndex() with the result
+    * from sending createObject() to the data source.
+    * Presents a JOptionPane if the create fails, unless
+    * the delegate implements displayGroupCreateObjectFailed.
+    * @return the newly created object.
+    */
+    public Object insertNewObjectAtIndex ( int anIndex )
+    {
+        Object result = null;
+        if ( dataSource != null )
+        {
+            result = dataSource.createObject();
+        }
+        if ( result != null )
+        {
+            if ( insertedObjectDefaultValues != null )
+            {
+                Duplicator.writePropertiesForObject(
+                    insertedObjectDefaultValues, result );
+            }
+            insertObjectAtIndex( result, anIndex );
+        }
+        else // create failed
+        {
+            if ( delegate() != null )
+            {
+                NSSelector selector = new NSSelector(
+                    "displayGroupCreateObjectFailed",
+                    new Class[] { EODisplayGroup.class, EODataSource.class } );
+                if ( selector.implementedByObject( delegate() ) )
+                {
+                    try
+                    {
+                        selector.invoke( delegate(), new Object[] { this, dataSource } );
+                        return result;
+                    }
+                    catch ( Exception exc )
+                    {
+                        System.err.println( "Error notifying delegate: displayGroupCreateObjectFailed" );
+                        exc.printStackTrace();
+                    }
+                }                    
+            }
+            
+            // no delegate or delegate does not implement displayGroupCreateObjectFailed
+            
+            String message = "Data source could not create new object";
+            Object delegateResult = notifyDelegate(
+                "displayGroupShouldDisplayAlert",
+                new Class[] { EODisplayGroup.class, String.class, String.class },
+                new Object[] { this, "Error", message } );
+            if ( ( delegateResult == null ) || ( Boolean.TRUE.equals( delegateResult ) ) )
+            {
+                JOptionPane.showMessageDialog( null, message );
+            }
+        }
+        return result;
+    }
+
+    /**
+    * Inserts the specified object into the list at
+    * the specified index.
+    */
+    public void insertObjectAtIndex ( Object anObject, int anIndex )
+    {
+        Object result = notifyDelegate(
+            "displayGroupShouldInsertObject",
+            new Class[] { EODisplayGroup.class, Object.class, int.class },
+            new Object[] { this, anObject, new Integer(anIndex) } );
+        if ( ( result != null ) && ( Boolean.FALSE.equals( result ) ) )
+        {
+            return;
+        }
+
+        contentsChanged = true;
+        updatedObjectIndex = anIndex;
+        willChange();
+
+
+        // add to all objects
+        if ( anIndex == displayedObjects.size() )
+        {
+            allObjects.addObject( anObject );
+        }
+        else // insert before same object
+        {
+            Object target = displayedObjects.objectAtIndex( anIndex );
+            int targetIndex = indexOf( allObjects, target );
+            if ( targetIndex != NSArray.NotFound )
+            {
+                allObjects.insertObjectAtIndex( anObject, targetIndex );
+            }
+            else // should never happen
+            {
+                throw new WotonomyException(
+                    "Could not find displayed object in all objects list: "
+                    + target );
+            }
+        }
+
+        // add to displayed objects
+        displayedObjects.insertObjectAtIndex( anObject, anIndex );
+
+        if ( dataSource != null )
+        {
+            if ( dataSource instanceof OrderedDataSource )
+            {
+                ((OrderedDataSource)dataSource).insertObjectAtIndex(
+                    anObject, anIndex );
+            }
+            else
+            {
+                dataSource.insertObject( anObject );
+            }
+        }
+
+        notifyDelegate(
+            "displayGroupDidInsertObject",
+            new Class[] { EODisplayGroup.class, Object.class },
+            new Object[] { this, anObject } );
+    }
+
+    /**
+    * Sets contentsChanged to true and notifies all observers.
+    */
+    public void redisplay ()
+    {
+        contentsChanged = true;
+        willChange();
+    }
+
+    /**
+    * Sets the selection to the next displayed object after the current
+    * selection.  If the last object is selected, or if no object
+    * is selected, then the first object becomes selected.
+    * If multiple items are selected, the first selected item is
+    * considered the selected item for the purposes of this method.
+    * Does not call redisplay().
+    * @return true if an object was selected.
+    */
+    public boolean selectNext ()
+    {
+        int count = displayedObjects.count();
+        if ( count == 0 ) return false;
+        if ( count == 1 )
+        {
+            selectObject( displayedObjects.objectAtIndex( 0 ) );
+            return true;
+        }
+
+        int i = -1;
+        Object selectedObject = selectedObject();
+        if ( selectedObject != null )
+        {
+            i = indexOf( displayedObjects, selectedObject );
+        }
+        if ( i == NSArray.NotFound ) i = -1;
+
+        // select next object
+        i++;
+        if ( i != displayedObjects.count() )
+        {
+            // set to next object
+            selectedObject = displayedObjects.objectAtIndex( i );
+        }
+        else // out of range
+        {
+            // set to null
+            selectedObject = displayedObjects.objectAtIndex( 0 );
+        }
+
+        return selectObject( selectedObject );
+    }
+
+    /**
+    * Sets the selection to the specified object.
+    * If the specified object is null or does not exist
+    * in the list of displayed objects, the selection
+    * will be cleared.
+    * @return true if the object was selected.
+    */
+    public boolean selectObject ( Object anObject )
+    {
+        if ( ( anObject == null ) ||
+             ( indexOf( displayedObjects, anObject )
+               == NSArray.NotFound ) )
+        {
+            clearSelection();
+            return false;
+        }
+
+        selectObjectsIdenticalTo( new NSArray( new Object[] { anObject } ) );
+        return true;
+    }
+
+    /**
+    * Sets the selection to the specified objects.
+    * If the specified list is null or if none of the objects
+    * in the list exist in the list of displayed objects, the
+    * selection will be cleared.
+    * @return true if all specified objects were selected.
+    */
+    public boolean selectObjectsIdenticalTo ( List anObjectList )
+    {
+        // optimization: check for resetting of selection
+        if ( ( anObjectList != null ) && ( selectedObjects.size() == anObjectList.size() ) )
+        {
+            boolean identical = true;
+            int size = selectedObjects.size();
+            for ( int i = 0; ( i < size ) && identical; i++ )
+            {
+                // compare by reference
+                if ( anObjectList.get( i ) != selectedObjects.get( i ) )
+                {
+                    identical = false;
+                }
+                else if ( displayedObjects.indexOfIdenticalObject(
+                      anObjectList.get( i ) ) == NSArray.NotFound )
+                {
+                    identical = false;
+                }
+            }
+            if ( identical )
+            {
+                return true;
+            }
+        }
+
+        Object result = notifyDelegate(
+            "displayGroupShouldChangeSelection",
+            new Class[] { EODisplayGroup.class, List.class },
+            new Object[] { this, anObjectList } );
+        if ( ( result != null ) && ( Boolean.FALSE.equals( result ) ) )
+        {
+            // need to notify the calling component
+            //   to revert back to the previous selection
+            selectionChanged = true;
+            willChange();
+            return false;
+        }
+
+        int i;
+        selectionChanged = true;
+        willChange();
+        Object o;
+        selectedObjects.removeAllObjects();
+        selectedIndexes.removeAllObjects();
+        Iterator it = anObjectList.iterator();
+        while ( it.hasNext() )
+        {
+            o = it.next();
+            if ( ( i = displayedObjects.indexOfIdenticalObject( o ) )
+                != NSArray.NotFound )
+            {
+                selectedObjects.addObject( o );
+                selectedIndexes.addObject( new Integer( i ) );
+            }
+        }
+        
+        notifyDelegate(
+            "displayGroupDidChangeSelection",
+            new Class[] { EODisplayGroup.class },
+            new Object[] { this } );
+        notifyDelegate(
+            "displayGroupDidChangeSelectedObjects",
+            new Class[] { EODisplayGroup.class },
+            new Object[] { this } );
+
+        return true;
+    }
+
+    /**
+    * Sets the selection to the previous displayed object before the current
+    * selection.  If the first object is selected, or if no object
+    * is selected, then the last object becomes selected.
+    * If multiple items are selected, the first selected item is
+    * considered the selected item for the purposes of this method.
+    * Does not call redisplay().
+    * @return true if an object was selected.
+    */
+    public boolean selectPrevious ()
+    {
+        int i = displayedObjects.count();
+        if ( i == 0 ) return false;
+        if ( i == 1 )
+        {
+            selectObject( displayedObjects.objectAtIndex( 0 ) );
+            return true;
+        }
+
+        Object selectedObject = selectedObject();
+        if ( selectedObject != null )
+        {
+            i = indexOf( displayedObjects, selectedObject );
+        }
+        if ( i == NSArray.NotFound ) i = displayedObjects.count();
+
+        // select next object
+        i--;
+        if ( i < 0 )
+        {
+            // out of range - select last object
+            i = displayedObjects.count() - 1;
+        }
+
+        return selectObject( displayedObjects.objectAtIndex( i ) );
+    }
+
+    /**
+    * Returns the currently selected object, or null if
+    * there is no selection.
+    */
+    public Object selectedObject ()
+    {
+        if ( selectedObjects.count() == 0 )
+        {
+            return null;
+        }
+        return selectedObjects.objectAtIndex( 0 );
+    }
+
+    /**
+    * Returns a read-only List containing all selected objects, if any.
+    * Returns an empty list if no objects are selected.
+    */
+    public NSArray selectedObjects ()
+    { // System.out.println( "avoided allocation: selectedObjects" );
+        return selectedObjectsProxy;
+    }
+
+    /**
+    * Returns a read-only List containing the indexes of all selected
+    * objects, if any.  The list contains instances of
+    * java.lang.Number; call intValue() to retrieve the index.
+    */
+    public NSArray selectionIndexes ()
+    {
+//        return selectedIndexes;
+        int i;
+        NSMutableArray result = new NSMutableArray();
+        Enumeration e = selectedObjects.objectEnumerator();
+        while ( e.hasMoreElements() )
+        {
+            i = indexOf( displayedObjects, e.nextElement() );
+            if ( i != NSArray.NotFound )
+            {
+                result.addObject( new Integer( i ) );
+            }
+            else
+            {
+              System.err.println( 
+                  "Should never happen: selected objects not in displayed objects" );
+              new RuntimeException().printStackTrace( System.err );
+            }
+        }
+        return result;
+    }
+
+    /**
+    * Sets the objects managed by this display group.
+    * updateDisplayedObjects() is called to filter the
+    * display objects.  The previous selection will be
+    * maintained if possible.  The data source is not
+    * notified.
+    */
+    public void setObjectArray ( List anObjectList )
+    {
+        if ( anObjectList == null ) anObjectList = new NSArray();
+
+        Object result = notifyDelegate(
+            "displayGroupDisplayArrayForObjects",
+            new Class[] { EODisplayGroup.class, List.class },
+            new Object[] { this, anObjectList } );
+        if ( result != null )
+        {
+            anObjectList = (List) result;
+        }
+
+        contentsChanged = true;
+        willChange();
+
+        NSArray oldSelectedObjects = new NSArray( selectedObjects ); // copy
+
+        // reset allObjects to new list
+        allObjects.removeAllObjects();
+        allObjects.addObjectsFromArray( anObjectList );
+
+        // update the displayed object list
+        updateDisplayedObjects();
+        
+        // restore the selection if possible
+        selectObjectsIdenticalTo( oldSelectedObjects );
+    }
+
+    /**
+    * Sets the currently selected object, or clears the
+    * selection if the object is not found or is null.
+    * Note: it's not clear how this differs from
+    * selectObject in the spec.  It is recommended that
+    * you call selectObject for now.
+    */
+    public void setSelectedObject ( Object anObject )
+    {
+        selectObject( anObject );
+    }
+
+    /**
+    * Sets the current selection to the specified objects.
+    * The previous selection is cleared, and any objects
+    * in the display group that are in the specified list
+    * are then selected.  If no items in the specified list
+    * are found in the display group, then the selection is
+    * effectively cleared.
+    * Note: it's not clear how this differs from
+    * selectObjectsIdenticalTo in the spec.
+    * It is recommended that you call that method for now.
+    */
+    public void setSelectedObjects ( List aList )
+    {
+        selectObjectsIdenticalTo( aList );
+    }
+
+    /**
+    * Sets the current selection to the objects at the
+    * specified indexes.  Items in the list are assumed
+    * to be instances of java.lang.Number.
+    * The previous selection is cleared, and any objects
+    * in the display group that are in the specified list
+    * are then selected.  If no items in the specified list
+    * are found in the display group, then the selection is
+    * effectively cleared.
+    */
+    public boolean setSelectionIndexes ( List aList )
+    {
+        Object o;
+        int index;
+        NSMutableArray objects = new NSMutableArray();
+        Iterator it = aList.iterator();
+        while ( it.hasNext() )
+        {
+            index = ((Number)it.next()).intValue();
+            if ( index < displayedObjects.count() )
+            {
+                o = displayedObjects.objectAtIndex( index );
+                if ( o != null )
+                {
+                    objects.add( o );
+                }
+            }
+        }
+        return selectObjectsIdenticalTo( objects );
+    }
+
+    /**
+    * Applies the qualifier to all objects and sorts
+    * the results to update the list of displayed objects.
+    * Observing associations are notified to reflect the changes.
+    */
+    public void updateDisplayedObjects ()
+    {
+        contentsChanged = true;
+        updatedObjectIndex = -1;
+        willChange();
+
+        displayedObjects.removeAllObjects();
+
+        displayedObjects.addObjectsFromArray( allObjects );
+
+        // apply qualifier, if any
+        if ( qualifier() != null )
+        {
+            EOQualifier.filterArrayWithQualifier(
+                displayedObjects, qualifier() );
+        }
+
+        // apply sort orderings, if any
+        NSArray orderings = sortOrderings();
+        if ( orderings != null )
+        {
+            if ( orderings.count() > 0 )
+            {
+                selectionChanged = true;
+                willChange();
+                EOSortOrdering.sortArrayUsingKeyOrderArray(
+                    displayedObjects, orderings );
+            }
+        }
+
+          // make sure the selectedObjects is a subset of displayedObjects
+          int i;
+          Object o;
+          Iterator it = new LinkedList( selectedObjects ).iterator();
+          boolean removeflag = false;
+          selectedIndexes.removeAllObjects();
+          while ( it.hasNext() )
+          {
+              o = it.next();
+              if ( ( i = displayedObjects.indexOfIdenticalObject( o ) )
+                      == NSArray.NotFound )
+              {
+                  selectedObjects.removeIdenticalObject( o );
+                  removeflag = true;
+              }
+              else
+              {
+                  selectedIndexes.addObject( new Integer( i ) );
+              }
+          }
+
+          //Note: it is important to put the
+          //selectionChanged = true line below remove.
+          if (removeflag)
+          {
+            selectionChanged = true;
+            willChange();
+
+            notifyDelegate(
+                "displayGroupDidChangeSelection",
+                new Class[] { EODisplayGroup.class },
+                new Object[] { this } );
+            notifyDelegate(
+                "displayGroupDidChangeSelectedObjects",
+                new Class[] { EODisplayGroup.class },
+                new Object[] { this } );
+          }
+    }
+
+    /**
+    * Returns the index of the changed object.  If more than
+    * one object has changed, -1 is returned.
+    */
+    public int updatedObjectIndex ()
+    {
+        return updatedObjectIndex;
+    }
+
+    // getting and setting values in objects
+
+    /**
+    * Returns a value on the selected object for the specified key.
+    */
+    public Object selectedObjectValueForKey ( String aKey )
+    {
+        Object selectedObject = selectedObject();
+        if ( selectedObject == null ) return null;
+        return valueForObject( selectedObject, aKey );
+    }
+
+    /**
+    * Sets the specified value for the specified key on
+    * all selected objects.
+    */
+    public boolean setSelectedObjectValue (
+        Object aValue, String aKey )
+    {
+        Object selectedObject = selectedObject();
+        if ( selectedObject == null ) return false;
+        return setValueForObject( aValue, selectedObject, aKey );
+    }
+
+    /**
+    * Sets the specified value for the specified key on
+    * the specified object.  Validations may be triggered,
+    * and error dialogs may appear to the user.
+    * @return True if the value was set successfully,
+    * false if the value could not be set and the update
+    * operation should not continue.
+    */
+    public boolean setValueForObject (
+        Object aValue, Object anObject, String aKey )
+    {
+        // notify object's observers:
+        //   this includes us, and will notify our observers
+        EOObserverCenter.notifyObserversObjectWillChange( anObject );
+
+        //TODO: if key is null, need to remove old object
+        // and add new object instead of simply replacing it.
+
+        try
+        {
+            if ( anObject instanceof EOKeyValueCoding )
+            {
+                ((EOKeyValueCoding)anObject).takeValueForKey( aValue, aKey );
+            }
+            else
+            {
+                EOKeyValueCodingSupport.takeValueForKey( anObject, aValue, aKey );
+            }
+        }
+        catch ( RuntimeException exc )
+        {
+            Object result = notifyDelegate(
+                "displayGroupShouldDisplayAlert",
+                new Class[] { EODisplayGroup.class, String.class, String.class },
+                new Object[] { this, "Error", exc.getMessage() } );
+            if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+            {
+                throw exc;
+            }
+            return false;
+        }
+
+        notifyDelegate(
+            "displayGroupDidSetValueForObject",
+            new Class[] { EODisplayGroup.class, Object.class, Object.class, String.class },
+            new Object[] { this, aValue, anObject, aKey } );
+
+        return true;
+    }
+
+    /**
+    * Calls setValueForObject() for the object at
+    * the specified index.
+    */
+    public boolean setValueForObjectAtIndex (
+        Object aValue, int anIndex, String aKey )
+    {
+        return setValueForObject(
+            aValue, displayedObjects.objectAtIndex( anIndex ), aKey );
+    }
+
+    /**
+    * Returns the value for the specified key on the specified object.
+    */
+    public Object valueForObject ( Object anObject, String aKey )
+    {
+        // empty string is considered the identity property
+        if ( aKey == null ) return anObject;
+        if ( aKey.equals( "" ) ) return anObject;
+
+        try
+        {
+            if ( anObject instanceof EOKeyValueCoding )
+            {
+                return ((EOKeyValueCoding)anObject).valueForKey( aKey );
+            }
+            else
+            {
+                return EOKeyValueCodingSupport.valueForKey( anObject, aKey );
+            }
+        }
+        catch ( RuntimeException exc )
+        {
+            Object result = notifyDelegate(
+                "displayGroupShouldDisplayAlert",
+                new Class[] { EODisplayGroup.class, String.class, String.class },
+                new Object[] { this, "Error", exc.getMessage() } );
+            if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+            {
+                throw exc;
+            }
+            return null;
+        }
+    }
+
+    /**
+    * Calls valueForObject() for the object at the specified index.
+    */
+    public Object valueForObjectAtIndex ( int anIndex, String aKey )
+    {
+        Object o = displayedObjects.objectAtIndex( anIndex );
+        return valueForObject( o, aKey );
+    }
+
+    /**
+    * Prints out the list of displayed objects.
+    */
+    public String toString()
+    {
+        return displayedObjects.toString();
+    }
+
+
+    /**
+    * Handles notifications from the data source's editing context,
+    * looking for InvalidatedAllObjectsInStoreNotification and
+    * ObjectsChangedInEditingContextNotification, refetching in
+    * the former case and updating displayed objects in the latter.
+    * Note: This method is not in the public specification.
+    */
+    public void objectsInvalidatedInEditingContext( NSNotification aNotification )
+    {
+        if ( EOObjectStore.InvalidatedAllObjectsInStoreNotification
+            .equals( aNotification.name() ) )
+        {
+            Object result = notifyDelegate(
+                "displayGroupShouldRefetch",
+                new Class[] { EODisplayGroup.class, NSNotification.class },
+                new Object[] { this, aNotification } );
+            if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+            {
+                fetch();
+            }
+        }
+        else
+        if ( EOEditingContext.ObjectsChangedInEditingContextNotification
+            .equals( aNotification.name() ) )
+        {
+            Object result = notifyDelegate(
+                "displayGroupShouldRedisplay",
+                new Class[] { EODisplayGroup.class, NSNotification.class },
+                new Object[] { this, aNotification } );
+            if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+            {
+                int index;
+                Enumeration e;
+                boolean didChange = false;
+                NSDictionary userInfo = aNotification.userInfo();
+    
+                // inserts are ignored
+    
+                // mark updated objects as updated
+                NSArray updates = (NSArray) userInfo.objectForKey(
+                    EOObjectStore.UpdatedKey );
+                e = updates.objectEnumerator();
+                while ( e.hasMoreElements() )
+                {
+                    index = indexOf( displayedObjects, e.nextElement() );
+                    if ( index != NSArray.NotFound )
+                    {
+                        //System.out.println( "EODisplayGroup: updated: " + index );
+                        if ( ! didChange )
+                        {
+                            didChange = true;
+                            contentsChanged = true;
+                            willChange();
+                            updatedObjectIndex = index;
+                        }
+                        else
+                        {
+                            updatedObjectIndex = -1;
+                        }
+                    }
+                }
+    
+                // treat invalidated objects as updated
+                NSArray invalidates = (NSArray) userInfo.objectForKey(
+                    EOObjectStore.InvalidatedKey );
+                e = invalidates.objectEnumerator();
+                while ( e.hasMoreElements() )
+                {
+                    index = indexOf( displayedObjects, e.nextElement() );
+                    if ( index != NSArray.NotFound )
+                    {
+                        //System.out.println( "EODisplayGroup: invalidated: " + index );
+                        if ( ! didChange )
+                        {
+                            didChange = true;
+                            contentsChanged = true;
+                            willChange();
+                            updatedObjectIndex = index;
+                        }
+                        else
+                        {
+                            updatedObjectIndex = -1;
+                        }
+                    }
+                }
+    
+                // remove deletes from display group if they exist
+                NSArray deletes = (NSArray) userInfo.objectForKey(
+                    EOObjectStore.DeletedKey );
+                e = deletes.objectEnumerator();
+                Object o;
+                while ( e.hasMoreElements() )
+                {
+                    o = e.nextElement();
+                    index = indexOf( displayedObjects, o );
+                    if ( index != NSArray.NotFound )
+                    {
+                        //System.out.println( "EODisplayGroup: deleted: " + o );
+                        deleteObjectAtIndexNoNotify( index );
+                    }
+                }
+                
+                if ( !usesOptimisticRefresh() )
+                {
+                    updateDisplayedObjects();
+                }
+            }
+        }
+
+    }
+
+    // static methods
+
+    /**
+    * Specifies the default behavior for whether changes
+    * should be validated immediately for all display groups.
+    */
+    public static boolean
+        globalDefaultForValidatesChangesImmediately ()
+    {
+        return globalDefaultForValidatesChangesImmediately;
+    }
+
+    /**
+    * Specifies the default string matching format for all
+    * display groups.
+    */
+    public static String globalDefaultStringMatchFormat ()
+    {
+        return globalDefaultStringMatchFormat;
+    }
+
+    /**
+    * Specifies the default string matching operator for all
+    * display groups.
+    */
+    public static String globalDefaultStringMatchOperator ()
+    {
+        return globalDefaultStringMatchOperator;
+    }
+
+    /**
+    * Sets the default behavior for validating changes
+    * for all display groups.
+    */
+    public static void
+    setGlobalDefaultForValidatesChangesImmediately (
+        boolean validatesImmediately )
+    {
+        globalDefaultForValidatesChangesImmediately =
+            validatesImmediately;
+    }
+
+    /**
+    * Sets the default string matching format that
+    * will be used by all display groups.
+    */
+    public static void
+    setGlobalDefaultStringMatchFormat ( String aFormat )
+    {
+        globalDefaultStringMatchFormat = aFormat;
+    }
+
+    /**
+    * Sets the default string matching operator that
+    * will be used by all display groups.
+    */
+    public static void
+    setGlobalDefaultStringMatchOperator ( String anOperator )
+    {
+        globalDefaultStringMatchOperator = anOperator;
+    }
+
+    /**
+    * Needed because we don't inherit from NSObject.
+    * Calls EOObserverCenter.notifyObserversObjectWillChange.
+    */
+    protected void willChange()
+    {
+        EOObserverCenter.notifyObserversObjectWillChange( this );
+    }
+
+    /**
+    * Called by LastGroupObserver to clear flags.
+    */
+    protected void processRecentChanges()
+    {
+        contentsChanged = false;
+        selectionChanged = false;
+    }
+
+    /**
+    * Returns the index of the specified object in the
+    * specified NSArray, comparing by value or by reference
+    * as determined by the private instance variable
+    * compareByReference.  If not found, returns NSArray.NotFound.
+    */
+    private int indexOf( NSArray anArray, Object anObject )
+    {
+        if ( compareByReference )
+        {
+            return anArray.indexOfIdenticalObject( anObject );
+        }
+        else
+        {
+            return anArray.indexOf( anObject );
+        }
+    }
+
+    // interface EOObserving
+
+    /**
+    * Receives notifications of changes from objects that
+    * are managed by this display group.  This implementation
+    * sets updatedObjectIndex and contentsChanged as appropriate.
+    */
+    public void objectWillChange(Object anObject)
+    {
+        int index = indexOf( displayedObjects, anObject );
+        if ( index != NSArray.NotFound )
+        {
+            updatedObjectIndex = index;
+            contentsChanged = true;
+            willChange();
+        }
+    }
+
+    // interface EOEditingContext.Editor
+    
+    /**
+    * Called before the editing context begins to save changes.
+    * This implementation calls endEditing().
+    */
+    public void editingContextWillSaveChanges( 
+        EOEditingContext anEditingContext )
+    {
+        endEditing();
+    }
+
+    /**
+    * Called to determine whether this editor has changes
+    * that have not been committed to the object in the context.
+    */
+    public boolean editorHasChangesForEditingContext(
+        EOEditingContext anEditingContext )
+    {
+        return ( editingAssociation() != null );
+    }
+
+    // interface EOEditingContext.MessageHandler
+    
+    /**
+    * Called to display a message for an error that occurred
+    * in the specified editing context.  If the delegate allows,
+    * this implementation presents an informational JOptionPane.
+    * Override to customize.
+    */
+    public void editingContextPresentErrorMessage( 
+        EOEditingContext anEditingContext,
+        String aMessage )
+    {
+        Object result = notifyDelegate(
+            "displayGroupShouldDisplayAlert",
+            new Class[] { EODisplayGroup.class, String.class, String.class },
+            new Object[] { this, "Error", aMessage } );
+        if ( ( result == null ) || ( Boolean.TRUE.equals( result ) ) )
+        {
+            JOptionPane.showMessageDialog( null, aMessage );
+        }
+    }
+
+    /**
+    * Called by the specified object store to determine whether
+    * fetching should continue, where count is the current count
+    * and limit is the limit as specified by the fetch specification.
+    * This implementation presents an JOptionPane allowing the user
+    * to specify whether to continue.  Override to customize.
+    */
+    public boolean editingContextShouldContinueFetching(
+        EOEditingContext anEditingContext,
+        int count,
+        int limit,
+        EOObjectStore anObjectStore )
+    {
+        return ( JOptionPane.showConfirmDialog( null, 
+            "Fetch limit reached: do you wish to continue?", 
+            "Continue?", 
+            JOptionPane.YES_NO_OPTION ) == JOptionPane.YES_OPTION );
+    }
+
+    /**
+     * Sends the specified message to the delegate.
+     * Returns the return value of the method,
+     * or null if no return value or no delegate
+     * or no implementation.
+     */
+    private Object notifyDelegate( 
+        String aMethodName, Class[] types, Object[] params )
+    {
+        try
+        {
+            Object delegate = delegate();
+            if ( delegate == null ) return null;
+            return NSSelector.invoke( 
+                aMethodName, types, delegate, params );
+        }
+        catch ( NoSuchMethodException e )
+        {
+            // ignore: not implemented
+        }
+        catch ( Exception exc )
+        {
+            // log to standard error
+            System.err.println( 
+                "Error while messaging delegate: " + 
+                    delegate + " : " + aMethodName );
+            exc.printStackTrace();
+        }
+        
+        return null;
+    }
+    
+    /**
+    * DisplayGroups can delegate important decisions to a Delegate.  
+    * Note that DisplayGroup doesn't require its delegates to implement
+    * this interface: rather, this interface defines the methods that
+    * DisplayGroup will attempt to invoke dynamically on its delegate.
+    * The delegate may choose to implement only a subset of the methods
+    * on the interface.
+    */
+    public interface Delegate
+    {
+        /**
+        * Called when the specified data source fails
+        * to create an object for the specified display group.
+        */
+        void displayGroupCreateObjectFailed (
+            EODisplayGroup aDisplayGroup,
+            EODataSource aDataSource );
+
+        /**
+        * Called after the specified display group's
+        * data source is changed.
+        */
+        void displayGroupDidChangeDataSource (
+            EODisplayGroup aDisplayGroup );
+
+        /**
+        * Called after a change occurs in the specified 
+        * display group's selected objects.
+        */
+        void displayGroupDidChangeSelectedObjects (
+            EODisplayGroup aDisplayGroup );
+
+        /**
+        * Called after the specified display group's
+        * selection has changed.
+        */
+        void displayGroupDidChangeSelection (
+            EODisplayGroup aDisplayGroup );
+
+        /**
+        * Called after the specified display group has
+        * deleted the specified object.
+        */
+        void displayGroupDidDeleteObject (
+            EODisplayGroup aDisplayGroup,
+            Object anObject );
+
+        /**
+        * Called after the specified display group
+        * has fetched the specified object list.
+        */
+        void displayGroupDidFetchObjects (
+            EODisplayGroup aDisplayGroup,
+            List anObjectList );
+
+        /**
+        * Called after the specified display group
+        * has inserted the specified object into
+        * its internal object list.
+        */
+        void displayGroupDidInsertObject (
+            EODisplayGroup aDisplayGroup,
+            Object anObject );
+
+        /**
+        * Called after the specified display group
+        * has set the specified value for the specified
+        * object and key.
+        */
+        void displayGroupDidSetValueForObject (
+            EODisplayGroup aDisplayGroup,
+            Object aValue,
+            Object anObject,
+            String aKey );
+
+        /**
+        * Called by the specified display group to
+        * determine what objects should be displayed
+        * for the objects in the specified list.
+        * @return An NSArray containing the objects
+        * to be displayed for the objects in the
+        * specified list.
+        */
+        NSArray displayGroupDisplayArrayForObjects (
+            EODisplayGroup aDisplayGroup,
+            List aList );
+
+        /**
+        * Called by the specified display group before
+        * it attempts to change the selection.
+        * @return True to allow the selection to change,
+        * false otherwise.
+        */
+        boolean displayGroupShouldChangeSelection (
+            EODisplayGroup aDisplayGroup,
+            List aSelectionList );
+
+        /**
+        * Called by the specified display group before
+        * it attempts to delete the specified object.
+        * @return True to allow the object to be deleted
+        * false to prevent the deletion.
+        */
+        boolean displayGroupShouldDeleteObject (
+            EODisplayGroup aDisplayGroup,
+            Object anObject );
+
+        /**
+        * Called by the specified display group before
+        * it attempts display the specified alert to
+        * the user.
+        * @return True to allow the message to be
+        * displayed, false if you want to handle the
+        * alert yourself and suppress the display group's
+        * notification.
+        */
+        boolean displayGroupShouldDisplayAlert (
+            EODisplayGroup aDisplayGroup,
+            String aTitle,
+            String aMessage );
+
+        /**
+        * Called by the specified display group before
+        * it attempts fetch objects.
+        * @return True to allow the fetch to take place,
+        * false to prevent the fetch.
+        */
+        boolean displayGroupShouldFetch (
+            EODisplayGroup aDisplayGroup );
+
+        /**
+        * Called by the specified display group before
+        * it attempts to insert the specified object.
+        * @return True to allow the object to be inserted
+        * false to prevent the insertion.
+        */
+        boolean displayGroupShouldInsertObject (
+            EODisplayGroup aDisplayGroup,
+            Object anObject,
+            int anIndex );
+
+        /**
+        * Called by the specified display group when
+        * it receives the specified 
+        * ObjectsChangedInEditingContextNotification.
+        * @return True to allow the display group to
+        * update the display (recommended), false
+        * to prevent the update.
+        */
+        boolean displayGroupShouldRedisplay (
+            EODisplayGroup aDisplayGroup,
+            NSNotification aNotification );
+
+        /**
+        * Called by the specified display group when
+        * it receives the specified 
+        * InvalidatedAllObjectsInStoreNotification.
+        * @return True to allow the display group to
+        * refetch (recommended), false to prevent the 
+        * refetch.
+        */
+        boolean displayGroupShouldRefetch (
+            EODisplayGroup aDisplayGroup,
+            NSNotification aNotification );
+
+    }
+
+}
+
+    /**
+    * A private class that will serve to clear the contentsChanged
+    * and selectionChanged flags after all Associations have been
+    * notified.
+    */
+    class LastGroupObserver extends EODelayedObserver
+    {
+        Reference ref;
+
+        public LastGroupObserver( EODisplayGroup aDisplayGroup )
+        {
+            ref = new WeakReference( aDisplayGroup );
+        }
+
+        /**
+        * We want to be informed last, after all Associations
+        * have been notified to changes in the DisplayGroup.
+        */
+        public int priority()
+        {
+            return ObserverPrioritySixth;
+        }
+
+        /**
+        * After all Associations have been notified,
+        * clear the contentsChanged and selectionChanged flags.
+        */
+        public void subjectChanged ()
+        {
+            EODisplayGroup group = (EODisplayGroup) ref.get();
+            if ( group != null )
+            {
+                group.processRecentChanges();
+            }
+        }
+    }
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.51  2004/01/28 18:35:40  mpowers
+ * Slight optimization: only comparing list in fetch if we have to.
+ *
+ * Revision 1.50  2004/01/27 20:42:30  mpowers
+ * No longer reselecting first after fetch if contents are identical.
+ *
+ * Revision 1.49  2003/12/18 11:37:45  mpowers
+ * Now calling qualifier internally.
+ *
+ * Revision 1.48  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.47  2003/01/18 23:30:42  mpowers
+ * WODisplayGroup now compiles.
+ *
+ * Revision 1.46  2002/10/24 21:15:36  mpowers
+ * New implementations of NSArray and subclasses.
+ *
+ * Revision 1.45  2002/10/24 18:20:20  mpowers
+ * Because NSArray is read-only, we are returning our internal representations
+ * to callers of allObjects(), displayedObjects(), and selectedObjects().
+ *
+ * Revision 1.44  2002/08/06 18:20:25  mpowers
+ * Now posting DisplayGroupWillFetch notifications before fetch.
+ * Implemented support for usesOptimisticRefresh.
+ * No longer supporting inserted/updated/deleted lists: not part of spec.
+ *
+ * Revision 1.43  2002/05/17 15:01:49  mpowers
+ * Implemented dynamic lookup of delegate methods so delegates no longer
+ * need to implement the DisplayGroup.Delegate interface.
+ *
+ * Revision 1.42  2002/03/26 21:46:06  mpowers
+ * Contributing EditingContext as a java-friendly convenience.
+ *
+ * Revision 1.41  2002/03/11 03:17:56  mpowers
+ * Provided control point for coalesced changes.
+ *
+ * Revision 1.40  2002/03/05 23:18:28  mpowers
+ * Added documentation.
+ * Added isSelectionPaintedImmediate and isSelectionTracking attributes
+ * to TableAssociation.
+ * Added getTableAssociation to TableColumnAssociation.
+ *
+ * Revision 1.39  2002/02/19 22:26:04  mpowers
+ * Implemented EOEditingContext.MessageHandler support.
+ *
+ * Revision 1.38  2002/02/19 16:37:38  mpowers
+ * Implemented support for EOEditingContext.Editor
+ *
+ * Revision 1.37  2001/12/11 22:17:48  mpowers
+ * Now properly handling exceptions in valueForObject.
+ * No longer trying to retain selection based only on index.
+ *
+ * Revision 1.36  2001/11/08 21:42:00  mpowers
+ * Now we know what to do with shouldRefetch and shouldRedisplay.
+ *
+ * Revision 1.35  2001/11/04 18:26:58  mpowers
+ * Fixed bug where exceptions were not properly reported when updating
+ * a value and the display group did not have a delegate.
+ *
+ * Revision 1.34  2001/11/02 20:59:36  mpowers
+ * Now correctly ensuring selected objects are a subset of displayed objects.
+ *
+ * Revision 1.33  2001/10/30 22:56:45  mpowers
+ * Added support for EOQualifier.
+ *
+ * Revision 1.32  2001/10/23 22:27:53  mpowers
+ * Now running at ObserverPrioritySixth.
+ *
+ * Revision 1.31  2001/10/23 18:45:05  mpowers
+ * Rolling back changes.
+ *
+ * Revision 1.28  2001/08/22 19:23:41  mpowers
+ * No longer asserting objects in all objects list.
+ *
+ * Revision 1.27  2001/07/30 16:17:01  mpowers
+ * Minor code cleanup.
+ *
+ * Revision 1.26  2001/07/10 22:49:07  mpowers
+ * Fixed bug in optimization for selectObjectsIdenticalTo (found by Dongzhi).
+ *
+ * Revision 1.25  2001/06/19 15:40:21  mpowers
+ * Now only changing the selection if the new selection is different
+ * from the old.
+ *
+ * Revision 1.24  2001/05/24 17:36:15  mpowers
+ * Fixed problem with selectedObjectsIdenticalTo: it was using compare
+ * by value instead of compare by reference.
+ *
+ * Revision 1.23  2001/05/18 21:09:19  mpowers
+ * Now throwing exceptions if the delegate cannot handle error from update.
+ *
+ * Revision 1.22  2001/05/14 15:26:12  mpowers
+ * Now checking for null delegate before and after selection change.
+ *
+ * Revision 1.21  2001/05/08 18:47:34  mpowers
+ * Minor fixes for d3.
+ *
+ * Revision 1.20  2001/04/29 22:02:45  mpowers
+ * Work on id transposing between editing contexts.
+ *
+ * Revision 1.19  2001/04/13 16:38:09  mpowers
+ * Alpha3 release.
+ *
+ * Revision 1.18  2001/04/03 20:36:01  mpowers
+ * Fixed refaulting/reverting/invalidating to be self-consistent.
+ *
+ * Revision 1.17  2001/03/29 03:31:13  mpowers
+ * No longer using Introspector.
+ *
+ * Revision 1.16  2001/02/27 03:32:18  mpowers
+ * Implemented default values for new objects.
+ *
+ * Revision 1.15  2001/02/27 02:11:17  mpowers
+ * Now throwing exception when cloning fails.
+ * Removed debugging printlns.
+ *
+ * Revision 1.14  2001/02/26 22:41:51  mpowers
+ * Implemented null placeholder classes.
+ * Duplicator now uses NSNull.
+ * No longer catching base exception class.
+ *
+ * Revision 1.13  2001/02/26 15:53:22  mpowers
+ * Fine-tuning notification firing.
+ * Child display groups now update properly after parent save or invalidate.
+ *
+ * Revision 1.12  2001/02/22 20:55:06  mpowers
+ * Implemented notification handling.
+ *
+ * Revision 1.11  2001/02/21 20:40:42  mpowers
+ * setObjectArray now falls back to index when trying to retain the
+ * same selection.
+ *
+ * Revision 1.10  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.9  2001/02/17 17:23:49  mpowers
+ * More changes to support compiling with jdk1.1 collections.
+ *
+ * Revision 1.8  2001/02/17 16:52:05  mpowers
+ * Changes in imports to support building with jdk1.1 collections.
+ *
+ * Revision 1.7  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.6  2001/01/24 14:23:05  mpowers
+ * Added support for OrderedDataSource.
+ *
+ * Revision 1.5  2001/01/12 17:21:37  mpowers
+ * Implicit creation of EOSortOrderings now happens in setSortOrderings.
+ *
+ * Revision 1.4  2001/01/11 20:34:26  mpowers
+ * Implemented EOSortOrdering and added support in framework.
+ * Added header-click to sort table columns.
+ *
+ * Revision 1.3  2001/01/10 22:49:44  mpowers
+ * Implemented similarly named selection methods instead of
+ * throwing exceptions.
+ *
+ * Revision 1.2  2001/01/09 20:12:52  mpowers
+ * Moved inner classes to package access.
+ *
+ * Revision 1.1.1.1  2000/12/21 15:48:20  mpowers
+ * Contributing wotonomy.
+ *
+ * Revision 1.21  2000/12/20 16:25:39  michael
+ * Added log to all files.
+ *
+ * Revision 1.20  2000/12/15 15:04:42  michael
+ * Added doc.
+ *
+ * Revision 1.19  2000/12/11 13:32:48  michael
+ * Finish the much better TreeAssociation implementation.
+ * TreeAssociation now has no gui dependencies.
+ *
+ * Revision 1.18  2000/12/05 17:41:46  michael
+ * Broadcasts selection change after delegate refuses selection change
+ * so the initiating association gets refreshed.
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/GenericAssociation.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/GenericAssociation.java
new file mode 100644
index 0000000..3a4ff08
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/GenericAssociation.java
@@ -0,0 +1,373 @@
+/*
+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;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+import net.wotonomy.control.EOKeyValueCoding;
+import net.wotonomy.control.EOKeyValueCodingSupport;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.foundation.NSArray;
+
+/**
+* GenericAssociation binds one or more properties on an 
+* observable object to a display group.  The controlled
+* object is expected to use the ObserverCenter and will
+* be observed by this association. <br><br>
+*
+* Bindings for this association are <i>generic</i>: the 
+* name of the aspect will be treated as a property key 
+* on the displayed object(s) and synchronized with the 
+* bound property on the controlled object. <br><br>
+*
+* NOTE: because we cannot assume that the controlled
+* object will retain a reference to this association,
+* you must explicitly retain a reference to prevent
+* the association from getting garbage collected.
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class GenericAssociation extends EOAssociation
+{
+    protected boolean objectModified;
+    protected Set aspectsModified;
+    
+    static final NSArray aspects = 
+        new NSArray( new Object[] {
+        } );
+    static final NSArray aspectSignatures = 
+        new NSArray( new Object[] {
+        } );
+    static final NSArray objectKeysTaken = 
+        new NSArray( new Object[] {
+        } );
+		
+    /**
+    * Constructor specifying the object to be controlled by this
+    * association.  Does not establish connection.
+    */
+    public GenericAssociation ( Object anObject )
+    {
+        super( anObject );
+        objectModified = false;
+        aspectsModified = new HashSet();
+    }
+    
+    /**
+    * Returns a List of aspect signatures whose contents
+    * correspond with the aspects list.  Each element is 
+    * a string whose characters represent a capability of
+    * the corresponding aspect. <ul>
+    * <li>"A" attribute: the aspect can be bound to
+    * an attribute.</li>
+    * <li>"1" to-one: the aspect can be bound to a
+    * property that returns a single object.</li>
+    * <li>"M" to-one: the aspect can be bound to a
+    * property that returns multiple objects.</li>
+    * </ul> 
+    * An empty signature "" means that the aspect can
+    * bind without needing a key.
+    * This implementation returns "A1M" for each
+    * element in the aspects array.
+    */
+    public static NSArray aspectSignatures ()
+    {
+        return aspectSignatures;
+    }
+    
+    /**
+    * Returns a List that describes the aspects supported
+    * by this class.  Each element in the list is the string
+    * name of the aspect.  This implementation returns an
+    * empty list.
+    */
+    public static NSArray aspects ()
+    {
+        return aspects;
+    }
+    
+    /**
+    * Returns a List of EOAssociation subclasses that,
+    * for the objects that are usable for this association,
+    * are less suitable than this association.
+    */
+    public static NSArray associationClassesSuperseded ()
+    {
+        return new NSArray();
+    }
+    
+    /**
+    * Returns whether this class can control the specified 
+    * object. 
+    */
+    public static boolean isUsableWithObject ( Object anObject )
+    {
+        return true;
+    }
+    
+    /**
+    * Returns a List of properties of the controlled object
+    * that are controlled by this class.  For example,
+    * "stringValue", or "selected".
+    */
+    public static NSArray objectKeysTaken ()
+    {
+        return objectKeysTaken;
+    }
+    
+    /**
+    * Returns the aspect that is considered primary
+    * or default.  This is typically "value" or somesuch.
+    */
+    public static String primaryAspect ()
+    {
+        return "";
+    }
+        
+    /**
+    * Returns whether this association can bind to the
+    * specified display group on the specified key for
+    * the specified aspect.  
+    */
+    public boolean canBindAspect ( 
+        String anAspect, EODisplayGroup aDisplayGroup, String aKey)
+    {
+        return true;
+    }
+    
+    /**
+    * Establishes a connection between this association
+    * and the controlled object.  This implementation 
+	* registers with ObserverCenter for change notifications
+    * from the controlled object.
+    */
+    public void establishConnection ()
+    {
+		EOObserverCenter.addObserver( this, object() );
+        super.establishConnection();
+		
+		// forces update from bindings
+		subjectChanged();
+    }
+	
+    /**
+    * Breaks the connection between this association and 
+    * its object.  Override to stop listening for events
+    * from the object.
+    */
+    public void breakConnection ()
+    {
+		EOObserverCenter.removeObserver( this, object() );
+        super.breakConnection();
+    }
+    
+    /**
+    * Overridden to track which observed object is changing.
+    */
+    public void objectWillChange( Object anObject )
+    {
+        if ( object() == anObject ) 
+        { 
+            objectModified = true;
+        }
+        else
+        {
+            aspectsModified.add( aspectToGroup.allKeysForObject( anObject ) );
+        }
+    }
+
+    /**
+    * Called when either the selection or the contents 
+    * of an associated display group have changed.
+    */
+    public void subjectChanged ()
+    {
+        String aspect;
+        String key;
+        Object value;
+        EODisplayGroup displayGroup;
+        Iterator iterator;
+        
+        iterator = aspectsModified.iterator();
+        while ( iterator.hasNext() )
+        {
+            aspect = (String) iterator.next();
+            key = displayGroupKeyForAspect( aspect );
+            displayGroup = displayGroupForAspect( aspect );
+
+            value = readValueFromDisplayGroupForKey( displayGroup, key );    
+            writeValueForKey( object(), value, key );
+        }
+        aspectsModified.clear();
+        
+        if ( objectModified )
+        {
+            iterator = aspectToGroup.keySet().iterator();
+            while ( iterator.hasNext() )
+            {
+                aspect = (String) iterator.next();
+                key = displayGroupKeyForAspect( aspect );
+                value = readValueForKey( object(), key );
+                displayGroup = displayGroupForAspect( aspect );
+                displayGroup.setSelectedObjectValue( value, key );
+            }
+        }
+    }
+    
+    protected Object readValueForKey( Object object, String key )
+    {
+        if ( object instanceof EOKeyValueCoding )
+        {
+            return ((EOKeyValueCoding)object).valueForKey( key );
+        }
+        return EOKeyValueCodingSupport.valueForKey( object, key );
+    }
+    
+    protected void writeValueForKey( Object object, Object value, String key )
+    {
+        if ( object instanceof EOKeyValueCoding )
+        {
+            ((EOKeyValueCoding)object).takeValueForKey( value, key );
+        }
+        else
+        {
+            EOKeyValueCodingSupport.takeValueForKey( object, value, key );
+        }
+    }
+    
+    protected Object readValueFromDisplayGroupForKey( 
+        EODisplayGroup displayGroup, String key )
+    {
+        Object value;
+        
+        if ( displayGroup.selectedObjects().size() > 1 )
+        {
+            // if there're more than one object selected, set
+            // the value to blank for all of them.
+            Object previousValue;
+
+            Iterator indexIterator = displayGroup.selectionIndexes().
+                                      iterator();
+
+            // get value for the first selected object.
+            int initialIndex = ( (Integer)indexIterator.next() ).intValue();
+            previousValue = displayGroup.valueForObjectAtIndex(
+                                      initialIndex, key );
+            value = null;
+
+            // go through the rest of the selected objects, compare each
+            // value with the previous one. continue comparing if two
+            // values are equal, break the while loop if they're different.
+            // the final value will be the common value of all selected objects
+            // if there is one, or be blank if there is not.
+            while ( indexIterator.hasNext() )
+            {
+                int index = ( (Integer)indexIterator.next() ).intValue();
+                Object currentValue = displayGroup.valueForObjectAtIndex(
+                                      index, key );
+                if ( currentValue != null && !currentValue.equals( previousValue ) )
+                {
+                    value = null;
+                    break;
+                }
+                else
+                {
+                    // currentValue is the same as the previous one
+                    value = currentValue;
+                }
+
+            } // end while
+
+        } else {
+
+            value = displayGroup.selectedObjectValueForKey( key );
+        } // end checking size of displayGroup
+        
+        return value;
+    }
+	
+	/**
+	* Writes the value currently in the component
+	* to the selected object in the display group
+	* bound to the value aspect.
+    * @return false if there were problems validating,
+    * or true to continue.
+	*/
+	protected boolean writeValueForAspect( Object value, String aspect )
+	{
+		EODisplayGroup displayGroup = 
+			displayGroupForAspect( aspect );
+		if ( displayGroup != null )
+		{
+			String key = displayGroupKeyForAspect( aspect );
+
+            boolean returnValue = true;
+            Iterator selectedIterator = displayGroup.selectionIndexes().iterator();
+            while ( selectedIterator.hasNext() )
+            {
+                int index = ( (Integer)selectedIterator.next() ).intValue();
+
+                if ( !displayGroup.setValueForObjectAtIndex( value, index, key ) )
+                {
+                    returnValue = false;
+                }
+            }
+            return returnValue;
+		}
+		return false;
+	}
+
+    /**
+    * Forces this association to cause the object to 
+    * stop editing and validate the user's input.
+    * @return false if there were problems validating,
+    * or true to continue.
+    */
+    public boolean endEditing ()
+    {        
+        return false;
+//!	    return writeValueToDisplayGroup();
+    }
+	
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.3  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.2  2001/11/08 19:51:24  mpowers
+ * Draft implementation.
+ *
+ * Revision 1.1  2001/11/02 23:15:04  mpowers
+ * Contributing "generic association".
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MasterDetailAssociation.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MasterDetailAssociation.java
new file mode 100644
index 0000000..2aea8d3
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MasterDetailAssociation.java
@@ -0,0 +1,406 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui;
+
+import net.wotonomy.control.EOClassDescription;
+import net.wotonomy.control.EODataSource;
+import net.wotonomy.control.EOEditingContext;
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.control.PropertyDataSource;
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSMutableArray;
+
+/**
+* MasterDetailAssociation binds a display group to a property
+* on the selected object of another display group.
+* Bindings are: 
+* <ul>
+* <li>parent: The property on the selected object of the
+* bound display group that is expected to be an indexed property.</li> 
+* </ul>
+*
+* @author michael@mpowers.net
+* @author $Author: cgruber $
+* @version $Revision: 904 $
+*/
+public class MasterDetailAssociation extends EOAssociation
+{
+    static final NSArray aspects = 
+        new NSArray( new Object[] {
+            ParentAspect
+        } );
+    static final NSArray aspectSignatures = 
+        new NSArray( new Object[] {
+            AttributeToOneAspectSignature
+        } );
+    static final NSArray objectKeysTaken = 
+        new NSArray( new Object[] {
+            "allObjects" 
+        } );
+
+    /**
+    * Used to be notified of changes to objects in the
+    * controlled display group.  requalify() should place 
+    * all objects fetched into the controlled group into
+    * this array.
+    * Otherwise, the parent object is only marked as 
+    * changed for inserts and deletes.
+    */
+    protected NSMutableArray observableArray;
+		
+    /**
+    * Constructor expecting an EODisplayGroup. 
+    * If the controlled display group does not have a data source,
+    * a new PropertyDataSource will be used.
+    */
+    public MasterDetailAssociation ( Object anObject )
+    {
+        super( anObject );
+        observableArray = new ObservableArray( this );
+    }
+    
+    /**
+    * Returns a List of aspect signatures whose contents
+    * correspond with the aspects list.  Each element is 
+    * a string whose characters represent a capability of
+    * the corresponding aspect. <ul>
+    * <li>"A" attribute: the aspect can be bound to
+    * an attribute.</li>
+    * <li>"1" to-one: the aspect can be bound to a
+    * property that returns a single object.</li>
+    * <li>"M" to-one: the aspect can be bound to a
+    * property that returns multiple objects.</li>
+    * </ul> 
+    * An empty signature "" means that the aspect can
+    * bind without needing a key.
+    * This implementation returns "A1M" for each
+    * element in the aspects array.
+    */
+    public static NSArray aspectSignatures ()
+    {
+        return aspectSignatures;
+    }
+    
+    /**
+    * Returns a List that describes the aspects supported
+    * by this class.  Each element in the list is the string
+    * name of the aspect.  This implementation returns an
+    * empty list.
+    */
+    public static NSArray aspects ()
+    {
+        return aspects;
+    }
+    
+    /**
+    * Returns a List of EOAssociation subclasses that,
+    * for the objects that are usable for this association,
+    * are less suitable than this association.
+    */
+    public static NSArray associationClassesSuperseded ()
+    {
+        return new NSArray();
+    }
+    
+    /**
+    * Returns whether this class can control the specified 
+    * object. 
+    */
+    public static boolean isUsableWithObject ( Object anObject )
+    {
+        return ( anObject instanceof EODisplayGroup );
+    }
+    
+    /**
+    * Returns a List of properties of the controlled object
+    * that are controlled by this class.  For example,
+    * "stringValue", or "selected".
+    */
+    public static NSArray objectKeysTaken ()
+    {
+        return objectKeysTaken;
+    }
+    
+    /**
+    * Returns the aspect that is considered primary
+    * or default.  This is typically "value" or somesuch.
+    */
+    public static String primaryAspect ()
+    {
+        return ParentAspect;
+    }
+        
+    /**
+    * Returns whether this association can bind to the
+    * specified display group on the specified key for
+    * the specified aspect.  
+    */
+    public boolean canBindAspect ( 
+        String anAspect, EODisplayGroup aDisplayGroup, String aKey)
+    {
+        return ( aspects.containsObject( anAspect ) );
+    }
+    
+    /**
+    * Establishes a connection between this association
+    * and the controlled object.  Subclasses should begin
+    * listening for events from their controlled object here.
+    */
+    public void establishConnection ()
+    {
+        //NOTE: if nothing refers to this assocation, it gets gc'd.
+        // otherwise, this is not needed.
+        component().addObserver( this );
+
+        EODisplayGroup displayGroup = 
+            displayGroupForAspect( ParentAspect );
+        String key = 
+            displayGroupKeyForAspect( ParentAspect );
+
+        // obtain and qualify new data source from existing source if necessary
+        if ( component().dataSource() == null ) 
+        {
+            if ( ( displayGroup != null ) && ( displayGroup.dataSource() != null ) )
+            {
+                component().setDataSource( 
+                    displayGroup.dataSource().
+                        dataSourceQualifiedByKey( key ) );
+            }
+        }
+
+        // set up proxy data source if necessary
+        if ( component().dataSource() == null )
+        {
+            // get context and class desc from master group
+            EOEditingContext editingContext = null;
+            EOClassDescription classDesc = null;
+            if ( displayGroup != null )
+            {
+                EODataSource dataSource = displayGroup.dataSource();
+                if ( dataSource != null )
+                {
+                    editingContext = dataSource.editingContext();
+                    EOClassDescription parentDesc = dataSource.classDescriptionForObjects();
+                    if ( parentDesc != null )
+                    {
+                        classDesc = parentDesc.classDescriptionForDestinationKey( key );   
+                    }
+                }
+            }
+            
+            //FIXME: should this be called DetailDataSource?
+            component().setDataSource( 
+               new PropertyDataSource( editingContext, classDesc ) );
+        }
+
+        super.establishConnection();
+		requalify();
+    }
+    
+    /**
+    * Breaks the connection between this association and 
+    * its object.  Override to stop listening for events
+    * from the object.
+    */
+    public void breakConnection ()
+    {
+        //NOTE: if nothing refers to this assocation, it gets gc'd.
+        // otherwise, this is not needed.
+        component().deleteObserver( this );        
+
+        super.breakConnection();
+    }
+	
+    /**
+    * Called when either the selection or the contents 
+    * of an associated display group have changed.
+    */
+    public void subjectChanged ()
+    {
+		EODisplayGroup displayGroup;
+
+		// parent aspect
+		displayGroup = displayGroupForAspect( ParentAspect );
+		if ( displayGroup != null )
+		{
+			if ( displayGroup.selectionChanged() )
+			{
+                requalify();
+			}
+			else
+			if ( displayGroup.contentsChanged() )
+			{
+                requalify();
+			}
+		}
+    }
+
+    /**
+    * Overridden to intercept notifications of changes to objects 
+    * in the controlled display group and broadcast a change on the 
+    * parent group's selected object.  All other notifications are
+    * passed to the super implementation.
+    */
+    public void objectWillChange ( Object anObject )
+    {
+        // if child display group is notifying
+        if ( ! ( anObject instanceof EODisplayGroup ) )
+        {
+            // mark parent group's object as changed
+            EODisplayGroup displayGroup = displayGroupForAspect( ParentAspect );
+            if ( displayGroup != null )
+            {
+                Object selected = displayGroup.selectedObject();
+                if ( selected != null )
+                {
+                    // only notify if childrenKey is an attribute of parentDesc
+                    // (and therefore not a toOne or toMany relationship)
+                    EOClassDescription parentDesc = 
+                        EOClassDescription.classDescriptionForClass( 
+                            selected.getClass() );
+                    String key = displayGroupKeyForAspect( ParentAspect );
+                    if ( key != null )
+                    {
+                        int idx = key.indexOf( '.' );
+                        if ( idx != -1 ) key = key.substring( 0, idx );
+                        if ( parentDesc.attributeKeys().contains( key ) )
+                        {
+                            // only notify if we are an attribute key
+                            EOObserverCenter.notifyObserversObjectWillChange( selected );
+                        }
+                    }
+                }
+            }
+        }
+        else // display group is notifying
+        {
+            // call super so subjectChanged will be called
+            super.objectWillChange( anObject );
+        }
+    }
+    
+    /**
+    * Called by subjectChanged() to requalify the controlled
+    * display group with the selected object and the bound key.
+    */
+	protected void requalify()
+	{
+		EODisplayGroup component = component();
+		EODisplayGroup displayGroup = displayGroupForAspect( ParentAspect );
+		String key = displayGroupKeyForAspect( ParentAspect );
+		
+		if ( ( displayGroup.selectedObject() != null )
+        && ( component.dataSource() != null ) )
+		{
+			component.dataSource().qualifyWithRelationshipKey( 
+				key, displayGroup.selectedObject() );  
+			component.fetch();
+            observableArray.setArray( component.allObjects() );
+		}
+		else // no selection or no data source, clear
+		{
+			component.setObjectArray( null );
+            observableArray.removeAllObjects();
+		}
+        component.updateDisplayedObjects();
+	}
+                  
+    /**
+	* This implementation returns ObserverPrioritySecond
+	* so that master detail assocations are notified before
+    * other associations.
+    */
+    public int priority ()
+    {
+        return ObserverPrioritySecond;
+    }
+
+	// convenience
+
+    private EODisplayGroup component()
+    {
+        return (EODisplayGroup) object();
+    }
+    
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.14  2004/02/04 20:00:49  mpowers
+ * Improved change notification for dotted key paths.
+ *
+ * Revision 1.13  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.12  2001/10/26 18:39:05  mpowers
+ * Now a delayed observer with a higher priority, so that it is processed
+ * before other associations.
+ *
+ * Revision 1.11  2001/06/26 21:39:33  mpowers
+ * Added check for null component data source before requalifying.
+ *
+ * Revision 1.10  2001/05/21 14:04:15  mpowers
+ * No longer changing a detail group's data source if it's already specified.
+ *
+ * Revision 1.9  2001/05/18 21:08:46  mpowers
+ * Now calling updateDisplayedObjects on detail after master changes.
+ *
+ * Revision 1.8  2001/05/14 15:26:42  mpowers
+ * Modified logic for controlled groups that have no data source already set.
+ *
+ * Revision 1.7  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.6  2001/04/29 02:29:31  mpowers
+ * Debugging relationship faulting.
+ *
+ * Revision 1.4  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.3  2001/01/18 16:57:18  mpowers
+ * Fixed problem with losing connection: the association was getting
+ * garbage collected because nothing referred to it.  All other associations
+ * make themselves listeners of their controlled object, and that has been
+ * the only thing keeping them from getting gc'd.  This will need to be fixed.
+ *
+ * Revision 1.2  2001/01/17 23:06:09  mpowers
+ * TreeAssociation now modifies the contents of the children display
+ * group rather than adding items to the titles display group.
+ *
+ * Revision 1.1.1.1  2000/12/21 15:48:23  mpowers
+ * Contributing wotonomy.
+ *
+ * Revision 1.5  2000/12/20 16:25:40  michael
+ * Added log to all files.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MirrorDetailAssociation.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MirrorDetailAssociation.java
new file mode 100644
index 0000000..aeac376
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/MirrorDetailAssociation.java
@@ -0,0 +1,106 @@
+/*
+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;
+import net.wotonomy.foundation.NSArray;
+
+/**
+* This master detail association synchronizes the contents
+* and selection of the master group into the detail group.
+*/
+public class MirrorDetailAssociation extends MasterDetailAssociation{
+
+    /** 
+    * Standard constructor specifying the detail display group.
+    * @param displayGroup the detail display group of this 
+    * Master-Detail Association
+    */
+    public MirrorDetailAssociation(EODisplayGroup displayGroup){
+        super(displayGroup);
+    }
+
+    /**
+    * Called by subjectChanged() to requalify the controlled
+    * display group with the indexed object and the bound key.
+    * This implementation ignores both and sets the object array
+    * of the detail group to the displayed objects of the master
+    * and sets the selection to match.
+    */
+    protected void requalify()
+    {
+        EODisplayGroup detail = (EODisplayGroup) object();
+        EODisplayGroup master =
+            displayGroupForAspect( ParentAspect );
+
+        if ( master != null )
+        {
+            NSArray masterObjects = master.displayedObjects();
+            NSArray detailObjects = detail.displayedObjects();
+            int size = masterObjects.size();
+            boolean different = false;
+            
+            // see if lists contain the same object instances
+            if ( size == detailObjects.size() )
+            {
+                for ( int i = 0; i < size; i++ )
+                {
+                    if ( masterObjects.objectAtIndex(i) 
+                      != detailObjects.objectAtIndex(i) )
+                    {
+                        different = true;
+                        break;
+                    }
+                }
+            }
+            else // different sizes
+            {
+                different = true;
+            }
+            
+            // if different, sync contents and selection with master
+            if ( different )
+            {
+                detail.setObjectArray( masterObjects );
+                detail.setSelectionIndexes( master.selectionIndexes() );
+            }
+            else // if selection changed, sync selection with master
+            if ( master.selectionChanged() )
+            {
+                detail.setSelectionIndexes( master.selectionIndexes() );
+            }
+        }
+        else // no bound display group, clear
+        {
+            detail.setObjectArray( null );
+        }
+    }
+}
+/*
+ * $Log$
+ * Revision 1.1  2006/02/16 13:22:22  cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.2  2001/07/05 22:13:28  mpowers
+ * Now only updating if master has actually changed.
+ *
+ * Revision 1.1  2001/05/29 19:57:47  mpowers
+ * Added some neglected files.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/ObservableArray.java b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/ObservableArray.java
new file mode 100644
index 0000000..a398e97
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/ObservableArray.java
@@ -0,0 +1,349 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2001 Michael Powers
+
+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;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+
+import net.wotonomy.control.EOObserverCenter;
+import net.wotonomy.control.EOObserving;
+import net.wotonomy.foundation.NSMutableArray;
+import net.wotonomy.foundation.NSRange;
+
+/**
+* A package class that extends NSMutableArray but makes use
+* of the fact that wotonomy's implementation extends ArrayList
+* to intercept insertions and deletion and register and 
+* unregister objects for change notifications as appropriate.
+* Since we can't be sure of ArrayList's implementation, we're
+* forced to override each and every add and remove method,
+* some of which probably call each other.  However, 
+* EOObserverCenter will only register us once per object.
+*/
+class ObservableArray extends NSMutableArray
+{
+    EOObserving observer;
+    
+    ObservableArray( EOObserving anObserver )
+    {
+        observer = anObserver;
+    }
+    
+	/**
+	* Removes the last object from the array.
+	*/
+    public void removeLastObject ()
+    {
+		remove( count() - 1 );    
+    }
+
+	/**
+	* Removes the object at the specified index.
+	*/
+    public void removeObjectAtIndex (int index)
+    {
+    	remove( index );
+    }
+
+	/**
+	* Adds all objects in the specified collection.
+	*/
+    public void addObjectsFromArray (Collection aCollection)
+    {
+    	addAll( aCollection );
+    }
+
+	/**
+	* Removes all objects from the array.
+	*/
+    public void removeAllObjects ()
+    {
+    	clear();
+    }
+
+	/**
+	* Removes all objects equivalent to the specified object
+	* within the range of specified indices.
+	*/
+    public void removeObject (Object anObject, NSRange aRange)
+    {
+    	if ( ( anObject == null ) || ( aRange == null ) ) return;
+	    
+	    int loc = aRange.location();
+	    int max = aRange.maxRange();
+	    for ( int i = loc; i < max; i++ )
+	    {
+	    	if ( anObject.equals( get( i ) ) )
+		    {
+		    	remove( i );
+			    i = i - 1;
+			    max = max - 1;
+		    }
+	    }
+    }
+
+	/**
+	* Removes all instances of the specified object within the 
+	* range of specified indices, comparing by reference.
+	*/
+    public void removeIdenticalObject (Object anObject, NSRange aRange)
+    {
+    	if ( ( anObject == null ) || ( aRange == null ) ) return;
+	    
+	    int loc = aRange.location();
+	    int max = aRange.maxRange();
+	    for ( int i = loc; i < max; i++ )
+	    {
+	    	if ( anObject == get( i ) )
+		    {
+		    	remove( i );
+			    i = i - 1;
+			    max = max - 1;
+		    }
+	    }
+    }
+
+	/**
+	* Removes all objects in the specified collection from the array.
+	*/
+    public void removeObjectsInArray (Collection aCollection)
+    {
+    	removeAll( aCollection );
+    }
+
+	/**
+	* Removes all objects in the indices within the specified range 
+	* from the array.
+	*/
+    public void removeObjectsInRange (NSRange aRange)
+    {
+    	if ( aRange == null ) return;
+	    
+	    for ( int i = 0; i < aRange.length(); i++ )
+	    {
+	    	remove( aRange.location() );
+	    }
+    }
+
+	/**
+	* Replaces objects in the current range with objects from
+	* the specified range of the specified array.  If currentRange
+	* is larger than otherRange, the extra objects are removed.
+	* If otherRange is larger than currentRange, the extra objects
+	* are added.
+	*/
+    public void replaceObjectsInRange (NSRange currentRange, 
+    	List otherArray, NSRange otherRange)
+	{
+		if ( ( currentRange == null ) || ( otherArray == null ) ||
+			( otherRange == null ) ) return;
+	
+		// transform otherRange if out of bounds for array
+		if ( otherRange.maxRange() > otherArray.size() )
+		{
+			// TODO: Test this logic.
+			int loc = Math.min( otherRange.location(), otherArray.size() - 1 );
+			otherRange = new NSRange( loc, otherArray.size() - loc ); 
+		}
+		
+		Object o;
+		List subList = subList( 
+			currentRange.location(), currentRange.maxRange() );
+		int otherIndex = otherRange.location();
+		// TODO: Test this logic.
+		for ( int i = 0; i < subList.size(); i++ )
+		{
+			if ( otherIndex < otherRange.maxRange() )
+			{ // set object
+				subList.set( i, otherArray.get( otherIndex ) ); 
+			}
+			else
+			{ // remove extra elements from currentRange
+				subList.remove( i );
+				i--; 
+			}
+			otherIndex++;
+		}
+		// TODO: Test this logic.
+		for ( int i = otherIndex; i < otherRange.maxRange(); i++ )
+		{
+			add( otherArray.get( i ) );
+		}
+	}
+
+	/**
+	* Clears the current array and then populates it with the
+	* contents of the specified collection.
+	*/
+    public void setArray (Collection aCollection)
+    {
+    	clear();
+	    addAll( aCollection );
+    }
+
+	/**
+	* Removes all objects equivalent to the specified object. 
+	*/
+    public void removeObject (Object anObject)
+    {
+        remove( anObject );
+    }
+
+	/**
+	* Removes all occurences of the specified object,
+	* comparing by reference.
+	*/
+    public void removeIdenticalObject (Object anObject)
+    {
+        EOObserverCenter.removeObserver( observer, anObject );
+        super.removeIdenticalObject( anObject );
+    }
+
+	/**
+	* Inserts the specified object into this array at the
+	* specified index.
+	*/
+    public void insertObjectAtIndex (Object anObject, int anIndex)
+    {
+    	add( anIndex, anObject );
+    }
+    
+	/**
+	* Replaces the object at the specified index with the 
+	* specified object.
+	*/
+    public void replaceObjectAtIndex (int anIndex, Object anObject)
+    {
+    	set( anIndex, anObject );
+    }
+
+	/**
+	* Adds the specified object to the end of this array.
+	*/
+    public void addObject (Object anObject) 
+    {
+    	add( anObject );
+    }
+    
+    // interface List: mutators
+
+	public void add(int index, Object element) 
+    {
+        EOObserverCenter.addObserver( observer, element );
+        super.add( index, element );
+    }
+    
+	public boolean add(Object o)
+    {
+        EOObserverCenter.addObserver( observer, o );
+        return super.add(o);
+    }
+
+	public boolean addAll(Collection coll) 
+    {
+        Iterator it = coll.iterator();
+        while ( it.hasNext() )
+        {
+            EOObserverCenter.addObserver( observer, it.next() );
+        }
+        return super.addAll(coll);
+    }
+
+	public boolean addAll(int index, Collection c) 
+    {
+        Iterator it = c.iterator();
+        while ( it.hasNext() )
+        {
+            EOObserverCenter.addObserver( observer, it.next() );
+        }
+        return super.addAll( index, c );
+    }
+    
+	public void clear() 
+    {
+        Iterator it = iterator();
+        while ( it.hasNext() )
+        {
+            EOObserverCenter.removeObserver( observer, it.next() );
+        }
+        super.clear();
+    }
+
+	public Object remove(int index) 
+    {
+        EOObserverCenter.removeObserver( observer, get(index) );
+        return super.remove( index );
+    }
+    
+	public boolean remove(Object o) 
+    {
+        EOObserverCenter.removeObserver( observer, o );
+        return super.remove(o);
+    }
+
+	public boolean removeAll(Collection coll) 
+    {
+        Iterator it = coll.iterator();
+        while ( it.hasNext() )
+        {
+            EOObserverCenter.removeObserver( observer, it.next() );
+        }
+        return super.removeAll(coll);
+    }
+
+	public boolean retainAll(Collection coll) 
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    public Object set(int index, Object element) 
+    {
+        EOObserverCenter.removeObserver( observer, get(index) );
+        EOObserverCenter.addObserver( observer, element );
+        return super.set( index, element );
+    }
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:14:35  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.3  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.2  2002/10/24 21:15:36  mpowers
+ * New implementations of NSArray and subclasses.
+ *
+ * Revision 1.1  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.1  2001/01/24 14:37:24  mpowers
+ * Contributing a delegate useful for debugging.
+ *
+ *
+ */
+
diff --git a/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/package.html b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/package.html
new file mode 100644
index 0000000..710c57b
--- /dev/null
+++ b/projects/net.wotonomy.ui/src/main/java/net/wotonomy/ui/package.html
@@ -0,0 +1,14 @@
+<body>
+<p>
+An implementation of the JavaClient
+framework.  It tries to be API-compatible at the
+EODisplayGroup and EOAssociation layer.  The
+associations themselves are inspired by their EO
+counterparts, but are extended so as to be 
+more useful for java application development.
+</p>
+<p>
+This package has dependencies on the control,
+foundation, and util packages.
+</p>
+</body>