/*
   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.EventQueue;
  import java.awt.Graphics;
  import java.awt.Rectangle;
  import java.awt.Toolkit;
  import java.awt.datatransfer.Clipboard;
  import java.awt.datatransfer.StringSelection;
  import java.awt.event.ActionEvent;
  import java.awt.event.ActionListener;
  import java.awt.event.FocusEvent;
  import java.awt.event.FocusListener;
  import java.awt.event.KeyEvent;
  import java.awt.event.MouseAdapter;
  import java.awt.event.MouseEvent;
  import java.util.Enumeration;
  
  import javax.swing.CellEditor;
  import javax.swing.JComponent;
  import javax.swing.JTable;
  import javax.swing.KeyStroke;
  import javax.swing.event.ListSelectionEvent;
  import javax.swing.event.ListSelectionListener;
  import javax.swing.table.AbstractTableModel;
  import javax.swing.table.JTableHeader;
  import javax.swing.table.TableColumn;
  import javax.swing.table.TableModel;
  
  import net.wotonomy.control.EOSortOrdering;
  import net.wotonomy.foundation.NSArray;
  import net.wotonomy.foundation.NSMutableArray;
  import net.wotonomy.foundation.internal.WotonomyException;
  import net.wotonomy.ui.EOAssociation;
  import net.wotonomy.ui.EODisplayGroup;
  
  /***
  * TableAssociation binds one or more TableColumnAssociations
  * to a display group.  You should not instantiate this class
  * directly; use TableColumnAssociation.setTable() instead.
  * Note that TableAssociation inserts itself as the controlled
  * JTable's TableModel.
  *
  * Bindings are:
  * <ul>
  * <li>source: a property convertable to a string for
  * display in the cells of the table column</li>
  * <li>enabled: a property convertable to a string for
  * display in the cells of the table column.
  * Note that you can bind this aspect to a key equal to
  * "true" or "false" and leave the display group null.</li>
  * </ul>
  *
  * @author michael@mpowers.net
  * @author $Author: cgruber $
  * @version $Revision: 904 $
  */
  public class TableAssociation extends EOAssociation
  	implements ActionListener, ListSelectionListener, FocusListener
  {
      static final NSArray aspects =
          new NSArray( new Object[] {
              SourceAspect, EnabledAspect
          } );
      static final NSArray aspectSignatures =
          new NSArray( new Object[] {
              AttributeToOneAspectSignature
          } );
      static final NSArray objectKeysTaken =
          new NSArray( new Object[] {
              "tableModel", "tableHeader"
          } );
  
      // key command to copy contents to clipboard
      static public final String COPY = "COPY";
  
  	EODisplayGroup source;
      EODisplayGroup sortTarget; // used by TreeColumnAssociation
  	NSMutableArray columns;
      JTableHeader tableHeader;
  
      boolean pleaseIgnore;
     boolean selectionPaintedImmediately;
     boolean selectionTracking;
 
     /***
     * Constructor specifying the object to be controlled by this
     * association.  Throws an exception if the object is not
 	* a TableColumn.  setTable() must be called before
 	* establishing the connection.
     */
     public TableAssociation ( Object anObject )
     {
         super( anObject );
 		source = null;
 		columns = new NSMutableArray();
 		JTable aTable = ((JTable)anObject);
         aTable.addFocusListener( this );
 		aTable.setModel(
 			new TableAssociationModel( this ) );
 			// set up keyboard events for cut-copy: Ctrl-C, Ctrl-X
 
         // why did sun make this harder to use? 
         //aTable.getInputMap( JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT ).put(
         //   KeyStroke.getKeyStroke( KeyEvent.VK_C, java.awt.Event.CTRL_MASK ), COPY);
         //aTable.getActionMap().put(COPY, this);
         
         aTable.registerKeyboardAction( this, COPY,
 			KeyStroke.getKeyStroke( KeyEvent.VK_C, 
             Toolkit.getDefaultToolkit().getMenuShortcutKeyMask() ),
 			JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT );
 		aTable.registerKeyboardAction( this, COPY,
 			KeyStroke.getKeyStroke( KeyEvent.VK_X, 
             Toolkit.getDefaultToolkit().getMenuShortcutKeyMask() ),
 			JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT );
         tableHeader = new SortedTableHeader();
         tableHeader.setColumnModel( aTable.getColumnModel() );
         aTable.setTableHeader( tableHeader );
         tableHeader.addMouseListener( new TableHeaderListener() );
         pleaseIgnore = false;
         selectionPaintedImmediately = false;
         selectionTracking = false;
     }
 
     /***
     * 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 JTable );
     }
 
     /***
     * 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 ) );
     }
 
     /***
     * Binds the specified aspect of this association to the
     * specified key on the specified display group.
     */
     public void bindAspect (
         String anAspect, EODisplayGroup aDisplayGroup, String aKey )
 	{
 		if ( SourceAspect.equals( anAspect ) )
 		{
 			source = aDisplayGroup;
 		}
 		super.bindAspect( anAspect, aDisplayGroup, aKey );
 	}
 
     /***
     * Establishes a connection between this association
     * and the controlled object.  Subclasses should begin
     * listening for events from their controlled object here.
     */
     public void establishConnection ()
     {
         if ( source == null )
         {
             throw new WotonomyException( "No display group: " + 
                 "please ensure that the TableColumnAssociation " + 
                 "has a display group bound to the ValueAspect" );
         }
         super.establishConnection();
         selectFromDisplayGroup();
         addAsListener();
     }
 
     /***
     * 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()
     {
         component().getSelectionModel()
 			.addListSelectionListener( this );
     }
 
     protected void removeAsListener()
     {
         component().getSelectionModel()
 			.removeListSelectionListener( this );
     }
 
     /***
     * 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 ()
     {
         // stop any cell editing
         CellEditor editor = component().getCellEditor();
         if ( editor != null )
         {
             return editor.stopCellEditing();
         }
         return true;
     }
 
     /***
     * Called when either the selection or the contents
     * of an associated display group have changed.
     */
     public void subjectChanged ()
     {
 		if ( source != null )
 		{
 			if ( source.contentsChanged() )
 			{
                 removeAsListener();
 				((TableAssociationModel)component().getModel()).
 					fireTableDataChanged();
 				selectFromDisplayGroup();
                 addAsListener();
 
                 // if we caused this change, do nothing
                 if ( pleaseIgnore )
                 {
                     pleaseIgnore = false;
                 }
                 else // otherwise, update the sort indicator
                 {
                     tableHeader.repaint();
 
                     // cancel any cell editing
                     CellEditor editor = component().getCellEditor();
                     if ( editor != null )
                     {
                         editor.cancelCellEditing();
                     }
                 }
   			}
             else
 			if ( source.selectionChanged() )
 			{
                 removeAsListener();
 				selectFromDisplayGroup();
         		addAsListener();
 			}
 		}
 
     }
 
 	private void selectFromDisplayGroup()
 	{
 		JTable component = component();
 
 		int index;
 		component.getSelectionModel().clearSelection();
 		Enumeration e =
 			source.selectionIndexes().objectEnumerator();
 
 		while ( e.hasMoreElements() )
 		{   // add selections one-by-one to support non-contiguous
 			index = ((Number)e.nextElement()).intValue();
 			component.getSelectionModel().addSelectionInterval(
 				index, index ); // adds one row
 		}
 	}
 
 	// interface ListSelectionListener
 
     public void valueChanged(ListSelectionEvent e)
     {
         if ( source != null ) 
         {
             if ( selectionTracking || !e.getValueIsAdjusting() )
             {
                 int[] selectedIndices = component().getSelectedRows();
                 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
                 Runnable select = new Runnable()
                 {
                     public void run()
                     {
                         pleaseIgnore = true;
                         source.setSelectionIndexes( indexList );
                     }
                 };
                 if ( selectionPaintedImmediately )
                 {
                     EventQueue.invokeLater( select );
                 }
                 else
                 {
                     select.run();
                 }
             }
         }
     }
 
     /***
     * Determines whether the selection should be painted
     * immediately after the user clicks and therefore
     * before the children display group is updated.
     * When the children group is bound to many associations
     * or is bound to a master-detail association, updating
     * the display group can take a perceptibly long time.
     * This property defaults to false.
     * @see #setSelectionPaintedImmediately
     */
     public boolean isSelectionPaintedImmediately()
     {
         return selectionPaintedImmediately;
     }
 
     /***
     * Sets whether the selection should be painted immediately.
     * Setting this property to true will let the table paint
     * first before the display group is updated.
     */
     public void setSelectionPaintedImmediately( boolean isImmediate )
     {
         selectionPaintedImmediately = isImmediate;
     }
 
     /***
     * Determines whether the selection is actively tracking
     * the selection as the user moves the mouse.
     * If true, selection will not be updated while the
     * list selection event returns true for isValueAdjusting().
     * This property defaults to false.
     * @see #setSelectionTracking
     */
     public boolean isSelectionTracking()
     {
         return selectionTracking;
     }
 
     /***
     * Sets whether the selection is actively tracking
     * the selection as the user moves the mouse.
     * Setting this property to true will update the display
     * group with each change to the selection.
     * This means that any tree selection listers will
     * also be notified before the display group is updated
     * and will have to invokeLater if they want to see the
     * updated display group.
     */
     public void setSelectionTracking( boolean isTracking )
     {
         selectionTracking = isTracking;
     }
 
     // convenience
     private JTable component()
     {
         return (JTable) object();
     }
 
 	/***
 	* Copies the contents of the table to the clipboard as a tab-delimited string.
 	*/
     public void copyToClipboard()
     {
         Toolkit toolkit = Toolkit.getDefaultToolkit();
         Clipboard clipboard = toolkit.getSystemClipboard();
         StringSelection selection =
             new StringSelection( getTabDelimitedString() );
         clipboard.setContents( selection, selection );
     }
 
 	/***
 	* Converts the contents of the table to a tab-delimited string.
 	* @return A String containing the text contents of the table.
 	*/
 	public String getTabDelimitedString()
     {
         StringBuffer result = new StringBuffer(64);
 
         TableModel model = component().getModel();
         int cols = model.getColumnCount();
         int rows = model.getRowCount();
 
         Object o = null;
         for ( int y = 0; y < rows; y++ )
         {
             for ( int x = 0; x < cols; x++ )
             {
                 o = model.getValueAt( y, x );
                 if ( o == null ) o = "";
                 result.append( o );
                 result.append( '\t' );
             }
             result.append( '\n' );
         }
 
         return result.toString();
     }
 
     // interface ActionEventListener
 
     public void actionPerformed(ActionEvent evt)
     {
         String cmd = evt.getActionCommand();
 
         if ( COPY.equals( cmd ) )
         {
             copyToClipboard();
             return;
         }
     }
 
     /***
     * Used to render the little triangle over the sorted column(s).
     */
     class SortedTableHeader extends JTableHeader
     {
         public void paint(Graphics g)
         {
             super.paint( g );
             Rectangle r;
             TableColumnAssociation association;
             int size = columns.size();
             NSArray orderings;
             if ( sortTarget != null ) 
             {
                 orderings = sortTarget.sortOrderings();
             }
             else
             {
                 orderings = source.sortOrderings();
             }
             for ( int i = 0; i < size; i++ )
             {
                 r = getHeaderRect( component().convertColumnIndexToView( i ) );
                 association = (TableColumnAssociation) columns.objectAtIndex( i );
                 association.drawSortIndicator( r, g, orderings );
             }
         }
     }
 
     /***
     * Used to listen for clicks on the table header.
     */
     class TableHeaderListener extends MouseAdapter
     {
         public void mouseClicked( MouseEvent evt )
         {
             EODisplayGroup displayGroup = sortTarget;
             if ( displayGroup == null ) displayGroup = source;
             
             if ( evt.getClickCount() > 0 )
             {
                 int columnClicked = tableHeader.columnAtPoint( evt.getPoint() );
                 if ( columnClicked != -1 )
                 {
                     columnClicked = component().convertColumnIndexToModel( columnClicked );
                     TableColumnAssociation association = (TableColumnAssociation)
                         columns.objectAtIndex( columnClicked );
                     if ( association.isSortable() )
                     {
                         NSMutableArray newOrder =
                             new NSMutableArray( displayGroup.sortOrderings() );
 
                         // click once = asc, twice = desc, thrice = clear
                         EOSortOrdering sortOrdering;
                         int index = association.getIndexOfMatchingOrdering( newOrder );
                         if ( index == -1 ) sortOrdering = null;
                         else if ( index == 1 ) sortOrdering = association.getSortOrdering( false );
                         else sortOrdering = association.getSortOrdering( true );
     
                         pleaseIgnore = true;
                         tableHeader.repaint();
 
                         // stop any cell editing
                         CellEditor editor = component().getCellEditor();
                         if ( editor != null )
                         {
                             editor.stopCellEditing();
                         }
 
                         // remove existing key
                         if ( index != 0 )
                         {
                             newOrder.removeObjectAtIndex( Math.abs( index ) - 1 );
                         }
                         
                         // put new key at front of list
                         if ( sortOrdering != null )
                         {
                             newOrder.insertObjectAtIndex( sortOrdering, 0 );
                         }
                         
                         displayGroup.setSortOrderings( newOrder );
                         displayGroup.updateDisplayedObjects();
                     }
                 }
             }
         }
     }
 
 	/***
 	* 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().isEditing() )
         {
             Object o;
             EODisplayGroup displayGroup;
             Enumeration e = aspects().objectEnumerator();
             while ( e.hasMoreElements() )
             {
                 displayGroup =
                     displayGroupForAspect( e.nextElement().toString() );
                 if ( displayGroup != null )
                 {
                     displayGroup.associationDidEndEditing( this );
                 }
             }
         }
     }
 
 	/***
 	* Used as the model for the controlled table.
 	* Package access so TableColumnAssociation can recognize
 	* it and use the addColumnAssociation() method.
 	* Extends AbstractTableModel just so we get event
 	* broadcasting for free.
 	*/
 	static class TableAssociationModel extends AbstractTableModel
 	{
 		private TableAssociation parent;
 
 		private TableAssociationModel( TableAssociation aParent )
 		{
 			parent = aParent;
 		}
         
         public TableAssociation getAssociation()
         {
             return parent;
         }
 
 		/***
 		* Adds the column to the list of ColumnAssociations,
 		* and adds the corresponding column to the table
 		* at the next available index, setting the value of
 		* the column's model index accordingly.
         * Establishes connection if no columns are currently 
         * associated.
 		*/
 		public void addColumnAssociation(
 			TableColumnAssociation aColumnAssociation )
 		{
             // establish connection if necessary
             if ( parent.columns.size() == 0 )
             {
                 parent.establishConnection();
             }
             
 			int newIndex = parent.columns.count();
 			parent.columns.add( aColumnAssociation );
 
 			// add column to table
 			TableColumn column = (TableColumn) aColumnAssociation.object();
 			column.setModelIndex( newIndex );
 			parent.component().addColumn( column );
             
 		}
 
 		/***
 		* Removes the column from the list of ColumnAssociations,
 		* and removes the corresponding column from the table.
         * Breaks connection if no more columns are associated.
 		*/
 		public void removeColumnAssociation(
 			TableColumnAssociation aColumnAssociation )
 		{
 			int index = parent.columns.indexOfIdenticalObject( aColumnAssociation );
             if ( index == NSArray.NotFound ) return;
             
 			parent.columns.removeObjectAtIndex( index );
 
 			// remove column from table
 			TableColumn column = (TableColumn) aColumnAssociation.object();
 			parent.component().removeColumn( column );
             
             // break connection if necessary
             if ( parent.columns.size() == 0 )
             {
                 parent.breakConnection();
             }
 		}
 
 		public int getRowCount()
 		{
 			if ( parent.source == null ) return 0;
 			return parent.source.displayedObjects().count();
 		}
 
 		public int getColumnCount()
 		{
 			return parent.columns.count();
 		}
 
 		/***
 		* Attempts to retrieve the header value from the specified column, 
         * or returns " " if the value is null.
 		*/
 		public String getColumnName(int columnIndex)
 		{
             TableColumnAssociation association = (TableColumnAssociation)
                 parent.columns.objectAtIndex( columnIndex );
             Object value = ((TableColumn)association.object()).getHeaderValue();
             if ( value != null ) return value.toString();
             return " ";
 		}
 
 		/***
 		* Returns the class of the first item in the
 		* display group bound to the column.
 		*/
 		public Class getColumnClass(int columnIndex)
 		{
             Object value;
             int count = getRowCount();
             for( int i = 0; i < count; i++ )
             { //First row in column is null find one that is not.
                 value = ((TableColumnAssociation)parent.columns.
                     objectAtIndex( columnIndex ) ).valueAtIndex( i );
                 if ( value != null ) return value.getClass();
             }
             return Object.class;
 		}
 
         /***
         * Calls the column association's isEditableAtRow method.
         */
 		public boolean isCellEditable(int rowIndex,
 									  int columnIndex)
 		{
 			return
 				((TableColumnAssociation)parent.columns.objectAtIndex(
 					columnIndex ) ).isEditableAtRow( rowIndex );
 		}
 
         /***
         * Calls the column association's valueAtIndex method.
         */
 		public Object getValueAt(int rowIndex,
 								 int columnIndex)
 		{
 			return
 				((TableColumnAssociation)parent.columns.objectAtIndex(
 					columnIndex ) ).valueAtIndex( rowIndex );
 		}
 
         /***
         * Calls the column association's setValueAtIndex method.
         */
 		public void setValueAt(Object aValue,
 							   int rowIndex,
 							   int columnIndex)
 		{
             Object existingValue = getValueAt( rowIndex, columnIndex );
             
             // don't update display group if value is the same as before
             if ( aValue == existingValue ) return; // handles null case
             if ( existingValue != null ) // both are not null
             {
                 Object newValue = aValue;
                 
                 // if different types
                 if ( newValue.getClass() != existingValue.getClass() )
                 {
                     // convert to string since most editors do anyway
                     newValue = newValue.toString();
                     existingValue = existingValue.toString();
                 }
                 if ( newValue.equals( existingValue ) )
                 {
                     // same value - do nothing
                     return;
                 }
             }
 
             ((TableColumnAssociation)parent.columns.objectAtIndex(
                 columnIndex ) ).setValueAtIndex( aValue, rowIndex );
 		}
 
 	}
 
 }
 
 /*
  * $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.31  2003/08/06 23:07:52  chochos
  * general code cleanup (mostly, removing unused imports)
  *
  * Revision 1.30  2002/11/16 16:33:31  mpowers
  * Now using platform-specific accelerator key for shortcuts.
  *
  * Revision 1.29  2002/05/24 14:41:29  mpowers
  * Throwing an exception for clarity.
  *
  * Revision 1.28  2002/04/10 21:20:04  mpowers
  * Better handling for tree nodes when working with editing contexts.
  * Better handling for invalidation.  No longer broadcasting events
  * when nodes have not been "registered" in the tree.
  *
  * Revision 1.27  2002/03/05 23:18:28  mpowers
  * Added documentation.
  * Added isSelectionPaintedImmediate and isSelectionTracking attributes
  * to TableAssociation.
  * Added getTableAssociation to TableColumnAssociation.
  *
  * Revision 1.25  2002/03/04 22:49:53  mpowers
  * Now working with TreeColumnAssociation to delegate sorting behavior.
  *
  * Revision 1.23  2002/03/04 03:58:17  mpowers
  * Refined table header click behavior.
  *
  * Revision 1.22  2002/03/01 23:41:39  mpowers
  * Added facility to get table association from model.
  *
  * Revision 1.21  2002/03/01 20:41:22  mpowers
  * Cleaned up unused code.
  *
  * Revision 1.20  2002/03/01 15:42:00  mpowers
  * Table column headers now always show their sort indicator.
  * A third table-column click clears the sort for that column.
  *
  * Revision 1.19  2002/02/28 23:01:39  mpowers
  * TableColumnAssociations add and remove themselves from the TableAssociation
  * when their connection is established and broken respectively.
  * TableAssociations now break connection if they have no column associations.
  *
  * Revision 1.18  2002/02/28 22:45:27  mpowers
  * Now registers as editing association when table gets focus, so that
  * endEditing can appropriate commit any table cell editors.
  *
  * Revision 1.17  2001/10/26 20:01:50  mpowers
  * We're again cancelling instead of stopping editing on subjectChanged.
  * I believe that the introduction of NSRunLoop has allowed us to return
  * to the correct behavior.
  *
  * Revision 1.16  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.15  2001/07/25 15:03:01  mpowers
  * getColumnName now checks for a column header value before defaulting " ".
  *
  * Revision 1.14  2001/06/05 19:09:25  mpowers
  * Fixed broken build.
  *
  * Revision 1.13  2001/06/05 19:08:12  mpowers
  * Better determination of column class.  Previously, if the first object
  * was null, Object.class was used.  Now we get the first non-null object.
  *
  * Revision 1.12  2001/05/02 17:39:01  mpowers
  * Now selects from display group after initial population.
  *
  * Revision 1.11  2001/03/29 23:05:22  mpowers
  * Fixes for editing table cells.
  *
  * Revision 1.10  2001/03/09 22:09:22  mpowers
  * Now better handling jdk1.1 for rendering the column header.
  *
  * Revision 1.9  2001/02/27 02:10:38  mpowers
  * No longer updating values to the display group if the value
  * has not changed.
  *
  * Revision 1.8  2001/02/17 16:52:05  mpowers
  * Changes in imports to support building with jdk1.1 collections.
  *
  * Revision 1.7  2001/02/16 17:47:17  mpowers
  * Now cancelling any cell editing on subjectChanged().
  *
  * Revision 1.6  2001/01/12 19:11:56  mpowers
  * Fixed table column click sorting.
  *
  * Revision 1.5  2001/01/12 17:20:30  mpowers
  * Moved EOSortOrdering creation to ColumnAssociation.
  *
  * Revision 1.4  2001/01/11 21:55:57  mpowers
  * Implemented sort indicator for table column headers.
  *
  * Revision 1.3  2001/01/11 20:34:26  mpowers
  * Implemented EOSortOrdering and added support in framework.
  * Added header-click to sort table columns.
  *
  * Revision 1.2  2001/01/08 20:40:51  mpowers
  * JTables in 1.3 clear their selection when the data model changes,
  * which sends a list selection event.  We now reset the selection again
  * after the data changes so we're compatible across 1.2 and 1.3.
  *
  * Revision 1.1.1.1  2000/12/21 15:49:00  mpowers
  * Contributing wotonomy.
  *
  * Revision 1.7  2000/12/20 16:25:41  michael
  * Added log to all files.
  *
  *
  */