Initial import from SVN

1 files changed, 613 insertions, 0 deletions

diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DateAssociation.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DateAssociation.java
new file mode 100644
index 0000000..ba50879
--- /dev/null
+++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/DateAssociation.java
@@ -0,0 +1,613 @@
+/*
+Wotonomy: OpenStep design patterns for pure Java applications.
+Copyright (C) 2000 Intersect Software Corporation
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, see http://www.gnu.org
+*/
+
+package net.wotonomy.ui.swing;
+
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.FocusEvent;
+import java.awt.event.FocusListener;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.Enumeration;
+import java.util.Iterator;
+
+import net.wotonomy.foundation.NSArray;
+import net.wotonomy.foundation.NSSelector;
+import net.wotonomy.foundation.internal.ValueConverter;
+import net.wotonomy.foundation.internal.WotonomyException;
+import net.wotonomy.ui.EOAssociation;
+import net.wotonomy.ui.EODisplayGroup;
+
+/**
+* DateAssociation binds any component that has a set and get Date methods and
+* fire actions events when the date has been changed.  Bindings are:
+* <ul>
+* <li>value: a property convertable to/from a date</li>
+* <li>editable: a boolean property that determines whether
+* the user can edit the date in the component</li>
+* <li>enabled: a boolean property that determines whether
+* the component is enabled or disabled</li>
+* </ul>
+*
+* @author rob@yahoo.com
+* @version $Revision: 904 $
+*/
+public class DateAssociation extends EOAssociation
+                             implements ActionListener, FocusListener
+{
+    static final NSArray aspects =
+        new NSArray( new Object[] {
+            ValueAspect, EnabledAspect, EditableAspect
+        } );
+    static final NSArray aspectSignatures =
+        new NSArray( new Object[] {
+            AttributeToOneAspectSignature,
+			AttributeToOneAspectSignature,
+			AttributeToOneAspectSignature
+        } );
+    static final NSArray objectKeysTaken =
+        new NSArray( new Object[] {
+            "date", "enabled", "editable"
+        } );
+
+	private final static NSSelector getDate =
+		new NSSelector( "getDate" );
+	private final static NSSelector setDate =
+		new NSSelector( "setDate",
+		new Class[] { Date.class } );
+	private final static NSSelector addActionListener =
+		new NSSelector( "addActionListener",
+		new Class[] { ActionListener.class } );
+	private final static NSSelector removeActionListener =
+		new NSSelector( "removeActionListener",
+		new Class[] { ActionListener.class } );
+	private final static NSSelector addFocusListener =
+		new NSSelector( "addFocusListener",
+		new Class[] { FocusListener.class } );
+	private final static NSSelector removeFocusListener =
+		new NSSelector( "removeFocusListener",
+		new Class[] { FocusListener.class } );
+	private final static NSSelector setEditable =
+		new NSSelector( "setEditable",
+		new Class[] { boolean.class } );
+
+	// dirty handling
+	private boolean needsUpdate;
+    private Date nullValue; // placeholder for null value flag
+
+    /**
+    * Constructor specifying the object to be controlled by this
+    * association.  Does not establish connection.
+    */
+    public DateAssociation ( Object anObject )
+    {
+        super( anObject );
+		needsUpdate = false;
+        nullValue = null;
+    }
+
+    /**
+    * 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 setDate.implementedByObject( anObject );
+    }
+
+    /**
+    * 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 ValueAspect;
+    }
+
+    /**
+    * 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.  This implementation
+	* attempts to add this class as an ActionListener
+	* and Focus Listener to the specified object.
+    */
+    public void establishConnection ()
+    {
+		Object component = object();
+		try
+		{
+			if ( addActionListener.implementedByObject( component ) )
+			{
+				addActionListener.invoke( component, this );
+			}
+			if ( addFocusListener.implementedByObject( component ) )
+			{
+				addFocusListener.invoke( component, this );
+			}
+		}
+		catch ( Exception exc )
+		{
+			throw new WotonomyException(
+				"Error while establishing connection", exc );
+		}
+
+        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 ()
+    {
+		Object component = object();
+		try
+		{
+			if ( removeActionListener.implementedByObject( component ) )
+			{
+				removeActionListener.invoke( component, this );
+			}
+			if ( removeFocusListener.implementedByObject( component ) )
+			{
+				removeFocusListener.invoke( component, this );
+			}
+		}
+		catch ( Exception exc )
+		{
+			throw new WotonomyException(
+				"Error while breaking connection", exc );
+		}
+        super.breakConnection();
+    }
+
+    /**
+    * Called when either the selection or the contents
+    * of an associated display group have changed.
+    */
+    public void subjectChanged ()
+    {
+		Object component = object();
+		EODisplayGroup displayGroup;
+		String key;
+		Object value;
+
+		// value aspect
+		displayGroup = displayGroupForAspect( ValueAspect );
+		if ( displayGroup != null )
+		{
+                    key = displayGroupKeyForAspect( ValueAspect );
+                    if ( component instanceof Component )
+                    {
+                        ((Component)component).setEnabled( 
+                                displayGroup.enabledToSetSelectedObjectValueForKey( key ) );
+                    }
+                    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
+
+                    // convert value to date
+                    try
+                    {
+                        Date dateValue = null;
+                        // (Date) ValueConverter.convertObjectToClass( value, Date.class );
+
+                        if ( value instanceof Date )
+                        {
+                            dateValue = (Date) value;
+                        }
+
+                        if ( ( dateValue == null ) && ( value instanceof Calendar ) )
+                        {
+                            dateValue = ( ( Calendar )value ).getTime();
+                        }
+
+                        if ( dateValue == null )
+                        {
+                            // current time (placeholder)
+                            nullValue = new Date();
+                            dateValue = nullValue;
+                        }
+                        else
+                        {
+                            nullValue = null;
+                        }
+
+                        if ( !dateValue.equals( getDate.invoke( component ) ) )
+                        {	// No need to update if there is no change.
+                            setDate.invoke( component, dateValue );
+                            needsUpdate = false;
+                        }
+
+                    }
+                    catch ( Exception exc )
+                    {
+                            throw new WotonomyException(
+                                    "Error while updating component connection", exc );
+                    }
+		}
+
+		// enabled aspect
+		displayGroup = displayGroupForAspect( EnabledAspect );
+		key = displayGroupKeyForAspect( EnabledAspect );
+		if ( ( ( displayGroup != null ) || ( key != null ) )
+		&& ( component instanceof Component ) )
+		{
+			if ( displayGroup != null )
+			{
+				value =
+					displayGroup.selectedObjectValueForKey( key );
+			}
+			else
+			{
+				// treat bound key without display group as a value
+				value = key;
+			}
+            Boolean converted = null;
+            if ( value != null ) 
+            {
+                converted = (Boolean)
+                    ValueConverter.convertObjectToClass(
+                        value, Boolean.class );
+            }
+            if ( converted == null ) converted = Boolean.FALSE;
+            if ( converted.booleanValue() != ((Component)component).isEnabled() )
+            {
+                ((Component)component).setEnabled( converted.booleanValue() );
+            }
+		}
+
+		// editable aspect
+		displayGroup = displayGroupForAspect( EditableAspect );
+		key = displayGroupKeyForAspect( EditableAspect );
+		if ( ( ( displayGroup != null ) || ( key != null ) )
+		&& ( setEditable.implementedByObject( component ) ) )
+		{
+            try
+            {
+                if ( displayGroup != null )
+                {
+                    value =
+                        displayGroup.selectedObjectValueForKey( key );
+                }
+                else
+                {
+                    // treat bound key without display group as a value
+                    value = key;
+                }
+                Boolean converted = (Boolean)
+                    ValueConverter.convertObjectToClass(
+                        value, Boolean.class );
+
+                if ( converted != null )
+                {
+                    setEditable.invoke( component, converted );
+                }
+            }
+			catch ( Exception exc )
+			{
+				throw new WotonomyException(
+					"Error while updating component connection (editable aspect)", exc );
+			}
+		}
+    }
+
+    /**
+    * 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 writeValueToDisplayGroup();
+    }
+
+	/**
+	* 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 writeValueToDisplayGroup()
+	{
+            if ( !needsUpdate ) return true;
+
+            EODisplayGroup displayGroup =
+                    displayGroupForAspect( ValueAspect );
+            if ( displayGroup != null )
+            {
+                String key = displayGroupKeyForAspect( ValueAspect );
+                                Object component = object();
+                Object value = null;
+                try
+                {
+                    if ( getDate.implementedByObject( component ) )
+                    {
+                            value = getDate.invoke( component );
+                    }
+                    if ( nullValue != null )
+                    {
+                        if ( nullValue.equals( value ) )
+                        {
+                            value = null;
+                        }
+                    }
+                }
+                catch ( Exception exc )
+                {
+                        throw new WotonomyException(
+                                "Error updating display group", exc );
+                }
+
+                needsUpdate = false;
+
+                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;
+	}
+
+    // interface ActionListener
+
+	/**
+	* Updates object on action performed.
+	*/
+	public void actionPerformed( ActionEvent evt )
+	{
+        needsUpdate = true;
+		writeValueToDisplayGroup();  // TODO: Should we do this here or on focus lost?
+	}
+
+    // interface FocusListener
+
+	/**
+	* Notifies of beginning of edit.
+	*/
+    public void focusGained(FocusEvent evt)
+    {
+		Object o;
+		EODisplayGroup displayGroup;
+        Enumeration e = aspects().objectEnumerator();
+		while ( e.hasMoreElements() )
+		{
+			displayGroup =
+				displayGroupForAspect( e.nextElement().toString() );
+			if ( displayGroup != null )
+			{
+				displayGroup.associationDidBeginEditing( this );
+			}
+		}
+    }
+
+	/**
+	* Updates object on focus lost and notifies of end of edit.
+	*/
+    public void focusLost(FocusEvent evt)
+    {
+		if ( endEditing() )
+		{
+			Object o;
+			EODisplayGroup displayGroup;
+			Enumeration e = aspects().objectEnumerator();
+			while ( e.hasMoreElements() )
+			{
+				displayGroup =
+					displayGroupForAspect( e.nextElement().toString() );
+				if ( displayGroup != null )
+				{
+					displayGroup.associationDidEndEditing( this );
+				}
+			}
+		}
+		else
+		{
+			// probably should notify of a validation error here,
+			// but how to also handle actionPerformed without copying code?
+/*
+			Object value = null;
+			try
+			{
+				if ( getText.implementedByObject( object() ) )
+				{
+					value = getText.invoke( object() );
+				}
+			}
+			catch ( Exception exc )
+			{
+				throw new WotonomyException(
+					"Error updating display group", exc );
+			}
+
+			EODisplayGroup displayGroup =
+					displayGroupForAspect( ValueAspect );
+			String key = displayGroupKeyForAspect( ValueAspect );
+			if ( displayGroup != null )
+			{
+				if ( displayGroup.associationFailedToValidateValue(
+					this, (String) value, key, object(),
+					"That format was not recognized." ) )
+				{
+					new net.wotonomy.ui.swing.util.StackTraceInspector();
+				}
+				if ( object() instanceof Component )
+				{
+					((Component)object()).requestFocus();
+				}
+			}
+*/
+		}
+    }
+}
+
+/*
+ * $Log$
+ * Revision 1.2  2006/02/18 23:19:05  cgruber
+ * Update imports and maven dependencies.
+ *
+ * Revision 1.1  2006/02/16 13:22:22  cgruber
+ * Check in all sources in eclipse-friendly maven-enabled packages.
+ *
+ * Revision 1.7  2004/01/28 18:34:57  mpowers
+ * Better handling for enabling.
+ * Now respecting enabledToSetSelectedObjectValueForKey from display group.
+ *
+ * Revision 1.6  2003/08/06 23:07:52  chochos
+ * general code cleanup (mostly, removing unused imports)
+ *
+ * Revision 1.5  2001/07/30 16:32:55  mpowers
+ * Implemented support for bulk-editing.  Detail associations will now
+ * apply changes to all selected objects.
+ *
+ * Revision 1.4  2001/02/17 17:23:49  mpowers
+ * More changes to support compiling with jdk1.1 collections.
+ *
+ * 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/17 16:25:26  mpowers
+ * Now catching null values from data object.
+ *
+ * Revision 1.1  2001/01/10 22:26:32  mpowers
+ * Contributing DateAssociation.
+ *
+ * Revision 1.1  2001/01/10 21:30:27  rglista
+ * Initial checkin
+ *
+ *
+ */
+