Programming Languages Suite/ProgLangD.iso/VCAFE.3.0A/Main.bin/MultiList.java

Text File | 1999-01-12 | 113KB | 3,849 lines

package symantec.itools.awt;

import java.awt.*;
import java.awt.event.*;
import java.util.BitSet;
import java.util.Vector;
import java.util.Hashtable;
import java.beans.PropertyVetoException;
import java.beans.PropertyChangeListener;
import java.beans.VetoableChangeListener;
import symantec.itools.awt.multiList.Cell;
import symantec.itools.awt.multiList.TextAndImageCell;
import symantec.itools.awt.multiList.CompareTextAndImageCells;
import symantec.itools.beans.VetoableChangeSupport;
import symantec.itools.beans.PropertyChangeSupport;
import java.text.MessageFormat;
import java.util.ResourceBundle;

// ===================================================================================
// = Component Notes
// ===================================================================================

// To visually use this component, you should use the following steps:
//        1. Create a MultiList component
//        2. Set the headings via 'Column Headings' property in the property list
//        3. (Optionally) Set the alignment of the headings via the 'Column Alignments' property
//        4. (Optionally) Set the size of the columns via the 'Column Sizes' property.
//           Otherwise, leave this blank and the columns will be automatically sized
//        5. Set the contents by using the 'List Items' property in the propery list:
//           (Note: the format for this property is:
//                 row1col1;row1col2;row1col2
//                 row2col1;row2col2;row2col2
//            or in other words seperate the columns by using a semi-colon.)


// ===================================================================================
// = Revision History
// ===================================================================================

//  02/03/97    TWB    Added reshape override to reset the columns during runtime
//                    Added a get/set ColumnSizes properties/methods so that widths
//                    can be determined at design time
//                    Added a get/set ColumnAlignments properties/methods so that alignments
//                    can be determined at design time
//  02/06/97    TWB    Added check for null strings in setListItems
//                    Integrated TGL's change for getListItems
//  03/14/97    RKM    Made changeSelection public as per customer request
//  03/17/97    TGL    Fixed multilists in tab panels (actually, multilists added to anything
//                    without a peer)
//  03/20/97    RKM    Added forceRedraw flag to handle more efficient redraws
//                    Set forceRedraw in addTextCell, addImageCell, & addCell so changes would
//                    redrawn into offscreen
//                    Changed all redraw followed by repaints to use forceRedraw flag
//  03/21/97    RKM    Removed repaint hack from paint
//  03/25/97    RKM    Removed forced call to redraw from repaint when designing (Why was that there???)
//  03/27/97    TNM    Added horizontal Scrollbar
//  03/27/97    RKM    Changed getCellText to return empty String if the elementAt throws
//                    instead of throwing or as the code thought, return null
//                    Added getCellImage
//  03/27/97    RKM    Changed hard coded numbers for verticalScrollbarWidth & scrollbarHeight to use prefferedSize of scrollbars
//  04/09/97    RKM    Changed CompareCells' lessThan method to handle nulls passed to it (this removes the nullPointException, but doesn't fix the sort problem)
//  04/17/97    LAB    Added Don Haney's ([e-mail]) fixes that addressed:
//                    Column widths revert to default after hide()/show(); modified setHeading(String h, int i, int pixels)
//                    Return from getColumnSize() inconsistent with setHeading(); modified getColumnSize() to return splitters[i + 1], rather than splitters[i]
//                    Scrollbar values and number of items to draw incorrectly set.  Fix in redraw().
//  05/02/97    RKM    Changed setHeadings to accept String of ; as well as array
//                    Added calcHeadings to handle a delayed calulation of headings when add had not been called before setHeadings
//                    Generalized handling of either String[] or ; separated tokens and added it to setHeadings, setColumnAlignments, & setColumnSizes
//                    Added removeRow (people on the newsgroup wanted this)
//  05/22/97    RKM    Changed setSelectedRow to call changeSelection
//  05/30/97    LAB    Updated to Java 1.1
//  06/01/97    RKM    Changed symantec.beans references to java.beans
//  05/30/97    LAB    Now fires ItemEvents (as it should), now has listener registration
//                    functions for bound and constrained property listeners.
//  05/15/97    TNM    Check for vendor to correct scrollbar problem.
//  06/20/97    TNM    Merged changes
//  06/20/97    TNM    Allowed reverse sorting. Changed repaint.
//  06/26/97    CAR    Bug fix in calcHeadnings when list.length is 0
//  07/14/97    LAB    Updated cursor handling for JDK 1.1.  Removed frame() method and changed calls to
//                    the frame's setCursor() to be calls to Component's setCursor() as per JDK 1.1.
//                    Updated version to 1.1.  Added add/removeNotify to handle event listener registration,
//                    and removed old event listener registration in the Constructor.
//                    Separated CompareCells and Cell classes, and made then public to accommodate
//                    future extendibility of the MultiList class.  Made most data members protected
//                    for this purpose also.  Added AllowSorting property.
//  07/18/97    LAB    Changed incorrect calls to invalidate() to repaint().
//  07/23/97    CAR changed visibility of field "hasFocus" from private to package
//                  marked fields transient as needed
//                  inner classes implement java.io.Serializable
//  08/04/97    RKM    Added override of setLayout - so users could not change it
//                    Renamed a couple of things for more readable code
//                    Fixed a couple of the setters to compare objects properly
//                    Reworked drawing of headings (screwed Window's drawing - NEED TO FIX)
//                    Fixed click and drag in and out of column heading - it would depress only first time
//                    Fixed font save/restore bug in drawHeading (was typo)
//                    Lots of tweaks to make drawing better (not platform specific)
//                    Fixed setSelectedRow to work correctly
//                    Added allowResizingOfColumns, did not make it a property
//                    Fixed bug where dragging out of the column heading and then clicking in a cell and dragging into heading
//                        resulted in the heading sorting
//  08/05/97    RKM    Added selectAll & deselectAll
//                    Fixed drawing of the selection border
//                    Added setMultipleMode & isMultipleMode
//                    Reworked drawRows
//                    Made selectRow & deSelectRow public
//                    Removed propertyChanged & veto stuff from setSelectedRow
//                    Fixed scrolling up via arrows bug
//                    Fixed clicking below last cell bug
//                    Fixed clicking in column header and swapping of sort order (even if clicking in another cell) bug
//  08/06/97    RKM    Added mechanisms to allow users to plug in own drawing and sorting routines (not as great as it could be)
//                    Cleaned up redraw() to not recreate offscreen image every time (was a bug)
//  08/07/97    RKM    Changed auto resizing mechanism to never allocate columnSizes
//                    Added auto-resize property
//  08/09/97    RKM    Temp fixed for column alignment problem - I need to come back to this and make column
//                        alignment behave as column sizes
//  08/10/97    RKM    Change stategy on redraws/repaints
//  08/11/97    RKM    Change column alignments to allow for better default column alignment support
//                    Fixed injection caused by setSupressRedraw, tiggerRedraw was not getting called
//  08/16/97    RKM    Added ability for user (extender) to override the calculation of the header height
//  08/17/97    RKM    Added property to show or hide the headings - user request
//                     Added property to control the visual indication of focus
//  08/19/97    CAR Changed addTextCell, if String object is null set to ""
//  08/25/97    RKM    Changed drawing - no headings, no drawing
//                    Added internalCreateColumns, so CreateColumns could triggerRedraw
//                    Added headings as needed in setListItems (allows users to set items before headings)
//                    Fixed bug in getColumnAlignment, it was not returning the alignment of the last column
//                    Fixed setNumberOfColumns to function better
//                    Added isFocusTraversable override
//  08/27/97    CAR Fixed bug in multiple mode pertaining to mouse input event modifiers
//  09/03/97    RKM Add recalc of column widths when adding columns automatically in resizeHeadings
//  09/11/97    RKM Changed default font from Helvetica to SansSerif
//  09/24/97    RKM Properly set isSun1_1, now that MRJ is working well!!!!!!!!
//  10/20/97    LAB Added suppress redraws around calls to calcVerticalScrollbarPosition in redraw
//                    since calcVerticalScrollbarPosition calls adjustHeadings wich could end up calling
//                    triggerRedraw and put the form editor in an infinite loop (Addresses Mac Bug #8567).
//  10/21/97    JYZ Add synchronized keyword to all registration methods
//  10/21/97    JYZ Fixed bug in the set Foreground color for the list item. It should be set to
//                  a system color instead of an absolute color such as black. Then this may
//                  explain why we see different results on different systems. (A Customer bug report)
//  12/19/97    DS  Added checks for null buffer and rectangle
//  03/03/98    DS  Added DeprecatedException to stop use of "impossible to get right" method
//  07/29/98    LAB    Added check for null clip upon creation of the offscreen image.  Fixes redraw problem
//                    on unix based machines.
//  10/05/98    MSH Fixed Multilist changeSelection() so that the scroll down case works correctly
//  01/12/99    MSH Fixed problem where MultiList scrollbar would not appear under Microsoft VM (#69651)

/**
 * This class implements a multi-column listbox component.
 * Use to create a box that displays a matrix of items that the user can
 * selectRow. The user cannot type or edit a selection in a list box.
 * <p>
 * The user can resize a column at run-time by dragging the column boundary
 * to a new position.
 * <p>
 * @version 1.1, July 14, 1997
 * @author Symantec
 */
public class MultiList extends Panel implements java.io.Serializable, java.awt.ItemSelectable
{
    /**
     * Maximum time inverval to register a double click (in milliseconds).
     */
    public final static long CLICKTHRESHOLD = 250;

    /**
     * Left-justify column alignment constant.
     */
    public final static int LEFT = 0;

    /**
     * Center-justify column alignment constant.
     */
    public final static int CENTER = 1;

    /**
     * Right-justify column alignment constant.
     */
    public final static int RIGHT = 2;

    /**
     * Border amount. Only calc'd on the right and the bottom side.
     */
    protected final static int BORDER = 1;
    /**
     * Fudge factor for resizing of columns.
     */
    protected final static int RESIZE_FUDGE_FACTOR = 3;

    //
    // Constructors
    //

    /**
     * Constructs a default MultiList.
     */
    public MultiList()
    {
        this(0, false, Color.white);
    }

    /**
     * Constructs a new MultiList with the specified number of columns.
     * @param cols the number of columns
     */
    public MultiList(int cols)
    {
        this(cols, false, Color.white);
    }

    /**
     * Constructs a new MultiList with the spcified number of columns
     * and whether multiple row selection allowed.
     * @param cols the number of columns
     * @param multi true for multiple row selection, false otherwise
     */
    public MultiList(int cols, boolean multi)
    {
        this(cols, multi, Color.white);
    }

    /**
     * Constructs a new MultiList with the specified number of columns,
     * whether multiple row selection is allowed, and given background color.
     * @param cols the number of columns
     * @param multi true for multiple row selection, false otherwise
     * @param bg the background color
     */
    public MultiList(int cols, boolean multi, Color bg)
    {
        internalCreateColumns(cols);

        multiSelect = multi;

        super.setLayout(null);

        Font defaultFont = new Font("SansSerif", Font.PLAIN, 12);
        try
        {
            setHeadingFont(defaultFont);
            setCellFont(defaultFont);
        }
        catch(PropertyVetoException e){}

        setBackground(colorBg = bg);

        verticalScrollbar = new Scrollbar(Scrollbar.VERTICAL);
        verticalScrollbar.hide();
        add(verticalScrollbar);

        horizontalScrollbar = new Scrollbar(Scrollbar.HORIZONTAL);
        horizontalScrollbar.hide();
        add(horizontalScrollbar);
    }

    //
    // Properties
    //

    /**
     * Sets whether this MultiList should allow multiple selections or not.
     * @param b the boolean to allow multiple selections
     * @see #isMultipleMode
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setMultipleMode(boolean b)
        throws PropertyVetoException
    {
        if (multiSelect != b)
        {
            Boolean oldValue = new Boolean(multiSelect);
            Boolean newValue = new Boolean(b);

            vetos.fireVetoableChange("multipleMode", oldValue, newValue);

            multiSelect = b;

            //If turning multimode off, only the first row in the selection should stay selected
            if (!multiSelect)
            {
                int[] selectedRows = getSelectedRows();
                for (int i = 1;i < selectedRows.length;i++)
                    deselectRow(selectedRows[i]);
            }

            changes.firePropertyChange("multipleMode", oldValue, newValue);
        }
    }

    /**
     * Returns true if this MultiList allows multiple selections.
     * @see #setMultipleMode
     */
    public boolean isMultipleMode()
    {
        return multiSelect;
    }

    /**
     * Sets whether this MultiList should visually indicate focus.
     * @param b the boolean to visually indicate focus
     * @see #isFocusIndicatedVisually
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setFocusIndicatedVisually(boolean b)
        throws PropertyVetoException
    {
        if (focusIndicatedVisually != b)
        {
            Boolean oldValue = new Boolean(focusIndicatedVisually);
            Boolean newValue = new Boolean(b);

            vetos.fireVetoableChange("focusIndicatedVisually", oldValue, newValue);

            focusIndicatedVisually = b;

            changes.firePropertyChange("focusIndicatedVisually", oldValue, newValue);

            repaintFocus();
        }
    }

    /**
     * Returns true if this MultiList indicates it has focus visually.
     * @see #setFocusIndicatedVisually
     */
    public boolean isFocusIndicatedVisually()
    {
        return focusIndicatedVisually;
    }

    /**
     * Sets the number of columns.
     * @param i the new number of columns
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     * @see #getNumberOfCols
     */
    public void setNumberOfCols(int i)
        throws PropertyVetoException
    {
        Integer oldValue = new Integer(getNumberOfCols());
        Integer newValue = new Integer(i);

        if (!oldValue.equals(newValue))
        {
            vetos.fireVetoableChange("numberOfCols", oldValue, newValue);

            internalCreateColumns(0);
            resizeHeadings(i);
            forceColumnSizeRecalc = true;

            changes.firePropertyChange("numberOfCols", oldValue, newValue);

            triggerRedraw();
        }
    }

    /**
     * @deprecated
     * @see #setNumberOfCols(int)
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setColumns(int i) throws PropertyVetoException
    {
        setNumberOfCols(i);
    }

    /**
     * Returns the current number of columns.
     * @return the current number of columns.
     * @see #setNumberOfCols
     */
    public int getNumberOfCols()
    {
        return headings.length;
    }

    /**
     * Gets the current number of rows.
     * @return the current number of rows
     */
    public int getNumberOfRows()
    {
        return cells.rows();
    }


    /**
     * Sets whether this MultiList should draw the column headings or not.
     * @param b the boolean to draw column headings
     * @see #isHeadingVisible
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadingVisible(boolean b)
        throws PropertyVetoException
    {
        if (headingVisible != b)
        {
            Boolean oldValue = new Boolean(headingVisible);
            Boolean newValue = new Boolean(b);

            vetos.fireVetoableChange("headingVisible", oldValue, newValue);

            headingVisible = b;

            changes.firePropertyChange("headingVisible", oldValue, newValue);

            if (headingVisible)
                calculateHeadingHeight();
            else
                headingHeight = 0;

            //!!!RKM!!! Had to do this to handle mystery column not going away
            //???RKM??? If I remove the mystery column on resize, I can probably remove this
            forceFullRedraw = true;
            triggerRedraw();
        }
    }

    /**
     * Returns true if heading of the MultiList is visible.
     * @see #setHeadingVisible
     */
    public boolean isHeadingVisible()
    {
        return headingVisible;
    }

    /**
     * Returns the heading text of the specified column.
     * @param i the zero-relative index of the column
     * @see #setHeading
     */
    public String getHeading(int i)
    {
        return headings[i];
    }

    /**
     * Sets a column's heading text.
     * @param h the new column heading text
     * @param i the zero-relative index of the column
     * @see #setHeading(java.lang.String, int, int)
     * @see #getHeading
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeading(String h, int i)
        throws PropertyVetoException
    {
        String oldValue = headings[i];
        if (!symantec.itools.util.GeneralUtils.objectsEqual(oldValue,h))
        {
            String newValue = h;

            vetos.fireVetoableChange("heading", oldValue, newValue);

            headings[i] = h;

            changes.firePropertyChange("heading", oldValue, newValue);

            triggerRedraw();
        }
    }

    /**
     * Sets a column's heading text and width.
     * @param h the new column heading text
     * @param i the zero-relative index of the column
     * @param pixels the new width of the column, in pixels
     * @see #setHeading(java.lang.String, int)
     * @see #getHeading
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeading(String h, int i, int pixels) throws PropertyVetoException
    {
        throw new DeprecatedException("symantec.itools.awt.Multilist.setHeadings(String, int, int)\n" +
                                      "cannot be used.  Please change your code to\n" +
                                      "setColumnSizes(String[]) instead");



/*
        String oldValue = headings[i];
        if (!symantec.itools.util.GeneralUtils.objectsEqual(oldValue,h))
        {
            String newValue = h;

            vetos.fireVetoableChange("heading", oldValue, newValue);

            headings[i] = h;
            splitters[i+1] = pixels;

            {
                //???RKM??? Shouldn't this be done in such a way as to allow vetoing

                if (columnSizes == null)
                    columnSizes = new int[headings.length];

                // Update all; the user might not set headings in sequence 0 to n

                for (int j = 0;j < headings.length;j++)
                    columnSizes[j] = splitters[j + 1] - splitters[j];
            }

            changes.firePropertyChange("heading", oldValue, newValue);

            triggerRedraw();
        }
        */
    }

    /**
     * Gets a String array of all of the column headings.
     * @return an array of all of the current headings
     * @see #setHeadings
     */
    public String[] getHeadings()
    {
        return headings;
    }

    /**
     * Initializes all the column headings with the given list.
     * For each string in the given list, create a column, use the string as
     * its heading, and give it a default width.
     * @param list array of heading title strings
     * @see #getHeadings
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadings(String[] list) throws PropertyVetoException
    {
        //Supress redraws
        boolean wasSuppressingRedraw = setSupressRedraw(true);

        try
        {
            //Handle String Arrays as well as array of one string with ; separators
            list = tokenizeStringArrayIfNeeded(list);

            String[] oldValue = getHeadings();

            vetos.fireVetoableChange("headings", oldValue, list);

            if (list.length == 0)
                internalCreateColumns(0);
            else
                calcHeadings(list);

            changes.firePropertyChange("headings", oldValue, list);
        }
        finally
        {
            forceColumnSizeRecalc = true;
            triggerRedraw();
            setSupressRedraw(wasSuppressingRedraw);
        }
    }

    /**
     * Returns the font for column heading text.
     * @see #setHeadingFont
     */
    public Font getHeadingFont()
    {
        return headingFont;
    }

    /**
     * Sets the font for column heading text.
     * @param newFont the font for heading text
     * @see #getHeadingFont
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadingFont(Font newFont) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(headingFont,newFont))
        {
            Font oldValue = getHeadingFont();

            vetos.fireVetoableChange("headingFont", oldValue, newFont);

            headingFont = newFont;

            changes.firePropertyChange("headingFont", oldValue, newFont);

            if (headingVisible)
            {
                calculateHeadingHeight();
                triggerRedraw();
            }
        }
    }

    /**
     * Returns the font currently used for text in all the cells.
     * @see #setCellFont
     */
    public Font getCellFont()
    {
        return cellFont;
    }

    /**
     * Sets the font used for text in all the cells.
     * @param f the font for cell text
     * @see #getCellFont
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setCellFont(Font f) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(cellFont,f))
        {
            Font oldValue = cellFont;

            vetos.fireVetoableChange("cellFont", oldValue, f);

            cellFont = f;
            FontMetrics fontMetrics = getFontMetrics(f);
            cellAscent = fontMetrics.getAscent();
            cellDescent = fontMetrics.getDescent();
            cellHeight = fontMetrics.getHeight();

            changes.firePropertyChange("cellFont", oldValue, f);

            triggerRedraw();
        }
    }

    /**
     * Sets the column heading foreground and background colors.
     * @param fg foreground Color for heading text
     * @param bg background Color for heading text
     * @see #setHeadingFg
     * @see #setHeadingBg
     * @see #getHeadingFg
     * @see #getHeadingBg
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadingColors(Color fg, Color bg) throws PropertyVetoException
    {
        boolean wasSupressingRedraw = setSupressRedraw(true);

        try
        {
            setHeadingFg(fg);
            setHeadingBg(bg);
        }
        finally
        {
            triggerRedraw();
            setSupressRedraw(wasSupressingRedraw);
        }
    }

    /**
     * Returns the color of the column heading text foreground.
     * @return the current column heading foreground color
     * @see #setHeadingFg
     */
    public Color getHeadingFg()
    {
        return headingFg;
    }

    /**
     * Sets the column heading text foreground color.
     * @param c foreground color for heading text
     * @see #getHeadingFg
     * @see #setHeadingBg
     * @see #setHeadingColors
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadingFg(Color c) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(headingFg,c))
        {
            Color oldValue = headingFg;

            vetos.fireVetoableChange("headingFg", oldValue, c);

            headingFg = c;

            changes.firePropertyChange("headingFg", oldValue, c);

            triggerRedraw();
        }
    }

    /**
     * Returns the color of the column heading text background.
     * @return the current column heading background color
     * @see #setHeadingBg
     */
    public Color getHeadingBg()
    {
        return headingBg;
    }

    /**
     * Sets the column heading text background color.
     * @param c background color for heading text
     * @see #getHeadingBg
     * @see #setHeadingFg
     * @see #setHeadingColors
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setHeadingBg(Color c) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(headingBg,c))
        {
            Color oldValue = headingBg;

            vetos.fireVetoableChange("headingBg", oldValue, c);

            headingBg = c;

            changes.firePropertyChange("headingBg", oldValue, c);

            triggerRedraw();
        }
    }

    /**
     * Sets foreground and background colors of cell text.
     * @param fg the foreground color of cell text
     * @param bg the background color of cell text
     * @see #setCellFg
     * @see #setCellBg
     * @see #getCellFg
     * @see #getCellBg
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setCellColors(Color fg, Color bg) throws PropertyVetoException
    {
        boolean wasSupressingRedraw = setSupressRedraw(true);
        try
        {
            setCellFg(fg);
            setCellBg(bg);
        }
        finally
        {
            triggerRedraw();
            setSupressRedraw(wasSupressingRedraw);
        }
    }

    /**
     * Gets the current foreground color of cell text.
     * @return the current cell foreground color
     * @see #setCellFg
     */
    public Color getCellFg()
    {
        return colorFg;
    }

    /**
     * Sets the foreground color of cell text.
     * @param c the foreground color of cell text
     * @see #getCellFg
     * @see #setCellBg
     * @see #setCellColors
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setCellFg(Color c) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(colorFg,c))
        {
            Color oldValue = colorFg;

            vetos.fireVetoableChange("cellFg", oldValue, c);

            colorFg = c;

            changes.firePropertyChange("cellFg", oldValue, c);

            triggerRedraw();
        }
    }

    /**
     * Sets the background color of cell text.
     * @param c the background color of cell text
     * @see #getCellBg
     * @see #setCellFg
     * @see #setCellColors
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setCellBg(Color c) throws PropertyVetoException
    {
        if (!symantec.itools.util.GeneralUtils.objectsEqual(colorBg,c))
        {
            Color oldValue = colorBg;

            vetos.fireVetoableChange("cellBg", oldValue, c);

            colorBg = c;

            changes.firePropertyChange("cellBg", oldValue, c);

            triggerRedraw();
        }
    }

    /**
     * Gets the current background color of cell text.
     * @return the current cell background color
     * @see #setCellBg
     */
    public Color getCellBg()
    {
        return colorBg;
    }

    /**
     * Sets the alignment of each column.
     * If null is passed, then the default alignment for all columns is used.
     * @param list an array of strings that determines column alignment.
     * Each item should contain one of the following: "Left", "Center", or "Right"
     * @see #getColumnAlignments
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setColumnAlignments(String[] list)
        throws PropertyVetoException
    {
        //Preprocess list (zero elements == null)
        if (list != null && list.length == 0)
            list = null;

        //More preprocessing of lists (users could pass array or single string with ; as separators)
        list = tokenizeStringArrayIfNeeded(list);

        //???RKM??? What if the size passed in is not the same as the headings array size

        String[] oldValue = getColumnAlignments();

        vetos.fireVetoableChange("columnAlignments", oldValue, list);

        if (list != null)
        {
            // Initialize the columnSizes array again
            columnAlignments = new int[list.length];

            for (int i = 0; i < list.length; i++)
            {
                String listElem = list[i];

                int alignment = defaultColumnAlignment;
                if (listElem != null)
                {
                    if (listElem.equalsIgnoreCase("Left"))
                        alignment = LEFT;
                    else if (listElem.equalsIgnoreCase("Center"))
                        alignment = CENTER;
                    else if (listElem.equalsIgnoreCase("Right"))
                        alignment = RIGHT;
                }

                columnAlignments[i] = alignment;
            }
        }
        else columnAlignments = null;

        changes.firePropertyChange("columnAlignments", oldValue, list);

        triggerRedraw();
    }

    /**
     * Gets a string array containing the alignment of each column.
     * The possible values for each element are "Left", "Center", or "Right".
     * @return an array of strings containing the alignment for each column
     * @see #setColumnAlignments
     */
    public String[] getColumnAlignments()
    {
        //If using default alignment for all columns, then return null
        if (columnAlignments == null)
            return null;

        String[] list = new String[columnAlignments.length];

        for (int i = 0; i < list.length; i++)
        {
            String alignString;
            switch (getColumnAlignment(i))
            {
                case LEFT:
                default:
                    alignString = "Left";
                    break;
                case CENTER:
                    alignString = "Center";
                    break;
                case RIGHT:
                    alignString = "Right";
                    break;
            }//switch

            list[i] = alignString;
        }

        return list;
    }

    /**
     * Sets the alignment of the text in the specified column.
     * @param column the zero-relative column index
     * @param alignment one of the values: LEFT, CENTER, or RIGHT
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     * @see #getColumnAlignment
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setColumnAlignment(int column, int alignment)
        throws PropertyVetoException
    {
        //Range check
        rangeCheckAlignment(alignment);
        rangeCheckColumn(column);

        Integer oldValue = new Integer(getColumnAlignment(column));
        Integer newValue = new Integer(alignment);

        vetos.fireVetoableChange("columnAlignment", oldValue, newValue);

        //Handle switching from default alignment
        if (columnAlignments == null)
        {
            columnAlignments = new int[headings.length];
            for (int i = 0;i < headings.length;i++)
                columnAlignments[i] = -1;
        }

        this.columnAlignments[column] = alignment;

        changes.firePropertyChange("columnAlignment", oldValue, newValue);

        triggerRedraw();
    }

    /**
     * Gets the justification of the text for the specified column.
     * If the column is allocated, it returns the justification.
     * Otherwise it returns the default justification.
     * @param column the zero-relative column index
     * @return the alignment of the column as one of the values LEFT, CENTER, or RIGHT
     * @see #setColumnAlignment(int, int)
     */
    public int getColumnAlignment(int column)
    {
        if (columnAlignments != null && column < columnAlignments.length)
        {
            int columnAlignment = columnAlignments[column];
            if (columnAlignment != -1)
                return columnAlignments[column];
        }

        return getDefaultColumnAlignment();
    }

    /**
     * Gets the default column alignment.
     * This value is used when a column alignment is not specified.
     * @return the default column alignment, one of: LEFT, CENTER, or RIGHT
     * @see #setDefaultColumnAlignment
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     */
    public int getDefaultColumnAlignment()
    {
        return defaultColumnAlignment;
    }

    /**
     * Sets the default column alignment.
     * This value is used when an alignment is not specified for a column.
     * @param newDefaultColumnAlignment the new default column alignment, one of: LEFT, CENTER, or RIGHT
     * @see #getDefaultColumnAlignment
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setDefaultColumnAlignment(int newDefaultColumnAlignment)
        throws PropertyVetoException
    {
        rangeCheckAlignment(newDefaultColumnAlignment);

        if (defaultColumnAlignment != newDefaultColumnAlignment)
        {
            Integer oldValue = new Integer(defaultColumnAlignment);
            Integer newValue = new Integer(newDefaultColumnAlignment);

            vetos.fireVetoableChange("defaultColumnAlignment",oldValue,newValue);

            defaultColumnAlignment = newDefaultColumnAlignment;

            changes.firePropertyChange("defaultColumnAlignment",oldValue,newValue);

            triggerRedraw();
        }
    }

    /**
     * Sets the the width of each column in pixels.
     * Setting the column sizes to null will turn auto resizing on.
     * @param list a string array containing column sizes in pixels
     * @see #getColumnSizes
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setColumnSizes(String[] list)
        throws PropertyVetoException
    {
        //Supress redraws
        boolean wasSuppressingRedraw = setSupressRedraw(true);

        try
        {
            //Preprocess list (zero elements == null)
            if (list != null && list.length == 0)
                list = null;

            //More preprocessing of lists (users could pass array or single string with ; as separators)
            list = tokenizeStringArrayIfNeeded(list);

            String[] oldValue = getColumnSizes();

            vetos.fireVetoableChange("columnSizes", oldValue, list);

            if (list != null)
            {
                //???RKM??? What do we do if the size passed in is different than the num columns ???

                // Initialize the columnSizes array again
                columnSizes = new int[list.length];

                int total = 0;

                for (int i = 0; i < list.length; i++)
                {
                    int stringValue = 10;
                    try
                    {
                        String listElem = list[i];
                        if (listElem != null)
                            stringValue = Integer.parseInt(listElem);
                    }
                    catch (Exception e)
                    {
                    }
                    columnSizes[i] = stringValue;

                    if (splitters.length > i + 1)
                        splitters[i+1] = total += columnSizes[i];
                }

                if (splitters.length > 1)
                    splitters[0] = 0;
            }
            else
            {
                columnSizes = null;
                adjustHeadings();
            }

            changes.firePropertyChange("columnSizes", oldValue, list);
        }
        finally
        {
            triggerRedraw();
            setSupressRedraw(wasSuppressingRedraw);
        }
    }

    /**
     * Returns a string array containing the width of each column in pixels.
     * If columns are being automatically sized, it will return null.
     * @see #setColumnSizes
     */
    public String[] getColumnSizes()
    {
        return intArrayToStringArray(columnSizes);
    }

    /**
     * Get the column size in pixels for the specified column.
     * @param i the zero-relative column index
     */
    public int getColumnSize(int i)
    {
        return splitters[i + 1];
    }

    /**
     * Sets the specified row as the selected row.
     * @param row the zero-relative index of the row to selectRow
     * @exception IllegalArgumentException if the row parameter is out of range
     * @see getSelectedRow
     */
    public void setSelectedRow(int row) throws IllegalArgumentException
    {
        if (row < 0 || row > cells.rows() - 1){
            Object[] args = { new Integer(row) };
            throw new IllegalArgumentException(MessageFormat.format(errors.getString("InvalidRowNumber"), args));
        }

        selectRow(row);
    }

    /**
     * Returns the zero-relative index of the currently selected row.
     * Returns -1 if nothing is selected, or if more than one item is selected (in multi-mode)
     * @see #setSelectedRow
     * @see #isMultipleMode
     * @see #setMultipleMode
     */
    public int getSelectedRow()
    {
        int[] selected = getSelectedRows();

        if (selected.length == 1)
            return selected[0];
        return -1;
    }

    /**
     * Selects all rows in a MultiList. Does nothing if multiMode is off.
     * @see #deselectAll
     * @see #isMultipleMode
     * @see #setMultipleMode
     */
    public void selectAll()
    {
        //Only lists in multi-mode can do this
        if (!multiSelect)
            return;

        //Select all rows
        int numRows = getNumberOfRows();
        for (int i = 0;i < numRows;i++)
            selectRow(i);
    }

    /**
     * Deselects all rows in a MultiList.
     * @see #selectAll
     */
    public void deselectAll()
    {
        int[] selectedRows = getSelectedRows();
        for (int i = 0;i < selectedRows.length;i++)
            deselectRow(selectedRows[i]);
    }

    /**
     * Returns an integer index for each selected row.
     * @return the zero-relative indexes of the selected rows
     * @see #getSelectedRow
     * @see #setSelectedRow
     */
    public int[] getSelectedRows()
    {
        int size = highlightedRows.size();
        int count = 0;

        for (int i = 0; i < size; i++)
            if (highlightedRows.get(i))
                count++;

        int[] selections = new int[count];

        count = 0;
        for (int i = 0; i < size; i++)
        {
            if (highlightedRows.get(i))
            {
                selections[count++] = i;
            }
        }

        return selections;
    }

    /**
     * Returns an array of Objects (Integers), one for each selected row index.
     * This is a standard method of the java.awt.ItemSelectable interface.
     * @return the zero-relative indexes of the selected rows
     * May return null (no rows selected)
     * @see #getSelectedRows
     * @see #setSelectedRow
     * @see java.awt.ItemSelectable
     */
    public Object[] getSelectedObjects()
    {
        int[] temp = getSelectedRows();
        int length = temp.length;

        Integer[] newArray = new Integer[length];

        for (int i = 0; i < length; i++)
        {
            newArray[i] = new Integer(temp[i]);
        }

        return newArray;
    }

    /**
     * Sets the minimum allowable column width.
     * @param size the minimum column width in pixels
     * @see #getMinColumnWidth
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setMinColumnWidth(int size) throws PropertyVetoException
    {
        if (minColumnWidth != size && size > 0)
        {
            Integer oldValue = new Integer(minColumnWidth);
            Integer newValue = new Integer(size);

            vetos.fireVetoableChange("minColumnWidth", oldValue, newValue);

            minColumnWidth = size;

            changes.firePropertyChange("minColumnWidth", oldValue, newValue);
        }
    }

    /**
     * Sets the internal flag to supress redraw.
     * Call this to supress redraw, saving the returned boolean. After you've done
     * what you wanted to do restore the flag.
     * @param supressRedraw the new value for the supressing of redraw flags
     */
    public boolean setSupressRedraw(boolean supressRedraw)
    {
        //Save the old value, so we can return it
        boolean wasSupressingRedraw = isSuppressRedraw;

        //Set the new flag
        isSuppressRedraw = supressRedraw;

        //If the caller turned on redraw
        if (isSuppressRedraw != wasSupressingRedraw && !isSuppressRedraw)
        {
            if (redrawWasSupressed)
            {
                redrawWasSupressed = false;
                triggerRedraw();
            }
        }

        //Return the old value
        return wasSupressingRedraw;
    }

    /**
     * Internal helper routine.
     * Resizes the heading to match the number of columns.
     * @param column the number of columns
     */
    protected void resizeHeadings(int column)
    {
        if (column == headings.length)
            return;

        int columnsToAdd = column - headings.length;

        String[] newHeadings = new String[headings.length + columnsToAdd];
        int[] newSplitters = new int[newHeadings.length + 1];

        //Transfer over old columns
        {
            for (int i = 0;i < newHeadings.length;i++)
            {
                if (i < headings.length)
                {
                    newHeadings[i] = headings[i];
                    newSplitters[i + 1] = splitters[i + 1];
                }
                else
                {
                    newHeadings[i] = ("Column " + (i + 1));
                    newSplitters[i + 1] = newSplitters[i] + getMinColumnWidth();
                }
            }
        }

        headings = newHeadings;
        splitters = newSplitters;

        if (columnSizes == null)
            forceColumnSizeRecalc = true;
    }

    /**
     * Initializes all the MultiList cells with text. Each string in the provided
     * array initializes one row. The contents of each column are separated by
     * ";". For example, the string "col0;col1;col2" would result in "col0"
     * being placed in column 0, "col1" in column 1, and "col2" in column 2.
     * Any remaining columns will get cleared.
     * @param items the string array used to initialize all cell contents
     * @see #getListItems
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setListItems(String[] items) throws PropertyVetoException
    {
        //Supress redraws
        boolean wasSuppressingRedraw = setSupressRedraw(true);

        try
        {
            String[] oldValue = getListItems();

            vetos.fireVetoableChange("listItems", oldValue, items);

            clear();

            for (int row = 0; row < items.length; row++)
            {
                String s = items[row];

                // Make sure that we handle null strings by creating an empty string in it's place
                if (s == null)
                    s = "";

                int len = s.length();

                int start, end, col;
                for (end = col = start = 0; end <= len /*&& col < headings.length*/; ++end)
                {
                    if (end == len || s.charAt(end) == ';')
                    {
                        addCell(row, col++, s.substring(start, end), null);
                        start = end + 1;

                        //Handle adding of headings (hey, if the user puts in the data he/she probably wants to see it)
                        if (col > headings.length)
                            resizeHeadings(col);
                    }
                }

                while (col < headings.length)
                    addCell(row, col++, "", null);
            }

            changes.firePropertyChange("listItems", oldValue, getListItems());
        }
        finally
        {
            triggerRedraw();
            setSupressRedraw(wasSuppressingRedraw);
        }
    }

    /**
     * Returns the text contents of all the cells as a string array. A new
     * string is used for each row. The contents of each row's column are
     * separated by ";". For example, the string "col0;;col2" would result
     * from a "col0" in column 0, an empty column 1, and  "col2" in column 2.
     * @return the string array containing the text of all the cells
     * @see #setListItems
     */
    public String[] getListItems()
    {
        Vector v = new Vector();
        String s;
        boolean lastNull = false;
        int row, col;
        String rowString;
        String[] items = new String[cells.rows()];

        for (row = 0; row < cells.rows(); row++) {
            rowString = "";

            for (col = 0; col < headings.length; col++) {
                s = getCellText(row, col);
                if (col != 0) rowString += ";";
                rowString += (s != null) ? s : "";
            }

            items[row] = rowString;
        }

        return items;
    }

    /**
     * Sets the flag to allow sorting of columns when a heading is selected.
     * @param b if true allow columns to be sorted when column heading is clicked;
     * if false, no sorting will occur
     * @see #isAllowSorting
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setAllowSorting(boolean b) throws PropertyVetoException
    {
        if (allowSorting != b)
        {
            Boolean oldValue = new Boolean(allowSorting);
            Boolean newValue = new Boolean(b);

            vetos.fireVetoableChange("allowSorting", oldValue, newValue);

            allowSorting = b;

            changes.firePropertyChange("allowSorting", oldValue, newValue);
        }
    }

    /**
     * Gets the flag controlling sorting of columns when a heading is selected.
     * @return true if columns will be sorted when column heading is clicked;
     * if false, no sorting will occur
     * @see #setAllowSorting
     */
    public boolean isAllowSorting()
    {
        return allowSorting;
    }

    /**
     * Sets the flag to allow resizing of columns via the user interface.
     * @param allowResizing if true the user may resize columns via the UI;
     * if false, columns cannot be resized via the UI
     * @see #isAllowResizingOfColumns
     * @exception PropertyVetoException
     * if the specified property value is unacceptable
     */
    public void setAllowResizingOfColumns(boolean allowResizing)
        throws PropertyVetoException
    {
        if (allowResizingOfColumns != allowResizing)
        {
            Boolean oldValue = new Boolean(allowResizingOfColumns);
            Boolean newValue = new Boolean(allowResizing);

            vetos.fireVetoableChange("allowResizingOfColumns", oldValue, newValue);

            allowResizingOfColumns = allowResizing;

            changes.firePropertyChange("allowResizingOfColumns", oldValue, newValue);
        }
    }

    /**
     * Gets whether columns may currently be resized by the user via the user interface.
     * @return true if resizing of columns via the UI is allowed;
     * if false, columns cannot be resized via the UI
     * @see #setAllowResizingOfColumns
     */
    public boolean isAllowResizingOfColumns()
    {
        return allowResizingOfColumns;
    }

    /**
     * Returns the minimum allowable column width in pixels.
     * @see #setMinColumnWidth
     */
    public int getMinColumnWidth()
    {
        return minColumnWidth;
    }

    /**
     * Adjusts the columns to default width.
     * The width of the columns is adjusted so that all columns fit into the
     * overall width of the MultiList.
     */
    public void adjustHeadings()
    {
        if (headings.length == 0)
        {
            internalCreateColumns(0);
            triggerRedraw();
        }
        else
        {
            Dimension d = size();
            int w = 0, width = (d.width - verticalScrollbarWidth) / headings.length, r = (d.width - verticalScrollbarWidth) - headings.length * width;
            splitters[0] = 0;
            for (int i = 0; i < headings.length; ++i)
                splitters[i+1] = w += width+(i<r?1:0);
        }
    }

    /**
     * Initializes the MultiList with the specified total numer of columns.
     * All old column data is lost. Row data is preserved. Note that this
     * method is identical to the method setNumberOfCols(), but doesn't
     * allow the change to be vetoed.
     * @param i the new number of columns
     * @see #setNumberOfCols
     * @see #getNumberOfCols
     */
    public void createColumns(int i)
    {
        internalCreateColumns(i);

        triggerRedraw();
    }

    /**
     * Internal helper routine.
     * Allocates room for the specified number of columns.
     * @param i the new number of columns
     */
    protected void internalCreateColumns(int i)
    {
        headings = new String[i];
        splitters = new int[i + 1];

        //???RKM??? I do not think this is wanted in all cases (setNumberOfCols)
        columnAlignments = null;
        columnSizes = null;
    }

    /**
     * Removes all rows from the MultiList.
     * @see #removeRow
     */
    public void clear()
    {
        cells.removeAllElements();

        //Stop dragging
        xDragLast = -1;
        isDragging = false;

        selectedRow = -1;
        highlightedRows = new BitSet();

        topRow = 0;
        sbVPosition = 0;

        triggerRedraw();
    }

    /**
     * Removes a single row from the MultiList.
     * @param row the zero-relative index of the row to remove
     * @see #clear
     */
    public void removeRow(int row)
    {
        int numRows = cells.rows();

        //Make certain row is in range
        if (row < 0 || row > numRows - 1)
            return;

        //Remove the row from the matrix
        cells.removeRow(row);

        //If the row is selected, remove it from the selection
        if (highlightedRows.get(row))
            highlightedRows.clear(row);

        //Move selections down
        for (int i = row + 1;i < numRows;i++)
        {
            if (highlightedRows.get(i))
            {
                highlightedRows.clear(i);
                highlightedRows.set(i - 1);
            }
        }

        triggerRedraw();
    }

    /**
     * Gets the object used to compare cells for sorting the specified column.
     * If no sorter has been explicitly specified, the default column sorter
     * will be returned.
     * @param column the zero-relative column index
     * @return the object used to compare column cells
     * @see #setColumnSorter
     */
    public CompareCells getColumnSorter(int column)
    {
        CompareCells compareCellsFunc = (CompareCells)columnCompareCellsRoutines.get(new Integer(column));
        if (compareCellsFunc == null)
            compareCellsFunc = getDefaultColumnSorter();
        return compareCellsFunc;
    }

    /**
     * Sets the object used to compare cells for sorting the specified column.
     * @param column the zero-relative column index
     * @param compare the object used to compare column cells
     * @see #getColumnSorter
     */
    public void setColumnSorter(int column, CompareCells compare)
    {
        columnCompareCellsRoutines.put(new Integer(column),compare);
    }

    /**
     * Gets the default object used to compare column cells for sorting.
     * @return the object used to compare column cells by default
     * @see #setDefaultColumnSorter
     * @see #getColumnSorter
     */
    public CompareCells getDefaultColumnSorter()
    {
        return defaultColumnSorter;
    }

    /**
     * Sets the default object used to compare column cells for sorting.
     * @param newDefaultSorter the object used to compare column cells by default
     * @see #getDefaultColumnSorter
     * @see #setColumnSorter
     */
    public void setDefaultColumnSorter(CompareCells newDefaultSorter)
    {
        defaultColumnSorter = newDefaultSorter;
    }

    /**
     * Sets the text of a cell at the given row and column position.
     * @param r the zero-relative row index
     * @param c the zero-relative column index
     * @param s the new cell text
     * @see #addImageCell
     * @see #addCell
     */
    public void addTextCell(int r, int c, String s)
    {
        if (s == null)
            s = new String("");
        TextAndImageCell cell = new TextAndImageCell(this, s);
        addCellImpl(r,c,cell);
    }

    /**
     * Sets the image of a cell at the given row and column position.
     * @param r the zero-relative row index
     * @param c the zero-relative column index
     * @param i the new cell image
     * @see #addTextCell
     * @see #addCell
     */
    public void addImageCell(int r, int c, Image i)
    {
        TextAndImageCell cell = new TextAndImageCell(this, i);
        addCellImpl(r,c,cell);
    }

    /**
     * Sets the contents of a cell, both text and image.
     * @param r the zero-relative row index
     * @param c the zero-relative column index
     * @param s the new cell text
     * @param i the new cell image
     * @see #addTextCell
     * @see #addImageCell
     */
    public void addCell(int r, int c, String s, Image i)
    {
        TextAndImageCell cell = new TextAndImageCell(this, s, i);
        addCellImpl(r,c,cell);
    }

    /**
     * Sets the contents of a cell to the given cell.
     * @param row the zero-relative row index
     * @param column the zero-relative column index
     * @param cell the new cell
     * @see #addCell
     * @see #addTextCell
     * @see #addImageCell
     */
    public void addCell(int row, int column, Cell cell)
    {
        addCellImpl(row,column,cell);
    }

    /**
     * Adds a cell to the MultiList in the row and column specified.
     * All addCell forms call this method.
     * @param row the zero-relative row index
     * @param column the zero-relative column index
     * @param cell the cell that is being added to the MultiList
     */
    protected void addCellImpl(int row, int column, Cell cell)
    {
        cells.updateElement(row, column, cell);

        triggerRedraw();
    }

    /**
     * Returns the text of the specified cell.
     * @param r the zero-relative row index
     * @param c the zero-relative column index
     * @return the cell text or the empty string ("") if the cell is not allocated
     * @see #getCellImage
     * @see #addCell
     * @see #addTextCell
     */
    public String getCellText(int r, int c)
    {
        try
        {
            //Calling elementAt will throw if the element is not allocated
            TextAndImageCell cell = (TextAndImageCell)cells.elementAt(r,c);

            //The element may be allocated, but that doesn't mean there's an object there
            if (cell != null)
                return cell.getText();
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            //Fall through, so an empty string is returned
        }
        catch(ClassCastException e)
        {
            //Fall through, so an empty string is returned
        }

        return "";
    }

    /**
     * Returns the image of the specified cell, if any.
     * @param r the zero-relative row index
     * @param c the zero-relative column index
     * @return the cell image, or null if the cell is not allocated
     * @see #getCellText
     * @see #addCell
     * @see #addImageCell
     */
    public Image getCellImage(int r, int c)
    {
        try
        {
            //Calling elementAt will throw if the element is not allocated
            TextAndImageCell cell = (TextAndImageCell)cells.elementAt(r,c);

            //The element may be allocated, but that doesn't mean there's an object there
            if (cell != null)
                return cell.getImage();
        }
        catch(ArrayIndexOutOfBoundsException e)
        {
            //Fall through, so null is returned
        }
        catch(ClassCastException e)
        {
            //Fall through, so null is returned
        }

        return null;
    }

    /**
     * Handles redrawing of this component on the screen.
     * This is a standard Java AWT method which gets called by the Java
     * AWT (repaint()) to handle repainting this component on the screen.
     * The graphics context clipping region is set to the bounding rectangle
     * of this component and its [0,0] coordinate is this component's
     * top-left corner.
     * Typically this method paints the background color to clear the
     * component's drawing space, sets graphics context to be the foreground
     * color, and then calls paint() to draw the component.
     *
     * It is overridden here to eliminate the unneeded repainting of the background.
     *
     * @param g the graphics context
     * @see java.awt.Component#repaint
     * @see #paint
     */
    public void update(Graphics g)
    {
        paint(g);
    }

    /**
     * Paints this component using the given graphics context.
     * This is a standard Java AWT method which typically gets called
     * by the AWT to handle painting this component. It paints this component
     * using the given graphics context. The graphics context clipping region
     * is set to the bounding rectangle of this component and its [0,0]
     * coordinate is this component's top-left corner.
     *
     * @param g the graphics context used for painting
     * @see java.awt.Component#repaint
     * @see #update
     */
    public void paint(Graphics g)
    {
        // we can enter here without an image if the multilist is created on
        // a panel without a peer (i.e., a tab panel).  Just to make sure, create
        // it if we need one...

        if (offscreenImage == null)
            redraw();

        if (offscreenImage != null)
        {
            Font f = g.getFont();
            if (f == null)
            {
                f = headingFont;
                setFont(f);
                return;
            }

            Dimension s = size();

            //???RKM??? Why would it always redraw at design time???
            //???RKM??? DO NOT JUST TURN THIS BACK ON - PLEASE COME TALK TO ME (YOU HAVE FOUND A BUG)
            if (cachedWidth != s.width || cachedHeight != s.height || forceRedraw /*|| java.beans.Beans.isDesignTime()*/)
                redraw();

            int heightMinusScrollbar = s.height - scrollbarHeight;
            int widthMinusScrollbar = s.width - verticalScrollbarWidth;

            g.translate(-sbHPosition, 0);
            if (sbVShow && sbHShow)
            {
                g.setColor(SystemColor.control);
                g.fillRect(sbHPosition + widthMinusScrollbar, heightMinusScrollbar, verticalScrollbarWidth, scrollbarHeight);
                g.setColor(Color.black);
                g.drawRect(sbHPosition + widthMinusScrollbar - 1, heightMinusScrollbar - 1, verticalScrollbarWidth, scrollbarHeight);
            }

            g.clipRect(sbHPosition,0,widthMinusScrollbar,heightMinusScrollbar);
            g.drawImage(offscreenImage, 0, 0, this);

            //Draw frame
            //???RKM??? This will flicker - fix
            g.setColor(Color.black);
            g.drawRect(sbHPosition,0, widthMinusScrollbar - 1, heightMinusScrollbar - 1);
        }
    }

    /**
     * Ensures the given column index is valid.
     * An IllegalArgumentException is thrown if it is out of range.
     * @param column the zero-relative column index to validate
     */
    protected void rangeCheckColumn(int column)
    {
        if (column < 0 || column > headings.length - 1)
            throw new IllegalArgumentException(errors.getString("InvalidColumnIndex") + column);
    }

    /**
     * Ensures the given column alignment value is valid.
     * An IllegalArgumentException is thrown if the value is invalid.
     * @param alignment the column alignment value to validate, should
     * be one of: LEFT, CENTER, or RIGHT
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     */
    protected void rangeCheckAlignment(int alignment)
    {
        if (alignment != LEFT && alignment != CENTER && alignment != RIGHT){
            Object[] args = { new Integer(alignment), "LEFT", "CENTER", "RIGHT" };
            throw new IllegalArgumentException(MessageFormat.format(errors.getString("InvalidAlignment"), args));
        }
    }

    /**
     * Determines if the vertical scrollbar needs to be shown.
     * If column sizes are being automatically determined,
     * forces a column size recalc as needed.
     */
    protected void calcVerticalScrollbarPosition(boolean minusHorizontalScrollbar)
    {
        Dimension s = size();

        //Calc if vertical scrollbar is needed
        if (cells.rows() * cellHeight > s.height - headingHeight - BORDER - (headingHeight > 0 ? 0 : BORDER) - (minusHorizontalScrollbar ? scrollbarHeight : 0))
        {
            sbVShow = true;
            verticalScrollbarWidth = verticalScrollbar.preferredSize().width - 1;
        }
        else
        {
            sbVShow = false;
            verticalScrollbarWidth = 0;
        }

        //Adjust column widths, if we are auto calculating
        if (columnSizes == null && (forceColumnSizeRecalc || (cachedWidth != s.width - verticalScrollbarWidth)))
            adjustHeadings();
        forceColumnSizeRecalc = false;
    }

    /**
     * Paints this component into an offscreen image for cleaner screen repaints.
     * It is not typically called directly.
     */
    public void redraw()
    {
        boolean wasSuppressingRedraw;

        Dimension s = size();

        //Set redraw to false
        forceRedraw = false;

        if (s.width == 0 || s.height == 0)
            return;

        //Suppress redraws.  I had to avoid using setSuppressRedraw to avoid looping. LAB.
        wasSuppressingRedraw = isSuppressRedraw;
        isSuppressRedraw = true;
        try
        {
            calcVerticalScrollbarPosition(false);
        }
        finally
        {
            isSuppressRedraw = wasSuppressingRedraw;
        }

        int lastSplitter = splitters[splitters.length-1];

        if (lastSplitter > s.width - verticalScrollbarWidth)
        {
            sbHShow = true;
            scrollbarHeight = horizontalScrollbar.preferredSize().height - 1;

            //Suppress redraws.  I had to avoid using setSuppressRedraw to avoid looping. LAB.
            wasSuppressingRedraw = isSuppressRedraw;
            isSuppressRedraw = true;
            try
            {
                calcVerticalScrollbarPosition(true);
            }
            finally
            {
                isSuppressRedraw = wasSuppressingRedraw;
            }
        }
        else
        {
            sbHShow = false;
            scrollbarHeight = 0;
        }

        //Post calc, set scrollbar positions
        if (!sbVShow)
            sbVPosition = 0;
        if (!sbHShow)
            sbHPosition = 0;

        {
            //Calc needed image width
            int imageWidth = Math.max(lastSplitter, s.width + sbHPosition);

            //Create a new offscreen image, if we need to
            if (offscreenImage == null ||
                offscreenImageGraphics == null ||
                cachedWidth != imageWidth ||
                cachedHeight != s.height ||
                cachedLastSplitter != lastSplitter ||
                offscreenImage.getWidth(this) != imageWidth ||
                forceFullRedraw)
            {
                forceFullRedraw = false;

                //If old offscreenImage, flush it
                if (offscreenImage != null)
                {
                    offscreenImage.flush();
                    offscreenImage = null;
                }

                //Create a new offscreen image
                offscreenImage = createImage(imageWidth, s.height);

                //Cache the height and width of the MultiList
                cachedWidth = s.width;
                cachedHeight = s.height;

                //!!!RKM!!! Note: lastSplitter has to be cached due to the clipRect below
                //???RKM??? This could be removed if we get a working setClip
                //Cache last splitter
                cachedLastSplitter = lastSplitter;

                //If there previously was a graphics, dispose it
                if (offscreenImageGraphics != null)
                {
                    offscreenImageGraphics.dispose();
                    offscreenImageGraphics = null;
                }

                //Hook up to the new offscreenImage
                if (offscreenImage != null)
                    offscreenImageGraphics = offscreenImage.getGraphics();
                //If the clip is null, provide one.  Works around clipping problem on Unix systems -LAB
                if (offscreenImageGraphics != null && offscreenImageGraphics.getClip() == null)
                    offscreenImageGraphics.setClip(0, 0, imageWidth, s.height);
            }
        }

        if (offscreenImageGraphics != null)
        {
            offscreenImageGraphics.setColor(colorBg);
            offscreenImageGraphics.fillRect(0,0,offscreenImage.getWidth(this), s.height);
        }

        //Cache numRows, since cells.rows() is expensive
        int numRows = cells.rows();

        if (sbVShow)
        {
            int vis = getNumVisibleRows();

            verticalScrollbar.reshape(s.width - verticalScrollbarWidth,0,verticalScrollbarWidth,s.height - scrollbarHeight);
            verticalScrollbar.setValues(sbVPosition, vis, 0, numRows - (isSun1_1 ? 0 : vis));
            verticalScrollbar.setPageIncrement(vis-1);
            verticalScrollbar.show();
        }
        else
        {
            topRow = 0;
            verticalScrollbar.hide();
        }

        if (sbHShow)
        {
            horizontalScrollbar.reshape(0,s.height-scrollbarHeight,s.width-verticalScrollbarWidth,scrollbarHeight);
            horizontalScrollbar.setValues(sbHPosition, s.width-verticalScrollbarWidth, 0, lastSplitter-(isSun1_1?0:(s.width-verticalScrollbarWidth)));
            horizontalScrollbar.setPageIncrement(s.width-verticalScrollbarWidth);
            horizontalScrollbar.setLineIncrement(hScrollbarLineIncrement);
            horizontalScrollbar.show();
        }
        else
        {
            horizontalScrollbar.hide();
        }

        if (offscreenImageGraphics != null)
        {
            if (headings.length > 0)
            {
                drawHeading(false);

                if (lastSplitter > 0)
                    offscreenImageGraphics.clipRect(0,0,lastSplitter,s.height);

                int count = cellHeight > 0 ? getNumVisibleRows() : 0;
                if (count > numRows)
                    count = numRows;

                offscreenImageGraphics.setFont(cellFont);
                drawRows(topRow, count, false);
            }
        }
    }

    /**
     * This routine changes the selected row, handling multiple selections
     * as needed.
     * @param newSelection the zero-relative index of the newly selected row
     * @param meta the state of the modifier keys from Event.modifiers
     * @see setSelectedRow
     * @see Event#CTRL_MASK
     * @see Event#SHIFT_MASK
     */
    public void changeSelection(int newSelection, int meta)
    {
        //Supress redraws
        boolean wasSuppressingRedraw = setSupressRedraw(true);

        try
        {
            int numberOfRows = getNumberOfRows();

            if (!((newSelection < numberOfRows) && (newSelection > -1)))
            {
                int[] selRows = getSelectedRows();
                if (multiSelect)
                {
                    if (((meta & Event.SHIFT_MASK) == Event.SHIFT_MASK) || ((meta & Event.CTRL_MASK) == Event.CTRL_MASK))
                        return;
                    deselectEvent(newSelection, selRows);
                }
                highlightedRows = new BitSet();
                paintSelection(selRows);
                repaint();
                return;
            }

            if (multiSelect)
                multiSel(newSelection, meta);
            else
                singleSel(newSelection, meta);

            // scroll a page UPWARD
            if (newSelection < topRow)
            {
                topRow = newSelection;

                if (topRow < 0)
                    topRow = 0;

                sbVPosition = topRow;
                verticalScrollbar.setValue(sbVPosition);

                triggerRedraw();
            }

            // scroll a page DOWNWARD
            if ((newSelection-topRow+1) > getNumVisibleRows())
            {
                topRow = newSelection;
                if ( topRow > numberOfRows - getNumVisibleRows() )
                    topRow -= (topRow - (numberOfRows - getNumVisibleRows()));

                sbVPosition = topRow;
                verticalScrollbar.setValue(sbVPosition);

                triggerRedraw();
            }

            selectedRow = newSelection;
            drawRows(selectedRow, 1, true);
        }
        finally
        {
            triggerRedraw();
            setSupressRedraw(wasSuppressingRedraw);
        }
    }

    /**
     * Tells this component that it has been added to a container.
     * This is a standard Java AWT method which gets called by the AWT when
     * this component is added to a container. Typically, it is used to
     * create this component's peer.
     *
     * It has been overridden here to add local event listeners.
     *
     * @see #removeNotify
     */
    public synchronized void addNotify()
    {
        super.addNotify();
        errors = ResourceBundle.getBundle("symantec.itools.resources.ErrorsBundle");

        //Hook up listeners
        if (mouse == null)
        {
            mouse = new Mouse();
            addMouseListener(mouse);
        }
        if (mouseMotion == null)
        {
            mouseMotion = new MouseMotion();
            addMouseMotionListener(mouseMotion);
        }
        if (key == null)
        {
            key = new Key();
            addKeyListener(key);
        }
        if (adjustment == null)
        {
            adjustment = new Adjustment();
            verticalScrollbar.addAdjustmentListener(adjustment);
            horizontalScrollbar.addAdjustmentListener(adjustment);
        }
        if (focus == null)
        {
            focus = new Focus();
            addFocusListener(focus);
        }
    }

    /**
     * Tells this component that it is being removed from a container.
     * This is a standard Java AWT method which gets called by the AWT when
     * this component is removed from a container. Typically, it is used to
     * destroy the peers of this component and all its subcomponents.
     *
     * It has been overridden here to remove local event listeners.
     *
     * @see #addNotify
     */
    public synchronized void removeNotify()
    {
        if (mouse != null)
        {
            removeMouseListener(mouse);
            mouse = null;
        }
        if (mouseMotion != null)
        {
            removeMouseMotionListener(mouseMotion);
            mouseMotion = null;
        }
        if (key != null)
        {
            removeKeyListener(key);
            key = null;
        }
        if (adjustment != null)
        {
            verticalScrollbar.removeAdjustmentListener(adjustment);
            horizontalScrollbar.removeAdjustmentListener(adjustment);
            adjustment = null;
        }
        if (focus != null)
        {
            removeFocusListener(focus);
            focus = null;
        }

        super.removeNotify();
    }

    private void multiSel(int newSelection, int meta)
    {
            if ((meta & Event.CTRL_MASK) == Event.CTRL_MASK)
            {
                if (highlightedRows.get(newSelection))
                    deselectRow(newSelection);
                else
                {
                    removeSelectionBorder();
                    selectRow(newSelection);
                }
            }
            else if ((meta & Event.SHIFT_MASK) == Event.SHIFT_MASK)
            {
                if (selectedRow == -1)
                    selectedRow = newSelection;

                for (int i=Math.min(selectedRow, newSelection);
                     i<=Math.max(selectedRow, newSelection);
                     i++)
                {
                    if (i>=0)
                    {
                        highlightedRows.set(i);
                    }
                }
                sourceItemEvent(ItemEvent.SELECTED);
                selectedRow = -1;
                paintSelection(getSelectedRows());
            }
            else
            {
                int[] selRows = getSelectedRows();
                deselectEvent(newSelection, selRows);
                highlightedRows = new BitSet();
                removeSelectionBorder();
                selectedRow = -1;
                paintSelection(selRows);
                selectRow(newSelection);
            }
    }

    private void singleSel(int newSelection, int meta)
    {
        if (selectedRow >= 0 && highlightedRows.get(selectedRow))
        {
            if (selectedRow != newSelection)
            {
                deselectRow(selectedRow);
                selectRow(newSelection);
            }
            else if ((meta & Event.CTRL_MASK) == Event.CTRL_MASK)
            {
                deselectRow(selectedRow);
            }
        }
        else
        {
            removeSelectionBorder();
            selectRow(newSelection);
        }
    }

    private void deselectEvent(int newSelection, int[] selRows)
    {
        int numberSelected = selRows.length;

        if ((numberSelected>1) ||
            ((numberSelected==1) &&
             (selectedRow!=newSelection)))
        {
            sourceItemEvent(ItemEvent.DESELECTED);
        }
    }

    /**
     * Paints the specified rows as selected.
     * @param selRows an array of the zero-relative indexes of selected rows
     */
    protected void paintSelection(int[] selRows)
    {
        for (int i = 0; i < selRows.length ;i++)
        {
            int selectedRow = selRows[i];
            if (selectedRow - sbVPosition >= 0 && selectedRow - sbVPosition <= getNumVisibleRows()+1)
                drawRows(selectedRow, 1, true);
        }
    }

    /**
     * Selects the row, if it is not already selected.
     * @param row the zero-relative row index
     * @see #deselectRow
     */
    public void selectRow(int row)
    {
        if (!highlightedRows.get(row))
        {
            //If in single select mode, deselect previously selected row
            if (!multiSelect)
            {
                int selectedRow = getSelectedRow();
                if (selectedRow != -1 && selectedRow != row)
                    deselectRow(selectedRow);
            }

            highlightedRows.set(row);
            sourceItemEvent(ItemEvent.SELECTED);

            drawRows(row, 1, true);
        }
    }

    /**
     * Deselects the row, if it is not already selected.
     * @param row the zero-relative row index
     * @see #selectRow
     */
    public void deselectRow(int row)
    {
        //If the row is hilited, unhilite it
        if (highlightedRows.get(row))
        {
            highlightedRows.clear(row);
            sourceItemEvent(ItemEvent.DESELECTED);

            //If the row has the selection border, remove it
            if (row == selectedRow)
                removeSelectionBorder();
            else
                drawRows(row, 1, true);
        }
    }

    /**
     * If there is a selected row, it removes the selection border from it.
     */
    protected void removeSelectionBorder()
    {
        if (selectedRow != -1)
        {
            int saveSelectedRow = selectedRow;
            selectedRow = -1;
            drawRows(saveSelectedRow, 1, true);
            selectedRow = saveSelectedRow;
        }
    }

    /**
     * Returns the recommended dimensions to properly display this component.
     * This is a standard Java AWT method which gets called to determine
     * the recommended size of this component.
     *
     * @see #minimumSize
     */
    //???RKM??? Seems wrong - hard coded
    public synchronized Dimension preferredSize()
    {
        return new Dimension(175, 125);
    }

    /**
     * Returns the minimum dimensions to properly display this component.
     * This is a standard Java AWT method which gets called to determine
     * the minimum size of this component.
     *
     * @see #preferredSize
     */
    //???RKM??? Seems wrong - hard coded
    public synchronized Dimension minimumSize()
    {
        return new Dimension(50, 50);
    }

    /**
     * Adds the specified action listener to receive action events
     * from this object.
     * @param l the action listener
     * @see #removeActionListener
     */
    public synchronized void addActionListener(ActionListener l)
    {
        actionListener = AWTEventMulticaster.add(actionListener, l);
    }

    /**
     * Removes the specified action listener so it no longer receives
     * action events from this object.
     * @param l the action listener
     * @see #addActionListener
     */
    public synchronized void removeActionListener(ActionListener l)
    {
        actionListener = AWTEventMulticaster.remove(actionListener, l);
    }

    /**
     * Adds the specified item listener to receive item events from this object.
     * @param l the item listener
     * @see #removeItemListener
     * @see #sourceItemEvent
     */
    public synchronized void addItemListener(ItemListener l)
    {
        itemListener = AWTEventMulticaster.add(itemListener, l);
    }

    /**
     * Removes the specified item listener so it no longer receives
     * item events from this object.
     * @param l the action listener
     * @see #addItemListener
     * @see #sourceItemEvent
     */
    public synchronized void removeItemListener(ItemListener l)
    {
        itemListener = AWTEventMulticaster.remove(itemListener, l);
    }

    /**
     * This is the Mouse Event handling innerclass.
     */
    class Mouse extends java.awt.event.MouseAdapter implements java.io.Serializable
    {
        /**
         * Handles Mouse Pressed events
         * @param e the MouseEvent
         */
        public void mousePressed(MouseEvent e)
        {
            int x = e.getX();
            int y = e.getY();

            requestFocus();

            //Reset column click code
            clickedInHeadings = false;

            //Is the click in the header
            if (y < headingHeight)
            {
                if (allowResizingOfColumns)
                {
                    // It's a click on the heading area:
                    // is it close enough to be a column size drag?
                    for (int i = 1;i< splitters.length - 1;i++)
                    {
                        int currSplitter = splitters[i];
                        if ((x < Math.min(currSplitter - sbHPosition + RESIZE_FUDGE_FACTOR, size().width - verticalScrollbarWidth)) &&
                            (x > currSplitter - sbHPosition - RESIZE_FUDGE_FACTOR))
                        {
                            dragColumn = i;
                            isDragging = true;
                            offscreenImageGraphics.setClip(0, 0, Math.max(splitters[splitters.length-1], size().width+sbHPosition), size().height);
                            mouseMotion.mouseDragged(e); //draw drag line immediately
                            return;
                        }
                    }
                }

                if (allowSorting)
                {
                    // check for sort button push
                    for (int i = 0; i < headings.length; i++)
                    {
                        //int max = i == headings.length - 1 ? size().width : splitters[i+1]-sbHPosition;

                        if ((x > splitters[i] - sbHPosition) && (x < splitters[i+1] - sbHPosition))
                        {
                           clickedInHeadings = true;
                           columnClicked = i;
                           drawHeading(true);
                           repaint();
                           return;
                        }
                    }
                }

                return;
            }

            //Check if the user is clicking in the corner box
            {
                Dimension size = getSize();
                if (x >= size.width - verticalScrollbarWidth || y >= size.height - scrollbarHeight)
                    return;
            }

            //Calc row clicked in
            int clickedInRow = ((int) (y - headingHeight) / cellHeight) + topRow;

            //Range check the row that was clicked in
            if (clickedInRow < 0 || clickedInRow > cells.rows() - 1)
                return;

            //Save off the old selection
            int oldRowSelect = selectedRow;

            // set new row selection
            changeSelection(clickedInRow, e.getModifiers());

            // detect a double click
            long when = e.getWhen();
            if ((selectedRow == oldRowSelect) || (oldRowSelect < 0))
            {
                // if clicked on same row track time elapsed since last mouseDown
                long clickSpeed = when - clickTime;

                if (clickSpeed < CLICKTHRESHOLD)
                    sourceActionEvent(selectedRow);
            }

            clickTime = when;
        }

        /**
         * Handles Mouse Released events
         * @param e the MouseEvent
         */
        public void mouseReleased(MouseEvent e)
        {
            int x = e.getX();

            if (isDragging)
            {
                //fix any drag that went off the left side
                if (x < 0)
                    x = 0;

                //Adjust splitters to delta
                boolean splittersChanged = false;
                {
                    xDragLast = Math.max(splitters[dragColumn - 1] + minColumnWidth,x + sbHPosition);

                    int splitterDelta = xDragLast - splitters[dragColumn];

                    for (int i = dragColumn + 1;i < splitters.length;i++)
                    {
                        int splitterWas = splitters[i];
                        splitters[i] += splitterDelta;
                        if (splitterWas != splitters[i])
                            splittersChanged = true;
                    }

                    if (splitters[dragColumn] != xDragLast)
                    {
                        splitters[dragColumn] = xDragLast;
                        splittersChanged = true;
                    }
                }

                //Stop dragging
                xDragLast = -1;
                isDragging = false;

                //???RKM??? Cursor should not be assumed as default
                if (e.getY() > headingHeight)
                    setCursor(new Cursor(Cursor.DEFAULT_CURSOR));

                //If the columnSizes were being calculated, switch to set column sizes
                if (splittersChanged && columnSizes == null)
                {
                    //Switch the column sizes - done this way so they could be vetoed
                    try
                    {
                        setColumnSizes(intArrayToStringArray(getColumnSizesFromSplitters()));
                    }
                    catch(PropertyVetoException veto)
                    {
                    }
                }

                triggerRedraw();

                return;
            }

            if (columnClicked != -1)
            {
                // Find sort for that column
                CompareCells compareCellsFunc = getColumnSorter(columnClicked);

                // it was a sorting request
                compareCellsFunc.setCurrentBitSet(highlightedRows);
                compareCellsFunc.setSelectedRow(selectedRow);

                if (columnClicked == lastColumnClicked)
                    compareCellsFunc.reverse();
                cells.sort(compareCellsFunc, columnClicked);

                selectedRow = compareCellsFunc.getSelectedRow();

                //Rember the last column click, so we can detect when to swap the sort order
                lastColumnClicked = columnClicked;

                columnClicked = -1;

                triggerRedraw();
            }
        }

        public void mouseExited(MouseEvent e)
        {
            if ((getCursor().getType() != Cursor.DEFAULT_CURSOR) && (!isDragging))
                setCursor(new Cursor(Cursor.DEFAULT_CURSOR));
        }
    }

    /**
     * This is the MouseMotion Event handling innerclass.
     */
    class MouseMotion implements java.awt.event.MouseMotionListener, java.io.Serializable
    {
        /**
         * Handles Mouse Moved events
         * @param e the MouseEvent
         */
        public void mouseMoved(MouseEvent e)
        {
            if (allowResizingOfColumns)
            {
                boolean isCloseEnough = false;

                // Use resize cursor ?
                if (e.getY() < headingHeight)
                {
                    int x = e.getX();

                    // Moving mouse around in header area
                    // is it close enough to be a column size drag?
                    for (int i = 1;i < splitters.length - 1;i++)
                    {
                        int currSplitter = splitters[i];
                        if ((x < Math.min(currSplitter - sbHPosition + RESIZE_FUDGE_FACTOR, size().width - verticalScrollbarWidth)) &&
                            (x > currSplitter - sbHPosition - RESIZE_FUDGE_FACTOR))
                        {
                            isCloseEnough = true;
                            break;
                        }
                    }
                }

                int newCursor = (isCloseEnough ? Cursor.W_RESIZE_CURSOR : Cursor.DEFAULT_CURSOR);

                if (newCursor != getCursor().getType())
                    setCursor(new Cursor(newCursor));
            }
        }

        /**
         * Handles Mouse Dragged events
         * @param e the MouseEvent
         */
        public void mouseDragged(MouseEvent e)
        {
            int x = e.getX();
            int y = e.getY();
            Dimension s = size();

            if (!isDragging)
            {
                if (clickedInHeadings)
                {
                    // check for sort button push outside of button
                    int max;
                    int min;

                    if (columnClicked > -1)
                    {
                        if (columnClicked == 0)
                            min = 0;
                        else
                            min = splitters[columnClicked]-sbHPosition;

                        if (columnClicked == headings.length - 1)
                            max = s.width;
                        else
                            max = splitters[columnClicked+1]-sbHPosition;

                        if ((x < min) || (x > max) || (y > headingHeight) || (y < 0))
                        {
                            memoryClick = columnClicked;
                            columnClicked = -1;
                            drawHeading(false);
                            //???RKM??? Seems crazy to repaint entire component, just to redraw column heading rect
                            Graphics g = getGraphics();
                            paint(g);
                            //???RKM??? Get smarter about what is blit to the scene, this could be made nicer
                            //repaint();
                        }
                    }
                    else if (memoryClick > -1)
                    {
                        if (memoryClick == 0)
                            min = 0;
                        else
                            min = splitters[memoryClick]-sbHPosition;

                        if (memoryClick == headings.length - 1)
                            max = s.width;
                        else
                            max = splitters[memoryClick+1]-sbHPosition;

                        if ((x > min) && (x < max) && (y < headingHeight) && (y > 0))
                        {
                            columnClicked = memoryClick;
                            memoryClick = -1;
                            drawHeading(true);
                            //???RKM??? Seems crazy to repaint entire component, just to redraw column heading rect
                            Graphics g = getGraphics();
                            paint(g);
                            //???RKM??? Get smarter about what is blit to the scene, this could be made nicer
                            //repaint();
                        }
                    }
                }
            }
            else
            {
                //fix any drag that went off the left side
                if (x < 0)
                    x = 0;

                if (x + sbHPosition < splitters[dragColumn-1] + minColumnWidth)
                    return;

                //erase prvious drag line and draw in new position
                int x1 = Math.min(x, xDragLast-sbHPosition);
                int x2 = Math.max(x, xDragLast-sbHPosition);

                offscreenImageGraphics.setColor(colorBg);
                offscreenImageGraphics.setXORMode(Color.gray);
                offscreenImageGraphics.drawLine(xDragLast,0,xDragLast,s.height);
                offscreenImageGraphics.drawLine(x+sbHPosition, 0, x+sbHPosition, s.height);
                offscreenImageGraphics.setColor(getForeground());
                offscreenImageGraphics.setPaintMode();

                //save x position of drag line
                xDragLast = x + sbHPosition;
                repaint(x1, 0, x2-x1+1, size().height);
            }
        }
    }

    /**
     * This is the Key Event handling innerclass.
     */
    class Key extends java.awt.event.KeyAdapter implements java.io.Serializable
    {
        /**
         * Handles Key Pressed events
         * @param e the KeyEvent
         */
        public void keyPressed(KeyEvent e)
        {
            int modifiers = e.getModifiers();

            switch (e.getKeyCode())
            {
                case KeyEvent.VK_DOWN:
                    if (selectedRow < cells.rows() - 1)
                        changeSelection(selectedRow + 1, modifiers);
                    break;

                case KeyEvent.VK_PAGE_DOWN:
                    changeSelection(Math.min(selectedRow + getNumVisibleRows(), cells.rows()-1), modifiers);
                    break;

                case KeyEvent.VK_UP:
                    if (selectedRow > 0)
                        changeSelection(selectedRow - 1, modifiers);
                    break;

                case KeyEvent.VK_PAGE_UP:
                    changeSelection(Math.max(selectedRow - getNumVisibleRows(), 0), modifiers);
                    break;

                case KeyEvent.VK_RIGHT:
                {
                    int max = horizontalScrollbar.getMaximum()-(isSun1_1?size().width-verticalScrollbarWidth:0);
                    if (sbHShow && sbHPosition < max)
                    {
                        horizontalScrollbar.setValue(Math.min(sbHPosition += hScrollbarLineIncrement, max));
                        repaint();
                    }
                    break;
                }

                case KeyEvent.VK_LEFT:
                {
                    if (sbHPosition > 0)
                    {
                        horizontalScrollbar.setValue(Math.max(sbHPosition-=hScrollbarLineIncrement, 0));
                        repaint();
                    }
                    break;
                }

                case KeyEvent.VK_ENTER:
                    if (selectedRow > -1)
                    {
                        sourceActionEvent(selectedRow);
                    }
                    break;
            }
        }
    }


    /**
     * This is the Adjustment Event handling innerclass.
     */
    class Adjustment implements java.awt.event.AdjustmentListener, java.io.Serializable
    {
        /**
         * Handles Scrollbar events
         * @param e the AdjustmentEvent
         */
        public void adjustmentValueChanged(AdjustmentEvent e)
        {
            if (e.getSource() == verticalScrollbar)
            {
                if (topRow != verticalScrollbar.getValue())
                {
                    topRow = verticalScrollbar.getValue();
                    sbVPosition = topRow;

                    triggerRedraw();
                }
            }
            else if (e.getSource() == horizontalScrollbar)
            {
                if (sbHPosition != horizontalScrollbar.getValue())
                {
                    sbHPosition = horizontalScrollbar.getValue();

                    triggerRedraw();
                }
            }
        }
    }

    /**
     * Fires an item event to the listeners.
     * @param eventType value indicating the kind of state change, one of:
     * ItemEvent.SELECTED or ItemEvent.DESELECTED
     * @see java.awt.event.ItemEvent#SELECTED
     * @see java.awt.event.ItemEvent#DESELECTED
     * @see #addItemListener
     * @see #removeItemListener
     */
    protected void sourceItemEvent(int eventType)
    {
        if (itemListener != null)
            itemListener.itemStateChanged(new ItemEvent(this, ItemEvent.ITEM_STATE_CHANGED, this, eventType));
    }

    /**
     * Internal helper routine.
     * Repaints the user input focus, as needed.
     */
    protected void repaintFocus()
    {
        if (selectedRow != -1)
            drawRows(selectedRow, 1, true);
        paintSelection(getSelectedRows());
    }

    class Focus implements FocusListener, java.io.Serializable
    {
        public void focusGained(FocusEvent e)
        {
            hasFocus = true;
            repaintFocus();
        }

        public void focusLost(FocusEvent e)
        {
            hasFocus = false;
            repaintFocus();
        }
    }

    /**
     * Fires an action event to the listeners.
     * The action command sent is the value specified in <code>actionCommand</code> concatenated
     * with the selectedRow. By default the <code>actionCommand</code> is "RowSelected:", so a
     * typical action command sent might be "RowSelected:0".
     * @param selectedRow the zero-relative index of the row generating the event
     * @see #actionCommand
     */
    protected void sourceActionEvent(int selectedRow)
    {
        //Sending the selected row along with the command name, for convenience.
        if (actionListener != null)
            actionListener.actionPerformed(new ActionEvent(this, ActionEvent.ACTION_PERFORMED, actionCommand + selectedRow));
    }

    /**
     * Returns the number of visible rows that can fit in the MulitList.
     * Note: This could be more than the number of rows in the MultiList.
     */
    protected int getNumVisibleRows()
    {
        return ((int)((size().height - headingHeight - scrollbarHeight - BORDER - (headingHeight > 0 ? 0 : BORDER)) / cellHeight));
    }

    /**
     * Draws the specifed rows into an offscreen image.
     * @param cellRow the zero-relative index of the first row to draw
     * @param numRowsToDraw the number of rows to draw
     * @param toRepaint if true, calls the <code>repaint</code> method to update the screen
     */
    protected void drawRows(int cellRow,int numRowsToDraw,boolean toRepaint)
    {
        //Calc index of row in visible area (ie first row on screen is zero - could be row twenty)
        int visibleRowIndex = cellRow - sbVPosition;

        //Range check visibleRowIndex
        if (visibleRowIndex < 0 || visibleRowIndex > getNumVisibleRows() - 1)
            return;

        MatrixEnumeration e = cells.elements();
        Cell c = null;

        if (cellRow > 0)
            c  = (Cell)e.advanceTo(cellRow);

        //iterate the rows and paint each one
        while (e.hasMoreElements() || c != null)
        {
            int x = 1;

            //Calc if rowIsSelected, once, outside the loop
            boolean rowIsSelected = highlightedRows.get(cellRow);

            //Calc topOfCell, onc, outside of loop
            int topOfCell = headingHeight + (headingHeight > 0 ? 0 : BORDER) + (visibleRowIndex * cellHeight);

            //Iterate the cols of the current row
               int cols = headings.length;
            for (int i = 0;i < cols;i++)
            {
                int w = splitters[i+1] - splitters[i];

                if(offscreenImage != null)
                {
                    offscreenImageGraphics.setColor(rowIsSelected ? colorHBg : colorBg);
                    offscreenImageGraphics.fillRect(x, topOfCell, w + 4, cellHeight);
                    offscreenImageGraphics.setColor(rowIsSelected?colorHFg :colorFg);
                }

                if (c == null)
                    c = (Cell)e.nextElement();

                if (offscreenImage != null && (c != null) && (e.currRow() == cellRow) && (e.currCol() == i))
                {
                    c.drawCell(offscreenImageGraphics, getColumnAlignment(i), splitters[i]+3, topOfCell, w, cellHeight, cellAscent);
                    c = null;
                }

                if (c != null && e.currRow() < cellRow)
                    c = null;

                x = splitters[i+1]-3;
            }

            if (hasFocus & focusIndicatedVisually)
            {
                if (offscreenImage != null && cellRow == selectedRow)
                {
                    Rectangle r1 = offscreenImageGraphics.getClipRect();

                    if(r1 != null)
                    {
                        offscreenImageGraphics.setColor(colorBg);
                        offscreenImageGraphics.setXORMode(Color.gray);
                        offscreenImageGraphics.drawRect(1, topOfCell, r1.width-3, cellHeight-1);
                        offscreenImageGraphics.setPaintMode();
                    }
                }
            }

            if (offscreenImage != null && toRepaint)
            {
                Rectangle r1 = offscreenImageGraphics.getClipRect();

                if(r1 != null)
                {
                    repaint(0, topOfCell, r1.width, cellHeight);
                }
            }

            if (--numRowsToDraw == 0)
                break;

            cellRow++;

            visibleRowIndex++;
        }
    }

    /**
     * Adds a listener for all property change events.
     * @param listener the listener to add
     * @see #removePropertyChangeListener
     */
    public synchronized void addPropertyChangeListener(PropertyChangeListener listener)
    {
        changes.addPropertyChangeListener(listener);
    }

    /**
     * Removes a listener for all property change events.
     * @param listener the listener to remove
     * @see #addPropertyChangeListener
     */
    public synchronized void removePropertyChangeListener(PropertyChangeListener listener)
    {
        changes.removePropertyChangeListener(listener);
    }

    /**
     * Adds a listener for all vetoable property change events.
     * @param listener the listener to add
     * @see #removeVetoableChangeListener
     */
    public synchronized void addVetoableChangeListener(VetoableChangeListener listener)
    {
        vetos.addVetoableChangeListener(listener);
    }

    /**
     * Removes a listener for all vetoable property change events.
     * @param listener the listener to remove
     * @see #addVetoableChangeListener
     */
    public synchronized void removeVetoableChangeListener(VetoableChangeListener listener)
    {
        vetos.removeVetoableChangeListener(listener);
    }

    /**
     * Takes no action.
     * This is a standard Java AWT method which gets called to specify
     * which layout manager should be used to layout the components in
     * standard containers.
     *
     * Since layout managers CANNOT BE USED with this container the standard
     * setLayout has been OVERRIDDEN for this container and does nothing.
     *
     * @param l the layout manager to use to layout this container's components
     * (IGNORED)
     * @see java.awt.Container#getLayout
     **/
    public void setLayout(LayoutManager mgr) {
    }

    public boolean isFocusTraversable()
    {
        return true;
    }

    static Color thirtyThreePercentGray = new Color(0x212121);
    static Color sixtySixPercentGray = new Color(0x434343);

    /**
     * Draws the specified column heading into an offscreen image.
     * @param columnHeadingRect the heading bounds
     * @param isSelected true if the column heading is selected
     */
    protected void drawColumnHeading
            (Rectangle    columnHeadingRect,
             boolean    isSelected)
    {
        if (symantec.itools.lang.OS.isMacintosh())
        {
            //Frame the column heading
            offscreenImageGraphics.setColor(Color.black);
            offscreenImageGraphics.drawRect(columnHeadingRect.x, columnHeadingRect.y, columnHeadingRect.width - 1, columnHeadingRect.height - 1);

            //Draw the gray in it
            offscreenImageGraphics.setColor(isSelected ? Color.gray : headingBg);
            offscreenImageGraphics.fillRect
                (columnHeadingRect.x + 2,
                 columnHeadingRect.y + 2,
                 columnHeadingRect.width - 4,
                 columnHeadingRect.height - 4);

            if (isSelected)
                 offscreenImageGraphics.setColor(Color.black);

            //Draw dot in lower left hand corner
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + 1,
                 columnHeadingRect.y + columnHeadingRect.height - 2,
                 columnHeadingRect.x + 1,
                 columnHeadingRect.y + columnHeadingRect.height - 2);

            //Draw dot in upper right hand corner
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + columnHeadingRect.width - 2,
                 columnHeadingRect.y + 1,
                 columnHeadingRect.x + columnHeadingRect.width - 2,
                 columnHeadingRect.y + 1);

            //Draw white left side vertical line (upper hilight)
            offscreenImageGraphics.setColor(isSelected ? thirtyThreePercentGray: Color.white);
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + 1,
                 columnHeadingRect.y + 1,
                 columnHeadingRect.x + 1,
                 columnHeadingRect.y + columnHeadingRect.height - 3);

            //Draw white top side horrizontal line (upper hilight)
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + 2,
                 columnHeadingRect.y + 1,
                 columnHeadingRect.x + columnHeadingRect.width - 3,
                 columnHeadingRect.y + 1);

            //Draw shadow
            offscreenImageGraphics.setColor(isSelected ? sixtySixPercentGray: Color.gray);

            //Draw horizontal shadow
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + 2,
                 columnHeadingRect.y + columnHeadingRect.height - 2,
                 columnHeadingRect.x + columnHeadingRect.width - 2,
                 columnHeadingRect.y + columnHeadingRect.height - 2);

            //Draw vertical shadow
            offscreenImageGraphics.drawLine
                (columnHeadingRect.x + columnHeadingRect.width - 2,
                 columnHeadingRect.y + 2,
                 columnHeadingRect.x + columnHeadingRect.width - 2,
                 columnHeadingRect.y + columnHeadingRect.height - 2);
        }
        else
        {
            columnHeadingRect.x += 1;
            columnHeadingRect.y += 1;
            columnHeadingRect.width -= 2;
            columnHeadingRect.height -= 2;

            draw3DBox(columnHeadingRect, !isSelected);

            offscreenImageGraphics.setColor(headingBg);
            offscreenImageGraphics.fillRect(columnHeadingRect.x+1, columnHeadingRect.y+1, columnHeadingRect.width-1, columnHeadingRect.height-1);
        }
    }

    //???RKM??? Can't we call draw3DRect here???
    /**
     * Draws a rectangle with 3-dimensional effect into the offscreen image.
     * @param r the rectangle bounds
     * @param up true to draw as if raised, false to draw as if lowered
     */
    protected void draw3DBox(Rectangle r, boolean up)
    {
        int x0 = r.x;
        int y0 = r.y;
        int x1 = r.x + r.width;
        int y1 = r.y + r.height;

        offscreenImageGraphics.setColor(up?Color.black: Color.white);
        offscreenImageGraphics.drawLine(x1,   y0, x1,   y1); //right
        offscreenImageGraphics.drawLine(x1+1, y0, x1+1, y1); //right

        offscreenImageGraphics.drawLine(x0,y1,x1,y1);        //bottom
        offscreenImageGraphics.drawLine(x0,y1+1, x1, y1+1);  //bottom

        offscreenImageGraphics.setColor(up?Color.white:Color.gray);
        offscreenImageGraphics.drawLine(x0,y0,x1-2,y0);     //top
        offscreenImageGraphics.drawLine(x0,y0,x0,y1-1);     //left
    }

    /**
     * Calculates the height of the column headings and stores that in
     * headingHeight.
     */
    protected void calculateHeadingHeight()
    {
        FontMetrics fontMetrics = getFontMetrics(headingFont);
        headingHeight = fontMetrics.getHeight() + fontMetrics.getLeading() + 7;
    }

    /**
     * Draws all column headings into an offscreen image.
     * @param down true if mouse is down in heading
     */
    protected void drawHeading(boolean down)
    {
        //If we aren't drawing headings, get out of here
        if (!headingVisible)
            return;

        //If we have any headers
        if (headings.length > 0)
        {
            //Save font we entered this routine with
            Font saveFont = offscreenImageGraphics.getFont();

            //Set font to heading font and get font metric for it (we'll need it later)
            offscreenImageGraphics.setFont(headingFont);
            FontMetrics fontMetrics = offscreenImageGraphics.getFontMetrics();

            //Init currSplitter to 0th elem, avoid two array indexes per loop
            int currSplitter = splitters[0];

            //Loop though all of the headings
            for (int i = 0; i < headings.length; i++)
            {
                int nextSplitter = splitters[i+1];

                int currHeadingWidth = nextSplitter - currSplitter;

                //Draw column heading
                Rectangle columnHeaderRect =
                    new Rectangle(currSplitter,0,currHeadingWidth,headingHeight);

                boolean clickingInCurrColumn = (columnClicked == i) ? true : false;

                drawColumnHeading(columnHeaderRect, clickingInCurrColumn);

                String currHeading = headings[i];
                if (currHeading == null)
                    continue;

                offscreenImageGraphics.setColor(headingFg);

                int stringWidth = fontMetrics.stringWidth(currHeading);
                int w = currHeadingWidth - 3;
                int shift = down && clickingInCurrColumn ? 1 : 0;

                int stringBaseline = headingHeight - 6 + shift;

                //Save clip and clip to heading rect
                Shape saveClip = offscreenImageGraphics.getClip();
                offscreenImageGraphics.setClip(columnHeaderRect.x,columnHeaderRect.y,columnHeaderRect.width,columnHeaderRect.height);

                switch (getColumnAlignment(i))
                {
                    case MultiList.LEFT:
                    {
                        offscreenImageGraphics.drawString(currHeading, currSplitter+8+shift, stringBaseline);
                        break;
                    }

                    case MultiList.CENTER:
                    {
                        if (stringWidth > w)
                            offscreenImageGraphics.drawString(currHeading, currSplitter+8+shift, stringBaseline);
                        else
                            offscreenImageGraphics.drawString(currHeading, currSplitter + (w-stringWidth)/2+shift, stringBaseline);

                        break;
                    }

                    case MultiList.RIGHT:
                    {
                        if (stringWidth > w)
                            offscreenImageGraphics.drawString(currHeading, currSplitter+8+shift, stringBaseline);
                        else
                            offscreenImageGraphics.drawString(currHeading, currSplitter+w-stringWidth-6+shift, stringBaseline);

                        break;
                    }
                }//switch

                //Restore clip
                offscreenImageGraphics.setClip(saveClip);

                if (clickingInCurrColumn)
                    offscreenImageGraphics.drawLine(columnHeaderRect.x+1, headingHeight - 1, nextSplitter - 3,  headingHeight - 1);

                //Set currSplitter to nextSplitter (loop iterations - one array index per loop)
                currSplitter = nextSplitter - 1;
            }

            //Restore font
            offscreenImageGraphics.setFont(saveFont);
        }

        //If the column headers do not fill up the width, add column
        {
            Dimension dim = size();

            int lastSplitter = splitters[splitters.length - 1];

            if (lastSplitter < sbHPosition + dim.width - verticalScrollbarWidth)
            {
                Rectangle fillerHeaderRect =
                    new Rectangle(lastSplitter - 1,0,sbHPosition + dim.width - verticalScrollbarWidth - lastSplitter + 1, headingHeight);
                drawColumnHeading(fillerHeaderRect, false);
            }
        }
    }

    /**
     * Converts the given array of int into a corresponding array of String.
     * @param intArray the array of ints
     * @return an array of String
     */
    protected String[] intArrayToStringArray(int[] intArray)
    {
        if (intArray == null)
            return null;

        String[] list = new String[intArray.length];

        for (int i = 0;i < intArray.length;i++)
        {
            String intString = "";
            try
            {
                intString = String.valueOf(intArray[i]);
            }
            catch (Exception e)
            {
            }
            list[i] = intString;
        }

        return list;
    }

    /**
     * Returns an array of column sizes as determined from the current splitter information.
     */
    protected int[] getColumnSizesFromSplitters()
    {
        int[] splitterColumnSizes = new int[headings.length];

        for (int i = 0;i < headings.length;i++)
            splitterColumnSizes[i] = splitters[i + 1] - splitters[i];

        return splitterColumnSizes;
    }

    /**
     * Triggers an entire redraw of this component, unless redrawing is
     * currently suppressed.
     * @see #setSupressRedraw
     */
    protected void triggerRedraw()
    {
        //If we're not suppressing redraws
        if (!isSuppressRedraw)
        {
            //Set forceRedraw so contents of offscreen is updated
            forceRedraw = true;
            repaint();
        }
        else redrawWasSupressed = true;
    }

    /**
     * Handles cases where the user might pass either an array of items,
     * or a single string with itemds separated by the ';' character.
     * This may occur in the <code>setHeadings</code>,
     * <code>setColumnAlignments</code>, or <code>setColumnSizes</code>
     * methods.
     * @param list the input list
     * @param an array of items, one per String
     * @see #setHeadings
     * @see #setColumnAlignments
     * @see #setColumnSizes
     */
    protected String[] tokenizeStringArrayIfNeeded(String[] list)
    {
        if (list != null)
        {
            //Handle case where user thinks ; separates entries
            if (list.length == 1 && list[0].indexOf(";") != -1)
            {
                //Convert the first element into an array of strings
                java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(list[0],";");

                int numColumns = tokenizer.countTokens();

                String[] convertedList = new String[numColumns];

                int currCol = 0;
                while (tokenizer.hasMoreTokens())
                {
                    String columnHeader = tokenizer.nextToken();

                    convertedList[currCol] = columnHeader;

                    currCol++;
                }

                list = convertedList;
            }
        }

        return list;
    }

    /**
     * Initializes new headings with the given list of heading titles.
     * @param list array of heading title strings
     */
    protected void calcHeadings(String[] list)
    {
        //    RKM    In order to reduce chance of a bug injection, I've allowed the calculation below to
        //        occur, even in the case where the result is bogus

        headings = new String[list.length];
        splitters = new int[list.length + 1];

        //???RKM??? So what do we do if columnAlignments is not the same width

        for (int i = 0; i < list.length; ++i)
        {
            try
            {
                setHeading(list[i], i);
            }
            catch (PropertyVetoException e){}
        }

        //If there were column sizes, reapply them now
        if (columnSizes != null)
        {
            try
            {
                setColumnSizes(intArrayToStringArray(columnSizes));
            }
            catch(PropertyVetoException veto)
            {
            }
        }
    }

    /**
     * The background color of cell text.
     * @see #getCellBg
     * @see #setCellBg
     */
    protected Color        colorBg = Color.white;
    /**
     * The foreground color of cell text.
     * @see #getCellFg
     * @see #setCellFg
     */
    protected Color        colorFg = Color.black;
    //???RKM??? Remove if when MRJ fixes it's bugs
    /**
     * The background color of hilighted cell text.
     * Automatically determined.
     */
    protected Color        colorHBg = symantec.itools.lang.OS.isMacintosh() ? new Color(0,0,128) : SystemColor.textHighlight;
    /**
     * The foreground color of hilighted cell text.
     * Automatically determined.
     */
    protected Color        colorHFg = symantec.itools.lang.OS.isMacintosh() ? Color.white : SystemColor.textHighlightText;
    /**
     * The background color of column heading text.
     * @see #getHeadingBg
     * @see #setHeadingBg
     */
    protected Color        headingBg = java.awt.SystemColor.control;
    /**
     * The foreground color of column heading text.
     * @see #getHeadingFg
     * @see #setHeadingFg
     */
    protected Color        headingFg = java.awt.SystemColor.controlText;
    /**
     * Allow sorting. Default is true.
     */
    protected boolean        allowSorting = true;
    /**
     * Indicate focus when drawing. Default is true.
     */
    protected boolean        focusIndicatedVisually = true;
    /**
     * Allow multiple selections. Default is false.
     */
    protected boolean        multiSelect = false;
    /**
     * Allow columns to be resized. Default is true.
     */
    protected boolean        allowResizingOfColumns = true;
    /* *
     * Checks for scrollbars that have different max value Members used to
     * calculate headings, when size of component is not known (pre add).
     */

    /**
     * The heading titles.
     * @see #getHeadings
     * @see #setHeadings
     * @see #getHeading
     * @see #setHeading
     */
    protected String        headings[];
    /**
     * Is the heading visible. Default is true.
     */
    protected boolean        headingVisible = true;
    /**
     * The heading height in pixels.
     * If the heading is showing, it includes one pixel for the border (they overlap).
     */
    protected int            headingHeight = 0;
    /**
     * The font used to draw heading text.
     * @see #getHeadingFont
     * @see #setHeadingFont
     */
    protected Font            headingFont;

    /**
     * The location of the boundries between columns, in pixels.
     */
    protected int            splitters[];

    /**
     * The column alignments.
     * Values are one of: LEFT, CENTER, or RIGHT.
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     * @see #setColumnAlignments
     */
    protected int            columnAlignments[];
    /**
     * The column alignment to use by default.
     * The initial value is LEFT.
     * @see #LEFT
     * @see #CENTER
     * @see #RIGHT
     * @see #getDefaultColumnAlignment
     * @see #setDefaultColumnAlignment
     */
    protected int            defaultColumnAlignment = LEFT;

    /**
     * If non-null, the the width of each column in pixels.
     * If null, the columns are automatically sized.
     * @see #getColumnSizes
     * @see #setColumnSizes
     */
    protected int            columnSizes[] = null;

    /**
     * If sorting is allowed, the column clicked in.
     * @see #isAllowSorting
     * @see #setAllowSorting
     */
    protected int            columnClicked = -1;
    /**
     * If sorting is allowed, the column previously clicked in.
     * @see #isAllowSorting
     * @see #setAllowSorting
     */
    protected int            lastColumnClicked = -1;
    /**
     * Temp storage for columnClicked when repainting during a mouse drag.
     */
    protected int            memoryClick = -1;

    //???RKM??? What if multiSelect is true ???
    /**
     * The most recently selected row.
     */
    protected int            selectedRow = -1;
    /**
     * Flags indicating which rows are currently selected.
     */
    protected BitSet        highlightedRows = new BitSet();

    /**
     * The cells.
     */
    protected Matrix        cells = new Matrix();
    /**
     * The font used to display cell text.
     * @see #getCellFont
     * @see #setCellFont
     */
    protected Font            cellFont;
    /**
     * The height of cells, in pixels.
     */
    protected int            cellHeight = 0;
    /**
     * The ascent metric of the cell font.
     */
    protected int            cellAscent = 0;
    /**
     * The descent metric of the cell font.
     */
    protected int            cellDescent = 0;

    /**
     * The zero-relative index of the first visible row in the list.
     */
    protected int            topRow;

    /**
     * The latest vertical size of this component.
     */
    protected int            cachedHeight = -1;
    /**
     * The latest horizontal size of this component.
     */
    protected int            cachedWidth = -1;
    /**
     * The latest overall row width.
     */
    protected int            cachedLastSplitter = -1;

    /**
     * The zero-relative index of the column being resized via the UI.
     */
    protected int            dragColumn = -1;
    /**
     * The latest horizontal position the the splitter being dragged to resize a column.
     */
    protected int            xDragLast = -1;
    /**
     * The vertical scrollbar value.
     */
    protected int            sbVPosition = 0;
    /**
     * The horizontal scrollbar value.
     */
    protected int            sbHPosition = 0;
    /**
     * The width of the vertical scrollbar. 0 if it is not displayed.
     */
    protected int            verticalScrollbarWidth = 0;
    /**
     * The height of the horizontal scrollbar. 0 if it is not displayed.
     */
    protected int            scrollbarHeight = 0;
    /**
     * The unit increment of the horizontal scrollbar.
     * The default value is 4.
     */
    protected int            hScrollbarLineIncrement = 4;
    /**
     * The minimum allowed column width, in pixels.
     */
    protected int            minColumnWidth = 10;
    /**
     * The time of the previous click.
     * Used to detect when a row is double-clicked.
     */
    transient protected long        clickTime = 0;
    /**
     * The first part of the action command.
     * It is sent when a row is double-clicked, or enter is pressed.
     * @see #sourceActionEvent
     */
    protected String        actionCommand = "RowSelected:";
    /**
     * The vertical scrollbar.
     * Always exists. Shown as needed.
     */
    protected Scrollbar    verticalScrollbar;
    /**
     * The horizontal scrollbar.
     * Always exists. Shown as needed.
     */
    protected Scrollbar    horizontalScrollbar;

    //Sorting variables
    /**
     * The default cell comparer.
     * @see #getDefaultColumnSorter
     * @see #setDefaultColumnSorter
     */
    protected CompareCells defaultColumnSorter            = new CompareTextAndImageCells();
    /**
     * The cell compare routines to use for each column.
     * The routines are indexed using an Integer of the column index.
     * @see #getColumnSorter
     * @see #setColumnSorter
     */
    protected Hashtable columnCompareCellsRoutines        = new Hashtable();

    //Event sourcers
    /**
     * The action listener to keep track of listeners for our action event.
     */
    protected ActionListener    actionListener    = null;
    /**
     * The action listener to keep track of listeners for our item event.
     */
    protected ItemListener        itemListener    = null;
    /**
     * The action listener to keep track of listeners for our focus event.
     */
    protected FocusListener    focusListener    = null;

    //Event listeners
    private Mouse                mouse        = null;
    private MouseMotion        mouseMotion    = null;
    private Key                key            = null;
    private Focus                focus        = null;
    private Adjustment            adjustment    = null;

    private VetoableChangeSupport vetos    = new VetoableChangeSupport(this);
    private PropertyChangeSupport changes    = new PropertyChangeSupport(this);

    /**
     * Column splitter is being dragged to resize a column.
     */
    transient protected boolean        isDragging = false;
    /**
     * Mouse button has been pressed in a column heading.
     */
    transient protected boolean        clickedInHeadings = false;
    /**
     * Vertical scrollbar is visible.
     */
    transient protected boolean        sbVShow = false;
    /**
     * Horizontal scrollbar is visible.
     */
    transient protected boolean        sbHShow = false;
    /**
     * True if next paint will redraw the entire component even if
     * its size has not changed.
     */
    transient protected boolean        forceRedraw = false;
    /**
     * Column sizes need to be recalculated.
     */
    transient protected boolean        forceColumnSizeRecalc = false;
    /**
     * Offscreen image needs to be flushed.
     */
    transient protected boolean        forceFullRedraw = false;
    /**
     * Redrawing of component is currently suppressed.
     * @see #setSupressRedraw
     */
    transient protected boolean        isSuppressRedraw = false;
    /**
     * Redraw would have occurred if it hadn't been suppressed.
     */
    transient protected boolean        redrawWasSupressed = false;
    /**
     * This component has the focus.
     */
    transient protected boolean        hasFocus = false;

    //
    //Offscreen image graphics
    //

    /**
     * The offscreen image. Used to draw the component before painting it to the screen.
     */
    transient protected Image offscreenImage = null;
    /**
     * The graphics context used to draw into the offscreen image.
     */
    transient protected Graphics offscreenImageGraphics = null;

    /**
     * Error strings.
     */
    transient protected ResourceBundle errors;

    /**
     * True if running under Java 1.1.
     */
    static protected boolean isSun1_1;

    static
    {
        //Calc it once
        String vendor  = System.getProperty("java.vendor" );
        String version = System.getProperty("java.version");
        isSun1_1 = ((vendor.startsWith("Sun Microsystems Inc.") ||
                    (vendor.startsWith("Apple"))                ||
                    (vendor.startsWith("Symantec Corporation"))  ||
                    (vendor.startsWith("Microsoft Corp.")) ||
                    (vendor.startsWith("Netscape"))) &&
                   ((version.startsWith("11"))
                    || (version.startsWith("1.1"))));
    }
}


class DeprecatedException
    extends RuntimeException
{
    DeprecatedException(String msg)
    {
        super(msg);
    }
}