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