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