/*
   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.util.Enumeration;
  
  import javax.swing.DefaultListModel;
  import javax.swing.JList;
  import javax.swing.SwingUtilities;
  import javax.swing.event.ListDataEvent;
  import javax.swing.event.ListDataListener;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.event.ListSelectionListener;
  
  import net.wotonomy.foundation.NSArray;
  import net.wotonomy.foundation.NSMutableArray;
  import net.wotonomy.ui.EOAssociation;
  import net.wotonomy.ui.EODisplayGroup;
  
  /***
  * TextAssociation binds a JList to a display group's
  * list of displayable objects.  Bindings are: 
  * <ul>
  * <li>titles: a property convertable to a string for
  * display in the cells of the list</li> 
  * </ul>
  *
  * @author michael@mpowers.net
  * @author $Author: cgruber $
  * @version $Revision: 904 $
  */
  public class ListAssociation extends EOAssociation
                            implements ListSelectionListener,
                                       ListDataListener
  {
      static final NSArray aspects = 
          new NSArray( new Object[] {
              TitlesAspect
          } );
      static final NSArray aspectSignatures = 
          new NSArray( new Object[] {
              AttributeToOneAspectSignature
          } );
      static final NSArray objectKeysTaken = 
          new NSArray( new Object[] {
              "items" 
          } );
  		
      protected DefaultListModel model;
  
      /***
      * Constructor expecting a JList. Throws an
  	* exception if it doesn't receive one.
  	* Note: This sets the JList's model to a DefaultListModel.
      */
      public ListAssociation ( Object anObject )
      {
          super( anObject );
          model = new DefaultListModel();
          ((JList)anObject).setModel( model );
      }
      
      /***
      * 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 JList );
     }
     
     /***
     * 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 TitlesAspect;
     }
         
     /***
     * 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 ()
     {
         addAsListener();
         super.establishConnection();
 		populateFromDisplayGroup(); 
         selectFromDisplayGroup();
     }
     
     /***
     * 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 addAsListener()
     { // System.out.println( "ListAssociation.addAsListener: " + ++count );
         component().getModel().addListDataListener( this );
         component().addListSelectionListener( this );
     }
 
     protected void removeAsListener()
     { // System.out.println( "ListAssociation.removeAsListener: " + --count );
         component().getModel().removeListDataListener( this );
         component().removeListSelectionListener( this );
     }
 
     /***
     * Called when either the selection or the contents 
     * of an associated display group have changed.
     */
     public void subjectChanged ()
     {
 		EODisplayGroup displayGroup;
 	
 		// titles aspect
 		displayGroup = displayGroupForAspect( TitlesAspect );
 		if ( displayGroup != null )
 		{
 //System.out.println( "subjectChanged: " + 
 //displayGroup.contentsChanged() + " : " + displayGroup.selectionChanged() 
 //+ " : " + displayGroup.updatedObjectIndex() );
 //new net.wotonomy.ui.swing.util.StackTraceInspector();
 			if ( displayGroup.contentsChanged() )
 			{
 				populateFromDisplayGroup();
 			}
 
 			if ( displayGroup.selectionChanged() )
 			{
 				selectFromDisplayGroup();
 			}
 		}
 
     }
 	
 	private void populateFromDisplayGroup()
 	{
 		JList component = component();
 		EODisplayGroup displayGroup = displayGroupForAspect( TitlesAspect );
 		String key = displayGroupKeyForAspect( TitlesAspect );
 			
 		removeAsListener();
 		
 		// remember selection
 		int[] selectedIndices = component().getSelectedIndices();
 		
 		// clear the model
 		model.removeAllElements();
 
 		// populate the model
 		Object value;
 		int size = displayGroup.displayedObjects().count();
 //System.out.println( "populateFromDisplayGroup: " + size );
 		for ( int i = 0; i < size; i++ )
 		{
 			value = displayGroup.valueForObjectAtIndex( i, key );
 			if ( value == null ) value = "[null]";
 			model.addElement( value );
 		}
 	
 		// select the same indexes
 		for ( int i = 0; i < selectedIndices.length; i++ )
 		{
 			component.addSelectionInterval(
 				selectedIndices[i], selectedIndices[i] ); // adds one row
 		}
 
 		addAsListener();
 	}
             
 	private void selectFromDisplayGroup()
 	{
 		JList component = component();
 		EODisplayGroup displayGroup = displayGroupForAspect( TitlesAspect );
 
 		removeAsListener();
 		
 		int index;
 		component.clearSelection();
 		Enumeration e = 
 			displayGroup.selectionIndexes().objectEnumerator();
 
 		while ( e.hasMoreElements() )
 		{   // add selections one-by-one to support non-contiguous
 			index = ((Number)e.nextElement()).intValue();
 			component.addSelectionInterval(
 				index, index ); // adds one row
 		}
 		
 		addAsListener();
 	}
 	
 	// interface ListSelectionListener
 
     public void valueChanged(ListSelectionEvent e)
     {
         final EODisplayGroup displayGroup = 
 			displayGroupForAspect( TitlesAspect );
         if ( ( displayGroup != null ) && ( ! e.getValueIsAdjusting() ) )
         {
             int[] selectedIndices = component().getSelectedIndices();
 			final NSMutableArray indexList = new NSMutableArray();
 			for ( int i = 0; i < selectedIndices.length; i++ )
 			{
 				indexList.addObject( new Integer( selectedIndices[i] ) );
 			}
             
             // invoke later so the component is repainted before
             //   any potentially lengthy second-order effects happen:
             //   this improves user-perceived responsiveness of big apps
             SwingUtilities.invokeLater( new Runnable() {
                 public void run()
                 {
         			displayGroup.setSelectionIndexes( indexList );
                 }
              });
         }
     }
 
     // interface ListDataListener
 
     public void intervalAdded(ListDataEvent e)
     {
         // System.out.println( "intervalAdded" );
         contentsChanged(e);
     }
     public void intervalRemoved(ListDataEvent e)
     {
         // System.out.println( "intervalRemoved" );
         contentsChanged(e);
     }
     public void contentsChanged(ListDataEvent e)
     {
         // System.out.println( "contentsChanged" );
 		
         // if we were editing a property,
 		// we'd notify our display group now.
     }
 	
 	// convenience
 
     private JList component()
     {
         return (JList) object();
     }
 }
 
 /*
  * $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.5  2003/08/06 23:07:52  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.4  2002/05/15 14:05:55  mpowers
  * Now appropriately selectingFromDisplayGroup on establishConnection.
  *
  * Revision 1.3  2001/09/14 13:40:26  mpowers
  * User-initiated selection changes are now handled on the next event loop
  * so that the component repaints the new selection before any potentially
  * lengthy logic is triggered by the selection change.
  *
  * Revision 1.2  2001/02/17 16:52:05  mpowers
  * Changes in imports to support building with jdk1.1 collections.
  *
  * Revision 1.1.1.1  2000/12/21 15:48:49  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.5  2000/12/20 16:25:41  michael
  * Added log to all files.
  *
  *
  */