diff options
Diffstat (limited to 'projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/ComboBoxAssociation.java')
| -rw-r--r-- | projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/ComboBoxAssociation.java | 700 |
1 files changed, 700 insertions, 0 deletions
diff --git a/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/ComboBoxAssociation.java b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/ComboBoxAssociation.java new file mode 100644 index 0000000..d0a087e --- /dev/null +++ b/projects/net.wotonomy.ui.swing/src/main/java/net/wotonomy/ui/swing/ComboBoxAssociation.java @@ -0,0 +1,700 @@ +/* +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.event.ActionEvent; +import java.awt.event.ActionListener; +import java.awt.event.FocusEvent; +import java.awt.event.FocusListener; +import java.util.Enumeration; +import java.util.Iterator; +import java.util.List; + +import javax.swing.AbstractListModel; +import javax.swing.ComboBoxModel; +import javax.swing.JComboBox; + +import net.wotonomy.foundation.NSArray; +import net.wotonomy.foundation.internal.ValueConverter; +import net.wotonomy.foundation.internal.WotonomyException; +import net.wotonomy.ui.EOAssociation; +import net.wotonomy.ui.EODisplayGroup; + +/** +* ComboBoxAssociation binds JComboBoxes to +* display groups. Bindings are: +* <ul> +* +* <li>value: optional - a property of the selected object in the +* display group that will be bind to the item the user +* selects or the text that the user enters in the field. +* If the value aspect is not bound, then the combo box works +* as an "overview" assocation and changing the selected object +* in the combobox will modify the selection of the display group +* bound to the objects or the titles display groups (in that order).</li> +* +* <li>titles: optional - a property of the objects in the bound +* display group that will appear in the list. If the +* objects aspect is not bound, this property is also +* used to populate the value binding. If the titles +* aspect itself is not bound, the items already in the +* combobox will be used to update the value in the +* selected object in the bound display group.</li> +* +* <li>objects: optional - if specified, when the user +* selects a title in the list, the property of the +* object at the corresponding index of the bound display +* group will be used to populate the value binding. +* If the objects aspect is used with an editable combo +* box, any value entered that does not match one of the +* titles in the list will produce a null value.</li> +* +* <li>enabled: optional - a boolean property of the +* selected object in the display group that determines whether +* the user can edit the field.</li> +* +* </ul> +* +* @author michael@mpowers.net +* @author $Author: cgruber $ +* @version $Revision: 904 $ +*/ +public class ComboBoxAssociation extends EOAssociation + implements FocusListener, ActionListener +{ + static final NSArray aspects = + new NSArray( new Object[] { + TitlesAspect, ValueAspect, + ObjectsAspect, EnabledAspect + } ); + static final NSArray aspectSignatures = + new NSArray( new Object[] { + AttributeToOneAspectSignature, + AttributeToOneAspectSignature, + AttributeToOneAspectSignature, + AttributeToOneAspectSignature + } ); + static final NSArray objectKeysTaken = + new NSArray( new Object[] { + "text" + } ); + + private boolean wasNull; + private static final String EMPTY_STRING = ""; + + /** + * Constructor specifying the object to be controlled by this + * association. Does not establish connection. + */ + public ComboBoxAssociation ( Object anObject ) + { + super( 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 () + { + 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 JComboBox ); + } + + /** + * 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. Subclasses should begin + * listening for events from their controlled object here. + */ + public void establishConnection () + { + super.establishConnection(); + + // prepopulate titles + EODisplayGroup displayGroup = + displayGroupForAspect( TitlesAspect ); + if ( displayGroup != null ) + { + String key = displayGroupKeyForAspect( TitlesAspect ); + populateTitles( displayGroup, key ); + } + addAsListener(); + subjectChanged(); + } + + protected void addAsListener() + { + component().addActionListener( this ); + component().addFocusListener( this ); + } + + /** + * Breaks the connection between this association and + * its object. Override to stop listening for events + * from the object. + */ + public void breakConnection () + { + removeAsListener(); + super.breakConnection(); + } + + protected void removeAsListener() + { + component().removeActionListener( this ); + component().removeFocusListener( this ); + } + + /** + * Called when either the selection or the contents + * of an associated display group have changed. + */ + public void subjectChanged () + { + removeAsListener(); + + JComboBox component = component(); + EODisplayGroup displayGroup; + String key; + + // titles aspect + displayGroup = displayGroupForAspect( TitlesAspect ); + if ( displayGroup != null ) + { + ComboBoxModel model = component().getModel(); + // if first time, or if backing group has changed +// if ( ( ! ( model instanceof ComboBoxAssociationModel ) ) +// || ( displayGroup.contentsChanged() ) ) +// { + key = displayGroupKeyForAspect( TitlesAspect ); + populateTitles( displayGroup, key ); +// } + } + + // value aspect + displayGroup = displayGroupForAspect( ValueAspect ); + if ( displayGroup != null ) + { + key = displayGroupKeyForAspect( ValueAspect ); + component.setEnabled( + displayGroup.enabledToSetSelectedObjectValueForKey( key ) ); + //Object value = displayGroup.selectedObjectValueForKey( key ); + Object value; + + + if ( displayGroup.selectedObjects().size() > 1 ) + { + + 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 { + // if there's only one object selected. + value = displayGroup.selectedObjectValueForKey( key ); + } // end checking the size of selected objects in displayGroup + + + // objects aspect + EODisplayGroup objectsDisplayGroup = + displayGroupForAspect( ObjectsAspect ); + if ( ( objectsDisplayGroup != null ) && ( value != null ) ) + { + String objectKey = displayGroupKeyForAspect( ObjectsAspect ); + Object match; + int index = NSArray.NotFound; + int count = objectsDisplayGroup.displayedObjects().count(); + for ( int i = 0; i < count; i++ ) + { + match = objectsDisplayGroup.valueForObjectAtIndex( i, objectKey ); + if ( value.equals( match ) ) + { + index = i; + } + } + if ( index == NSArray.NotFound ) + { + if ( component.getSelectedItem() != null ) + { + component.setSelectedItem( null ); + } + } + else + { + if ( component.getSelectedIndex() != index ) + { + component.setSelectedIndex( index ); + } + } + } + else + { + component.setSelectedItem( value ); + } + } + else // values aspect not bound + { + // use objects group if specified + EODisplayGroup sourceGroup = + displayGroupForAspect( ObjectsAspect ); + if ( sourceGroup == null ) + { + // fall back on titles group + sourceGroup = displayGroupForAspect( TitlesAspect ); + } + + if ( sourceGroup != null ) + { + List selection = sourceGroup.selectionIndexes(); + if ( ( selection != null ) && ( selection.size() > 0 ) ) + { + component.setSelectedIndex( ((Integer)selection.get(0)).intValue() ); + } + else + { + // the combo box model decides what to do with this value + component.setSelectedItem( null ); + } + } + } + + // enabled aspect + displayGroup = displayGroupForAspect( EnabledAspect ); + if ( displayGroup != null ) + { + key = displayGroupKeyForAspect( EnabledAspect ); + Object value = + displayGroup.selectedObjectValueForKey( key ); + Boolean converted = null; + if ( value != null ) + { + converted = (Boolean) + ValueConverter.convertObjectToClass( + value, Boolean.class ); + } + if ( converted == null ) converted = Boolean.FALSE; + if ( converted.booleanValue() != component.isEnabled() ) + { + component.setEnabled( converted.booleanValue() ); + } + } + + addAsListener(); + } + + /** + * Called to repopulate the title list from the + * specified display group. + */ + protected void populateTitles( + EODisplayGroup displayGroup, String key ) + { + component().setModel( + new ComboBoxAssociationModel( displayGroup, key ) ); + } + + /** + * 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() + { + JComboBox component = component(); + EODisplayGroup displayGroup; + String key; + + // selected title aspect + displayGroup = displayGroupForAspect( ValueAspect ); + if ( displayGroup != null ) + { + key = displayGroupKeyForAspect( ValueAspect ); + Object value = null; + + // selected object aspect, if any + EODisplayGroup objectsGroup = + displayGroupForAspect( ObjectsAspect ); + if ( objectsGroup != null ) + { + try + { + String objectKey = displayGroupKeyForAspect( ObjectsAspect ); + int index = component.getSelectedIndex(); + if ( index != -1 ) + { + value = objectsGroup + .valueForObjectAtIndex( index, objectKey ); + } + else // selected index is -1 + { + // the combo box is probably editable, + // so there is no corresponding object. + value = null; + } + } + catch ( NullPointerException npe ) + { + // catches NPE on line 436 of JComboBox.java: + // this is a common developer error + throw new WotonomyException( "ComboBoxAssociation: " + + "The object in the VALUE property may not have been found in the " + + "objects in the TITLES group.", npe ); + } + } + else // just use the selected item + { + value = component.getSelectedItem(); + } + + boolean returnValue = true; + if ( displayGroup.selectedObjects().size() == 1 ) + { // displayGroup has only one object + // only set value if changed + Object existingValue = displayGroup.selectedObjectValueForKey( key ); + if ( value == existingValue ) return true; + if ( ( existingValue != null ) && ( existingValue.equals( value ) ) ) return true; + + // value has changed: update the value. + return displayGroup.setSelectedObjectValue( value, key ); + } + else if ( displayGroup.selectedObjects().size() > 1 ) + { + // displayGroup has more than one object + Iterator selectedIterator = displayGroup.selectionIndexes().iterator(); + while ( selectedIterator.hasNext() ) + { + int index = ( (Integer)selectedIterator.next() ).intValue(); + + if ( !displayGroup.setValueForObjectAtIndex( value, index, key ) ) + { + returnValue = false; + } + } + return returnValue; + + } // end checking size of displayGroup + + } + else // values aspect not bound + { + // use objects group if specified + EODisplayGroup sourceGroup = + displayGroupForAspect( ObjectsAspect ); + if ( sourceGroup == null ) + { + // fall back on titles group + sourceGroup = displayGroupForAspect( TitlesAspect ); + } + + if ( sourceGroup != null ) + { + int index = component.getSelectedIndex(); + if ( index != -1 ) + { + sourceGroup.setSelectionIndexes( new NSArray( new Integer( index ) ) ); + } + else + { + sourceGroup.setSelectedObject( null ); + } + return true; + } + } + + return false; + } + + // interface ActionListener + + /** + * Updates object on action performed. + */ + public void actionPerformed( ActionEvent evt ) + { + writeValueToDisplayGroup(); + } + + // 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 ( component().isEditable() ) + { + if ( endEditing() ) + { + Object o; + EODisplayGroup displayGroup; + Enumeration e = aspects().objectEnumerator(); + while ( e.hasMoreElements() ) + { + displayGroup = + displayGroupForAspect( e.nextElement().toString() ); + if ( displayGroup != null ) + { + displayGroup.associationDidEndEditing( this ); + } + } + } + } + } + + // convenience + + private JComboBox component() + { + return (JComboBox) object(); + } + + /** + * Used as the data model for the controlled combo box. + */ + private class ComboBoxAssociationModel extends AbstractListModel + implements ComboBoxModel + { + EODisplayGroup displayGroup; + String key; + Object selectedItem; + + ComboBoxAssociationModel( + EODisplayGroup aDisplayGroup, String aKey ) + { + displayGroup = aDisplayGroup; + key = aKey; + selectedItem = null; + } + + public Object getElementAt(int index) + { + return displayGroup.valueForObjectAtIndex( index, key ); + } + + public int getSize() + { + return displayGroup.displayedObjects().count(); + } + + public void setSelectedItem(Object anItem) + { //System.out.println( "setSelectedItem: " + anItem ); + selectedItem = anItem; + + // must do this to notify an editable combo, + // otherwise the wrong value appears. + fireContentsChanged( this, -1, -1 ); + } + + public Object getSelectedItem() + { //System.out.println( "getSelectedItem: " + selectedItem ); + return selectedItem; + } + } +} + +/* + * $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.13 2004/01/28 18:34:57 mpowers + * Better handling for enabling. + * Now respecting enabledToSetSelectedObjectValueForKey from display group. + * + * Revision 1.12 2003/08/06 23:07:52 chochos + * general code cleanup (mostly, removing unused imports) + * + * Revision 1.11 2001/07/30 16:32:55 mpowers + * Implemented support for bulk-editing. Detail associations will now + * apply changes to all selected objects. + * + * Revision 1.10 2001/07/23 20:17:56 mpowers + * Now works as an overview association if the values aspect is not bound. + * + * Revision 1.9 2001/06/30 14:57:29 mpowers + * Removed a println. + * + * Revision 1.8 2001/06/29 22:28:19 mpowers + * Tabs to spaces. + * + * Revision 1.7 2001/06/29 22:17:31 mpowers + * Now updating the component on establishConnection. + * + * Revision 1.6 2001/05/14 15:24:49 mpowers + * Only updating if change was made. Feels like I had fixed this here before. + * + * Revision 1.5 2001/04/09 21:41:08 mpowers + * Fixed a bug I thought that I had fixed before. + * + * Revision 1.4 2001/03/01 20:37:17 mpowers + * Updated docs to emphasize that titles aspect is optional. + * + * 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/10 17:01:08 mpowers + * Caught a common developer error. + * + * Revision 1.1.1.1 2000/12/21 15:48:43 mpowers + * Contributing wotonomy. + * + * Revision 1.8 2000/12/20 16:25:40 michael + * Added log to all files. + * + * + */ + |