/*
   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.util.Iterator;
  
  import javax.swing.ButtonModel;
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  
  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;
  
  /***
  * ButtonAssociation binds any component that uses a ButtonModel
  * (all Swing button classes) to a display group.  This association
  * should be used to handle individual JRadioButtons and JCheckBoxes.
  * Bindings are:
  * <ul>
  * <li>value: a boolean property that determines the
  * selected state of the button model.  This will set
  * the value for radio buttons and check boxes.</li>
  * <li>enabled: a boolean property that determines the
  * enabled state of the button model.</li>
  * <li>visible: a boolean property that determines the
  * visible state of the button model.</li>
  * </ul>
  *
  * @author michael@mpowers.net
  * @author $Author: cgruber $
  * @version $Revision: 904 $
  */
  public class ButtonAssociation extends EOAssociation
      implements ChangeListener
  {
      static final NSArray aspects =
          new NSArray( new Object[] {
              ValueAspect, EnabledAspect, VisibleAspect
          } );
      static final NSArray aspectSignatures =
          new NSArray( new Object[] {
              AttributeToOneAspectSignature,
              AttributeToOneAspectSignature,
              AttributeToOneAspectSignature
          } );
      static final NSArray objectKeysTaken =
          new NSArray( new Object[] {
              "model.selected"
          } );
  
      static NSSelector getModel =
          new NSSelector( "getModel", new Class[] {} );
  
      protected ButtonModel buttonModel;
      protected boolean lastKnownValue;
  
      /***
      * Constructor specifying the object to be controlled by this
      * association.  Does not establish connection.
      * This implementation expects a ButtonModel or a class
      * that has a "getModel" method that returns a ButtonModel.
      */
      public ButtonAssociation ( Object anObject )
      {
          super( anObject );
  
          if ( anObject instanceof ButtonModel )
          {
              buttonModel = (ButtonModel) anObject;
          }
          else
          {
              try
              {
                  buttonModel = (ButtonModel) getModel.invoke( anObject );
              }
              catch ( Exception exc )
              {
                 throw new WotonomyException( "EOButtonAssociation: " +
                     "could not retrieve a button model from object:" + 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.
     * This implementation expects a ButtonModel or a class
     * that has a "getModel" method that returns a ButtonModel.
     */
     public static boolean isUsableWithObject ( Object anObject )
     {
         return
            ( anObject instanceof ButtonModel )
         || ( getModel.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.
     */
     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 ()
     {
         buttonModel.addChangeListener( this );
         super.establishConnection();
         subjectChanged();
     }
 
     /***
     * Breaks the connection between this association and
     * its object.  Override to stop listening for events
     * from the object.
     */
     public void breakConnection ()
     {
         buttonModel.removeChangeListener( this );
         super.breakConnection();
     }
 
     /***
     * Called when either the selection or the contents
     * of an associated display group have changed.
     * This implementation does nothing.
     */
     public void subjectChanged ()
     {
         Object component = object();
         EODisplayGroup displayGroup;
         String key;
 
         // value aspect
         displayGroup = displayGroupForAspect( ValueAspect );
 
         if ( displayGroup != null )
         {
             key = displayGroupKeyForAspect( ValueAspect );
             if ( component instanceof Component )
             {
                 ((Component)component).setEnabled( 
                         displayGroup.enabledToSetSelectedObjectValueForKey( 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 // displayGroup has only one object 
             {
                 value =
                     displayGroup.selectedObjectValueForKey( key );
             } // end checking size of displayGroup
 
             buttonModel.setArmed( false );
             buttonModel.setPressed( false );
             
             if ( value != null )
             {
                 Boolean converted = (Boolean)
                     ValueConverter.convertObjectToClass(
                         value, Boolean.class );
                 if ( converted != null )
                 {
                     lastKnownValue = converted.booleanValue();
                     if ( converted.booleanValue() !=
                         buttonModel.isSelected() )
                     {
                         buttonModel.removeChangeListener( this );
                         buttonModel.setSelected(
                             converted.booleanValue() );
                         buttonModel.addChangeListener( this );
                     }
                 } // end checking converted  == null
             }
             else
             {
                 buttonModel.setArmed( true );
                 buttonModel.setPressed( true );
             }
         }
 
         // 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() !=
                 buttonModel.isEnabled() )
             {
                 buttonModel.removeChangeListener( this );
                 buttonModel.setEnabled(
                     converted.booleanValue() );
                 buttonModel.addChangeListener( this );
             }
         }
 
         // visible aspect
         displayGroup = displayGroupForAspect( VisibleAspect );
         if ( displayGroup != null )
         {
             key = displayGroupKeyForAspect( VisibleAspect );
             Object value =
                 displayGroup.selectedObjectValueForKey( key );
             Boolean converted = (Boolean)
                 ValueConverter.convertObjectToClass(
                     value, Boolean.class );
             if ( converted != null )
             {
                 if ( converted.booleanValue() !=
                     ((Component)component).isVisible() )
                 {
                     ((Component)component).setVisible(
                         converted.booleanValue() );
                 }
             }
         }
     }
 
     /***
     * 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()
     {
         EODisplayGroup displayGroup =
             displayGroupForAspect( ValueAspect );
         if ( displayGroup != null )
         {
             boolean returnValue = true;
             String key = displayGroupKeyForAspect( ValueAspect );
             Object value = new Boolean( buttonModel.isSelected() );
 
             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 ChangeListener
 
     public void stateChanged(ChangeEvent e)
     {
         if ( buttonModel.isSelected() != lastKnownValue )
         {
             lastKnownValue = buttonModel.isSelected();
             writeValueToDisplayGroup();
         }
     }
 
 }
 
 /*
  * $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.8  2004/01/28 18:34:57  mpowers
  * Better handling for enabling.
  * Now respecting enabledToSetSelectedObjectValueForKey from display group.
  *
  * Revision 1.7  2003/08/06 23:07:52  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.6  2001/07/30 16:32:55  mpowers
  * Implemented support for bulk-editing.  Detail associations will now
  * apply changes to all selected objects.
  *
  * Revision 1.5  2001/06/29 22:28:19  mpowers
  * Tabs to spaces.
  *
  * Revision 1.4  2001/06/29 22:17:31  mpowers
  * Now updating the component on establishConnection.
  *
  * Revision 1.3  2001/02/27 02:10:38  mpowers
  * No longer updating values to the display group if the value
  * has not changed.
  *
  * Revision 1.2  2001/02/21 20:33:01  mpowers
  * Fixed bug with change listener.
  *
  * Revision 1.1.1.1  2000/12/21 15:48:38  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.3  2000/12/20 16:25:40  michael
  * Added log to all files.
  *
  *
  */