package omaTable;

import java.applet.Applet;
import java.applet.AppletContext;
import java.awt.*;
import java.awt.event.*;
import java.io.PrintStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.text.NumberFormat;
import java.util.*;

// Referenced classes of package com.objectplanet.gui:
//            TableEvent, TableData, TableListener

public class Table extends Applet
    implements Runnable
{

    public static final int SORT_ASCENDING = 0;
    public static final int SORT_DESCENDING = 1;
    public static final int COLUMN_TEXT = 0;
    public static final int COLUMN_NUMBER = 1;
    public static final int COLUMN_CURRENCY = 2;
    public static final int ALIGN_LEFT = 0;
    public static final int ALIGN_CENTER = 1;
    public static final int ALIGN_RIGHT = 2;
    public static final int SELECT_NONE = 0;
    public static final int SELECT_SINGLE = 1;
    public static final int SELECT_MULTIPLE = 2;
    private TableData tableData;
    private int sortedList[];
    private int displayList[];
    private String columnFilter[];
    private boolean filterPushed[];
    private String headerLabels[];
    private Vector listeners;
    private double columnWidth[];
    private int columnAlignment[];
    private int columnType[];
    private boolean columnOn[];
    private boolean selectedRows[];
    private Color rowForeground[];
    private Color rowBackground[];
    private Color defaultRowForeground;
    private Color defaultRowBackground;
    private boolean automaticRepaintOn;
    private boolean headerOn;
    private boolean filterBarOn;
    private boolean progressiveFilterOn;
    private int selectionMode;
    private String columnPrefix[];
    private String columnPostfix[];
    private boolean totalRowOn[];
    private int decimalCount[];
    private boolean sortingOn[];
    private String filterWildCard;
    private Hashtable urlList;
    private Hashtable urlTargetList;
    private Color urlColor;
    private boolean gridOn;
    private Color gridColor;
    private String fieldSeparator;
    private boolean columnStretchOn;
    private Dimension preferredSize;
    private int displayRowCount;
    private int columnXpos[];
    private boolean headerPushed[];
    private int visibleColumnCount;
    private int selectedHeader;
    private boolean adjusting;
    private double lastClickedPos;
    private int currentSeperator;
    private int currentEditField;
    private boolean cursorOn;
    private Thread thread;
    private int threadType;
    private Image offscreen;
    private int firstRow;
    private int offset;
    private int lastSelectedRow;
    private int lastSelectedCell;
    private int clickedRow;
    private int clickedCell;
    private long lastSelectedTime;
    private int lastSortedColumn;
    private boolean isFlipped;
    private long lastPaintTime;
    private double columnTotal[];
    private int rowBottom;
    private AppletContext applet;
    private boolean vScrollbarOn;
    private boolean upButtonPushed;
    private boolean downButtonPushed;
    private boolean aboveSliderPushed;
    private boolean belowSliderPushed;
    private int vScrollerTop;
    private int vSliderSpace;
    private int vSliderPos;
    private int vSliderSize;
    private int upButtonHeight;
    private int downButtonHeight;
    private boolean vSliderAdjusting;
    private int vSliderAdjustPos;
    private boolean hScrollbarOn;
    private boolean leftButtonPushed;
    private boolean rightButtonPushed;
    private boolean leftToSliderPushed;
    private boolean rightToSliderPushed;
    private int hSliderSpace;
    private int hSliderSize;
    private int hSliderPos;
    private boolean hSliderAdjusting;
    private int hSliderAdjustPos;
    private int maxDisplayRowCount;
    private int scrollByPageToY;
    private int scrollByPageToX;
    private static final int DOUBLE_CLICK_DELAY = 500;
    private static final int BORDER = 2;
    private static final int COLUMN_WIDTH = 100;
    private static final int LESS = -1;
    private static final int EQUAL = 0;
    private static final int LARGER = 1;
    private static final int SCROLLER = 15;
    private static final Cursor DEFAULT_CURSOR = new Cursor(0);
    private static final Cursor HAND_CURSOR = new Cursor(12);
    private static final Cursor RESIZE_CURSOR = new Cursor(11);
    private static final Cursor TEXT_CURSOR = new Cursor(2);
    private static final int THREAD_FILTER_BLINKER = 0;
    private static final int THREAD_SCROLL_LEFT_BUTTON = 1;
    private static final int THREAD_SCROLL_RIGHT_BUTTON = 2;
    private static final int THREAD_SCROLL_UP_BUTTON = 3;
    private static final int THREAD_SCROLL_DOWN_BUTTON = 4;
    private static final int THREAD_JUMP_LEFT_BUTTON = 5;
    private static final int THREAD_JUMP_RIGHT_BUTTON = 6;
    private static final int THREAD_JUMP_UP_BUTTON = 7;
    private static final int THREAD_JUMP_DOWN_BUTTON = 8;
    private static final int CONTINOUS_SCROLL_DELAY = 35;

    public Insets getInsets()
    {
        return new Insets(3, 3, 2, 2);
    }

    /**
     * @deprecated Method isTotalRowOn is deprecated
     */

    public boolean isTotalRowOn()
    {
        return isTotalRowOn(-1);
    }

    public boolean isTotalRowOn(int i)
    {
        boolean flag = false;
        if(i >= 0 && i < totalRowOn.length)
            return totalRowOn[i];
        if(i == -1)
        {
            for(int j = 0; j < totalRowOn.length; j++)
                if(totalRowOn[j])
                    flag = true;

        }
        return flag;
    }

    public static String getVersion()
    {
        return "1.2.4";
    }

    private void paint3DBox(Graphics g, int i, int j, int k, int l, boolean flag)
    {
        g.setColor(getBackground());
        g.fillRect(i, j, k, l);
        if(flag)
        {
            g.setColor(getBackground().darker());
            g.drawRect(i, j, k - 1, l - 1);
        } else
        {
            g.setColor(Color.white);
            g.drawLine(i + 1, j + 1, (i + k) - 2, j + 1);
            g.drawLine(i + 1, j + 1, i + 1, (j + l) - 2);
            g.setColor(Color.black);
            g.drawLine((i + k) - 1, j, (i + k) - 1, (j + l) - 1);
            g.drawLine(i, (j + l) - 1, (i + k) - 1, (j + l) - 1);
            g.setColor(getBackground().darker());
            g.drawLine((i + k) - 2, j + 1, (i + k) - 2, (j + l) - 2);
            g.drawLine(i + 1, (j + l) - 2, (i + k) - 2, (j + l) - 2);
        }
    }

    protected void autoRepaint()
    {
        if(automaticRepaintOn)
            repaint();
    }

    public boolean isRowSelected(int i)
    {
        if(i >= 0 && i < selectedRows.length)
            return selectedRows[i];
        else
            return false;
    }

    private static Color createColor(String s)
    {
        if(s == null || s.length() == 0)
            return null;
        s = s.trim().toLowerCase();
        if(s.indexOf(",") >= 0)
        {
            StringTokenizer stringtokenizer = new StringTokenizer(s, ", ");
            try
            {
                return new Color(Integer.parseInt(stringtokenizer.nextToken()), Integer.parseInt(stringtokenizer.nextToken()), Integer.parseInt(stringtokenizer.nextToken()));
            }
            catch(Exception _ex)
            {
                System.out.println("Invalid RGB color: " + s);
            }
        } else
        if(s.startsWith("#"))
        {
            try
            {
                return new Color(Integer.parseInt(s.substring(1, 3), 16), Integer.parseInt(s.substring(3, 5), 16), Integer.parseInt(s.substring(5, 7), 16));
            }
            catch(Exception _ex)
            {
                System.out.println("Invalid hex color: " + s);
            }
        } else
        {
            if(s.equals("black"))
                return Color.black;
            if(s.equals("blue"))
                return Color.blue;
            if(s.equals("cyan"))
                return Color.cyan;
            if(s.equals("darkgray"))
                return Color.darkGray;
            if(s.equals("gray"))
                return Color.gray;
            if(s.equals("green"))
                return Color.green;
            if(s.equals("lightgray"))
                return Color.lightGray;
            if(s.equals("magenta"))
                return Color.magenta;
            if(s.equals("orange"))
                return Color.orange;
            if(s.equals("pink"))
                return Color.pink;
            if(s.equals("red"))
                return Color.red;
            if(s.equals("white"))
                return Color.white;
            if(s.equals("yellow"))
                return Color.yellow;
            System.out.println("Invalid color name: " + s);
        }
        return null;
    }

    public void setGridColor(Color color)
    {
        gridColor = color;
        autoRepaint();
    }

    public Color getGridColor()
    {
        if(gridColor != null)
            return gridColor;
        else
            return getBackground();
    }

    public void gotoRow(int i)
    {
        int j = -1;
        for(int k = 0; k < displayRowCount; k++)
        {
            if(displayList[k] == i)
            {
                j = k;
                break;
            }
            j = displayRowCount - 1;
        }

        gotoRowPosition(j);
    }

    public synchronized void sortColumn(int i, int j)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        if(j != 0 && j != 1)
            throw new IllegalArgumentException("Invalid sort order");
        int k = getRowCount();
        qsort(sortedList, 0, k - 1, i);
        lastSortedColumn = i;
        if(j == 1)
        {
            for(int l = 0; l < k / 2; l++)
            {
                int i1 = sortedList[l];
                sortedList[l] = sortedList[k - 1 - l];
                sortedList[k - 1 - l] = i1;
            }

        }
        refilterTable();
        autoRepaint();
    }

    public boolean isProgressiveFilterOn()
    {
        return progressiveFilterOn;
    }

    public boolean isGridOn()
    {
        return gridOn;
    }

    private void paintTotalRow(Graphics g)
    {
        Dimension dimension = getSize();
        int i = getTotalRowHeight();
        int j = dimension.width - 4;
        j -= vScrollbarOn ? 15 : 0;
        int k = dimension.height - 2 - i;
        k -= filterBarOn ? getFilterHeight() : 0;
        k -= hScrollbarOn ? 15 : 0;
        g.setClip(0, 0, dimension.width, dimension.height);
        g.setColor(defaultRowBackground);
        g.fillRect(2, k, j, i);
        g.setColor(getBackground());
        g.drawLine(2, k + 1, columnXpos[columnXpos.length - 1] - 1, k + 1);
        for(int l = 0; l < columnXpos.length; l++)
        {
            int j1 = columnXpos[l] - 1 - offset;
            g.drawLine(j1, k + 1, j1, k + i + 1);
        }

        for(int i1 = 0; i1 < columnXpos.length; i1++)
            if(totalRowOn[i1])
            {
                NumberFormat numberformat = NumberFormat.getInstance(getLocale());
                if(columnType[i1] == 2)
                    numberformat = NumberFormat.getCurrencyInstance(getLocale());
                numberformat.setMaximumFractionDigits(decimalCount[i1]);
                numberformat.setMinimumFractionDigits(decimalCount[i1]);
                String s = null;
                if(columnType[i1] == 1 || columnType[i1] == 2)
                    s = numberformat.format(columnTotal[i1]);
                else
                    s = Math.round(columnTotal[i1]) + "";
                s = columnPrefix[i1] == null ? s : columnPrefix[i1] + s;
                s = columnPostfix[i1] == null ? s : s + columnPostfix[i1];
                g.setColor(defaultRowForeground);
                paintFieldLabel(g, s, k + 1, i1, false);
            }

    }

    private URL createURL(String s)
    {
        if(s == null)
            return null;
        URL url = null;
        try
        {
            url = new URL(s);
        }
        catch(MalformedURLException _ex)
        {
            URL url1 = getDocumentBase();
            if(url1 == null)
                return null;
            String s1 = url1.toExternalForm();
            int i = s1.lastIndexOf("?");
            if(i > -1)
                s1 = s1.substring(0, i);
            if(!s1.endsWith("/"))
                s1 = s1.substring(0, s1.lastIndexOf("/") + 1);
            if(s1.startsWith("file:/\\"))
                s1 = "file://" + s1.substring(8);
            try
            {
                url = new URL(s1 + s);
            }
            catch(MalformedURLException _ex2)
            {
                System.out.println("Invalid URL: " + s1);
            }
        }
        return url;
    }

    private void editFilterField(int i, boolean flag)
    {
        if(i >= 0 && i != currentEditField && flag)
        {
            currentEditField = i;
            cursorOn = true;
            if(thread == null)
            {
                threadType = 0;
                thread = new Thread(this);
                thread.start();
            }
        } else
        {
            currentEditField = -1;
            cursorOn = false;
            if(thread != null)
            {
                thread.stop();
                thread = null;
            }
        }
    }

    public int[] getSelectedRows()
    {
        int i = 0;
        int ai[] = new int[getRowCount()];
        for(int j = 0; j < ai.length; j++)
            if(selectedRows[j])
                ai[i++] = j;

        int ai1[] = new int[i];
        System.arraycopy(ai, 0, ai1, 0, ai1.length);
        return ai1;
    }

    private void paintRows(Graphics g)
    {
        if(g == null || displayRowCount < 1)
            return;
        g.setFont(getFont());
        FontMetrics fontmetrics = g.getFontMetrics();
        Dimension dimension = getSize();
        g.setClip(0, 0, dimension.width, dimension.height);
        int i = getHeaderHeight();
        int j = fontmetrics.getHeight() + 1;
        int k = i + 3;
        for(int l = firstRow; l < firstRow + maxDisplayRowCount + 1; l++)
        {
            if(l < displayRowCount && rowBackground[displayList[l]] != null)
            {
                g.setColor(rowBackground[displayList[l]]);
                g.fillRect(2, k, dimension.width - 4, j);
            }
            k += j;
        }

        g.setColor(SystemColor.textHighlight);
        k = i + 3;
        for(int i1 = firstRow; i1 < firstRow + maxDisplayRowCount + 1; i1++)
        {
            if(i1 < displayRowCount && selectedRows[displayList[i1]])
                g.fillRect(2, k, dimension.width - 4, j);
            k += j;
        }

        g.setColor(urlColor == null ? Color.blue : urlColor);
        k = i + 3;
        for(int j1 = firstRow; j1 < firstRow + maxDisplayRowCount + 1; j1++)
            if(j1 < displayRowCount)
            {
                String s = displayList[j1] + "";
                if(urlList.get(s) != null)
                    g.drawLine(6, (k + j) - 2, columnXpos[columnXpos.length - 1], (k + j) - 2);
                k += j;
            }

        int k1 = getColumnCount();
        for(int l1 = 0; l1 < k1; l1++)
            if(columnOn[l1])
            {
                NumberFormat numberformat = NumberFormat.getInstance(getLocale());
                if(columnType[l1] == 2)
                    numberformat = NumberFormat.getCurrencyInstance(getLocale());
                numberformat.setMaximumFractionDigits(decimalCount[l1]);
                numberformat.setMinimumFractionDigits(decimalCount[l1]);
                int i2 = l1 <= 0 ? 2 : columnXpos[l1 - 1];
                int k2 = l1 <= 0 ? columnXpos[0] - 2 - 1 : columnXpos[l1] - columnXpos[l1 - 1];
                if(visibleColumnCount > 1)
                    g.setClip(i2 - offset, 0, k2 - 1, dimension.height);
                k = i + j;
                int l2 = Math.min(displayRowCount, firstRow + maxDisplayRowCount + 1);
                for(int i3 = firstRow; i3 < l2; i3++)
                {
                    Object aobj[] = getRow(displayList[i3]);
                    if(aobj == null || l1 >= aobj.length)
                    {
                        k += j;
                    } else
                    {
                        String s1 = null;
                        if(aobj[l1] instanceof String)
                            s1 = (String)aobj[l1];
                        else
                            s1 = "";
                        if(columnType[l1] == 1 || columnType[l1] == 2)
                            try
                            {
                                Double double1 = new Double(s1);
                                s1 = numberformat.format(double1.doubleValue());
                            }
                            catch(NumberFormatException _ex) { }
                        if(columnPrefix[l1] != null)
                            s1 = columnPrefix[l1] + s1;
                        if(columnPostfix[l1] != null)
                            s1 += columnPostfix[l1];
                        int j2 = (l1 <= 0 ? 3 : columnXpos[l1 - 1]) - offset;
                        int j3 = fontmetrics.stringWidth(s1);
                        switch(columnAlignment[l1])
                        {
                        default:
                            break;

                        case 0: // '\0'
                            j2 = l1 <= 0 ? 6 : columnXpos[l1 - 1] + 3;
                            break;

                        case 2: // '\002'
                            if(visibleColumnCount == 1)
                                j2 = dimension.width - 2 - j3 - 2;
                            else
                                j2 = columnXpos[l1] - j3 - 2;
                            break;

                        case 1: // '\001'
                            int k3 = visibleColumnCount <= 1 ? dimension.width / 2 : j2 + k2 / 2;
                            j2 = Math.max(k3 - j3 / 2, j2 + 3);
                            break;
                        }
                        j2 = Math.max(l1 <= 0 ? 6 : columnXpos[l1 - 1] + 3, j2);
                        boolean flag = selectedRows[displayList[i3]];
                        if(selectionMode != 0 && flag && lastSelectedCell == l1)
                        {
                            g.setColor(SystemColor.textHighlight.brighter());
                            g.fillRect(j2 - offset - 1, (k - j) + 4, j3 + 2, j - 2);
                        }
                        if(flag)
                            g.setColor(SystemColor.textHighlightText);
                        else
                        if(isEnabled())
                            g.setColor(rowForeground[displayList[i3]] == null ? defaultRowForeground : rowForeground[displayList[i3]]);
                        else
                            g.setColor(Color.gray);
                        URL url = getURL(displayList[i3], l1);
                        if(url != null && !flag)
                            g.setColor(urlColor == null ? Color.blue : urlColor);
                        if(aobj[l1] instanceof String)
                            g.drawString(s1, j2 - offset, k);
                        if(url != null)
                            g.drawLine(j2 - offset, k + 1, (j2 - offset) + j3, k + 1);
                        k += j;
                    }
                }

            }

        rowBottom = (k - j) + 2;
    }

    public void destroy()
    {
        TableEvent.closeEvaluation();
        super.destroy();
    }

    public void setColumnType(int i, int j)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        switch(j)
        {
        case 0: // '\0'
        case 1: // '\001'
        case 2: // '\002'
            columnType[i] = j;
            break;

        default:
            throw new IllegalArgumentException("Invalid column type");
        }
    }

    public int getColumnType(int i)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        else
            return columnType[i];
    }

    public void setFilter(int i, String s)
    {
        if(i < 0 || i >= getColumnCount())
        {
            throw new IllegalArgumentException("Invalid column: " + i);
        } else
        {
            columnFilter[i] = s == null ? null : s.trim();
            refilterTable();
            checkScrollBars();
            autoRepaint();
            return;
        }
    }

    public String getFilter(int i)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        else
            return columnFilter[i];
    }

    public void setColumnStretchOn(boolean flag)
    {
        columnStretchOn = flag;
        adjustXpos();
        autoRepaint();
    }

    private void processMousePressed(MouseEvent mouseevent)
    {
        clickedRow = -1;
        clickedCell = -1;
        requestFocus();
        int i = mouseevent.getX();
        int j = mouseevent.getY();
        lastClickedPos = i;
        Dimension dimension = getSize();
        int k = getHeaderHeight();
        int l = getFilterHeight();
        int i1 = dimension.height - 2 - l;
        i1 -= hScrollbarOn ? l : 0;
        int j1 = get_field_seperator(i);
        clickedCell = get_field(i);
        selectedHeader = clickedCell;
        int k1 = k + 2;
        int l1 = dimension.height - 2;
        l1 -= filterBarOn ? l : 0;
        l1 -= hScrollbarOn ? 15 : 0;
        l1 -= isTotalRowOn(-1) ? getTotalRowHeight() : 0;
        int i2 = getFontMetrics(getFont()).getHeight();
        int j2 = (j - k - 2) / (i2 + 1) + firstRow;
        if(j > k1 && j < l1 && j2 >= 0 && j2 < displayRowCount)
            clickedRow = displayList[j2];
        if(j1 >= 0 && j > 2 && j < k + 2)
        {
            if(headerOn)
                adjusting = true;
        } else
        if(selectedHeader >= 0 && j > 2 && j < k + 2)
        {
            if(headerOn && sortingOn[selectedHeader])
                headerPushed[selectedHeader] = true;
        } else
        if(vScrollbarOn && i > dimension.width - 2 - 15)
            handleVerticalScrollbar(mouseevent);
        else
        if(hScrollbarOn && j > dimension.height - 2 - 15)
            handleHorizontalScrollbar(mouseevent);
        else
        if(selectedHeader >= 0 && j > i1 && j < i1 + l)
        {
            if((mouseevent.getModifiers() & 0x10) == 16)
            {
                boolean flag = !filterPushed[clickedCell];
                setFilterOn(clickedCell, flag);
                editFilterField(clickedCell, flag);
            }
            if((mouseevent.getModifiers() & 4) == 4)
                editFilterField(clickedCell, currentEditField == -1);
        } else
        if(clickedCell >= 0 && j > k + 2 && j < l1)
            handleRowSelection(mouseevent, clickedRow, clickedCell, j2);
        else
        if(clickedCell < 0)
            editFilterField(clickedCell, false);
        repaint();
    }

    private void processMouseDragged(MouseEvent mouseevent)
    {
        int i = getColumnCount();
        if(adjusting && i > 1)
        {
            if(columnStretchOn && currentSeperator < i - 1)
            {
                double d = mouseevent.getX();
                double d1 = d - lastClickedPos;
                if(d1 < 0.0D)
                {
                    double d2 = currentSeperator <= 0 ? 2 : columnXpos[currentSeperator - 1];
                    d1 = -Math.min(Math.abs(d1), (double)columnXpos[currentSeperator] - d2);
                }
                columnWidth[currentSeperator] += d1;
                double d3 = columnXpos[columnXpos.length - 1] - columnXpos[currentSeperator];
                double d4 = (d3 - d1) / d3;
                for(int i1 = currentSeperator + 1; i1 < columnWidth.length; i1++)
                {
                    columnWidth[i1] *= d4;
                    columnWidth[i1] = Math.max(columnWidth[i1], 5D);
                }

                lastClickedPos = d;
            } else
            if(!columnStretchOn)
            {
                int j = mouseevent.getX() + offset;
                int k = j - columnXpos[currentSeperator];
                int l = currentSeperator <= 0 ? 0 : columnXpos[currentSeperator - 1];
                if(j > l)
                    columnWidth[currentSeperator] += k;
            }
            adjustXpos();
            checkScrollBars();
            repaint();
        } else
        if(vSliderAdjusting)
            adjustVerticalScrollbar(mouseevent);
        else
        if(hSliderAdjusting)
            adjustHorizontalScrollbar(mouseevent);
    }

    private void calculateTotals()
    {
        int i = getColumnCount();
        for(int j = 0; j < i; j++)
        {
            double d = 0.0D;
            if(columnType[j] == 1 || columnType[j] == 2)
            {
                for(int k = 0; k < displayRowCount; k++)
                    try
                    {
                        String s = getCellLabel(displayList[k], j);
                        d += (new Double(s)).doubleValue();
                    }
                    catch(NumberFormatException _ex) { }

                columnTotal[j] = d;
            } else
            {
                columnTotal[j] = displayRowCount;
            }
        }

    }

    public void setPostfix(int i, String s)
    {
        if(i >= 0 && i < columnPostfix.length)
        {
            columnPostfix[i] = s;
            autoRepaint();
        }
    }

    public String getPostfix(int i)
    {
        if(i >= 0 && i < columnPostfix.length)
            return columnPostfix[i];
        else
            return null;
    }

    private void initParameter(String s, String s1)
    {
        if(s1 != null)
            setParameter(s, s1);
    }

    public void addTableListener(TableListener tablelistener)
    {
        listeners.addElement(tablelistener);
    }

    private void paintFilter(Graphics g)
    {
        g.setFont(getFont());
        FontMetrics fontmetrics = g.getFontMetrics();
        g.setColor(getBackground());
        Dimension dimension = getSize();
        int i = getFilterHeight();
        g.setClip(0, 0, dimension.width, dimension.height);
        int j = dimension.height - 2 - i;
        j -= hScrollbarOn ? 15 : 0;
        g.fillRect(3, j, dimension.width - 4 - 1, i);
        int k = getColumnCount();
        for(int l = 0; l < k; l++)
            if(columnOn[l])
            {
                int j1 = l <= 0 ? (2 - offset) + 1 : columnXpos[l - 1] - offset;
                int k1 = l <= 0 ? columnXpos[l] - 2 - 1 : columnXpos[l] - columnXpos[l - 1];
                boolean flag = filterPushed[l];
                g.setColor(getBackground());
                g.setClip(0, 0, dimension.width, dimension.height);
                if(visibleColumnCount > 1)
                    g.draw3DRect(j1, j, k1 - 1, i - 1, !flag);
                else
                    g.draw3DRect(j1, j, dimension.width - 4 - 2, i - 1, !flag);
                String s = columnFilter[l];
                g.setColor(getForeground());
                int l1 = paintFieldLabel(g, s, j, l, flag);
                int i2 = s == null ? 0 : fontmetrics.stringWidth(s);
                if(currentEditField == l && cursorOn)
                {
                    g.setColor(getForeground());
                    g.drawLine(l1 + i2, j + 3, l1 + i2, (j + i) - 3);
                    g.drawLine(l1 + i2 + 1, j + 3, l1 + i2 + 1, (j + i) - 3);
                }
            }

        if(visibleColumnCount > 1)
        {
            int i1 = columnXpos[columnXpos.length - 1] - offset;
            g.setClip(0, 0, dimension.width, dimension.height);
            g.setColor(getBackground());
            g.draw3DRect(i1, j, dimension.width, i - 1, true);
        }
    }

    private void paintBorder(Graphics g)
    {
        byte byte0 = 2;
        Dimension dimension = getSize();
        Rectangle rectangle = new Rectangle(0, 0, dimension.width, dimension.height);
        g.setColor(getBackground());
        g.setClip(0, 0, dimension.width, dimension.height);
        for(int i = 0; i < byte0; i++)
            g.drawRect(rectangle.x + i, rectangle.y + i, rectangle.width - i * 2, rectangle.height - i * 2);

        g.draw3DRect(rectangle.x + byte0, rectangle.y + byte0, rectangle.width - byte0 * 2, rectangle.height - byte0 * 2, false);
        g.setColor(Color.black);
        g.drawLine(rectangle.x + byte0, rectangle.y + byte0, rectangle.x + byte0, rectangle.height - byte0);
        g.drawLine(rectangle.x + byte0, rectangle.y + byte0, rectangle.width - byte0, rectangle.y + byte0);
    }

    public boolean isColumnOn(int i)
    {
        try
        {
            return columnOn[i];
        }
        catch(IndexOutOfBoundsException _ex)
        {
            return false;
        }
    }

    public void setAutomaticRepaintOn(boolean flag)
    {
        automaticRepaintOn = flag;
    }

    private int getHeaderHeight()
    {
        if(headerOn)
            return getFontMetrics(getFont()).getHeight() + 6;
        else
            return 0;
    }

    private void adjustVerticalScrollbar(MouseEvent mouseevent)
    {
        int i = mouseevent.getY();
        int j = i - vSliderAdjustPos;
        vSliderPos += j;
        vSliderPos = Math.max(vSliderPos, vScrollerTop + 15 + 1);
        vSliderPos = Math.min(vSliderPos, (vScrollerTop + 15 + vSliderSpace) - vSliderSize - 1);
        int k = vSliderPos - vScrollerTop - 15 - 1;
        firstRow = (int)Math.round((double)(k * (displayRowCount - maxDisplayRowCount)) / (double)(vSliderSpace - vSliderSize - 2));
        vSliderAdjustPos = i;
        repaint();
    }

    public void run()
    {
        switch(threadType)
        {
        default:
            break;

        case 0: // '\0'
            do
                try
                {
                    Thread.sleep(500L);
                    cursorOn = !cursorOn;
                    repaint();
                }
                catch(InterruptedException _ex) { }
            while(true);

        case 4: // '\004'
            try
            {
                Thread.sleep(250L);
                do
                {
                    do
                        Thread.sleep(35L);
                    while(displayRowCount - firstRow <= maxDisplayRowCount);
                    firstRow++;
                    vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 3: // '\003'
            try
            {
                Thread.sleep(250L);
                do
                {
                    do
                        Thread.sleep(35L);
                    while(firstRow <= 0);
                    firstRow--;
                    vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 8: // '\b'
            try
            {
                Thread.sleep(250L);
                do
                {
                    do
                        Thread.sleep(35L);
                    while(scrollByPageToY <= vSliderPos + vSliderSize);
                    firstRow += maxDisplayRowCount;
                    firstRow = Math.min(firstRow, displayRowCount - maxDisplayRowCount);
                    vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 7: // '\007'
            try
            {
                Thread.sleep(250L);
                do
                {
                    do
                        Thread.sleep(35L);
                    while(scrollByPageToY >= vSliderPos);
                    firstRow -= maxDisplayRowCount;
                    firstRow = Math.max(firstRow, 0);
                    vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 2: // '\002'
            try
            {
                Thread.sleep(250L);
                int i = 17 + hSliderSpace;
                int i1 = columnXpos[columnXpos.length - 1];
                do
                {
                    do
                        Thread.sleep(35L);
                    while(i1 - offset <= i + 15);
                    int i2 = i1 - offset - i - 15 - 1;
                    offset += Math.min(10, i2);
                    int k2 = hSliderSpace + 30;
                    hSliderPos = 18 + (int)Math.round(((double)(offset + 3) / (double)(i1 - k2)) * (double)(hSliderSpace - hSliderSize));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 1: // '\001'
            try
            {
                Thread.sleep(250L);
                do
                {
                    int j;
                    int j1;
                    do
                    {
                        Thread.sleep(35L);
                        j = columnXpos[columnXpos.length - 1];
                        j1 = hSliderSpace + 30;
                    } while(offset <= 0);
                    offset -= 10;
                    offset = Math.max(0, offset);
                    hSliderPos = 18 + (int)Math.round(((double)offset / (double)(j - j1)) * (double)(hSliderSpace - hSliderSize));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 6: // '\006'
            try
            {
                Thread.sleep(250L);
                int k = columnXpos[columnXpos.length - 1];
                do
                {
                    do
                        Thread.sleep(35L);
                    while(scrollByPageToX < hSliderPos + hSliderSize);
                    int k1 = k - offset - 2 - hSliderSpace - 30 - 1;
                    offset += Math.min(15 + hSliderSpace, k1);
                    int j2 = hSliderSpace + 30;
                    hSliderPos = 18 + (int)Math.round(((double)(offset + 3) / (double)(k - j2)) * (double)(hSliderSpace - hSliderSize));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;

        case 5: // '\005'
            try
            {
                Thread.sleep(250L);
                int l = columnXpos[columnXpos.length - 1];
                do
                {
                    do
                        Thread.sleep(35L);
                    while(scrollByPageToX >= hSliderPos);
                    offset -= 15 + hSliderSpace;
                    offset = Math.max(offset, 0);
                    int l1 = hSliderSpace + 30;
                    hSliderPos = 18 + (int)Math.round(((double)offset / (double)(l - l1)) * (double)(hSliderSpace - hSliderSize));
                    repaint();
                } while(true);
            }
            catch(InterruptedException _ex) { }
            break;
        }
    }

    public void init()
    {
        setAutomaticRepaintOn(false);
        setParameter("fieldSeparator", getParameter("fieldSeparator"));
        initParameter("columnCount", getParameter("columnCount"));
        initParameter("header", getParameter("header"));
        initParameter("headerOff", getParameter("headerOff"));
        initParameter("filterBarOn", getParameter("filterBarOn"));
        initParameter("progressiveFilterOn", getParameter("progressiveFilterOn"));
        initParameter("selectionMode", getParameter("selectionMode"));
        initParameter("columnWidth", getParameter("columnWidth"));
        initParameter("columnStretchOn", getParameter("columnStretchOn"));
        initParameter("columnAlignment", getParameter("columnAlignment"));
        initParameter("columnType", getParameter("columnType"));
        initParameter("rowForeground", getParameter("rowForeground"));
        initParameter("rowBackground", getParameter("rowBackground"));
        initParameter("foreground", getParameter("foreground"));
        initParameter("background", getParameter("background"));
        initParameter("totalRowOn", getParameter("totalRowOn"));
        initParameter("sortingOff", getParameter("sortingOff"));
        initParameter("filterWildCard", getParameter("filterWildCard"));
        initParameter("urlColor", getParameter("urlColor"));
        initParameter("gridOn", getParameter("gridOn"));
        initParameter("gridColor", getParameter("gridColor"));
        initParameter("urltarget", getParameter("urltarget"));
        initParameter("locale", getParameter("locale"));
        int i = getColumnCount();
        for(int j = 0; j < i; j++)
        {
            initParameter("prefix_" + j, getParameter("prefix_" + j));
            initParameter("postfix_" + j, getParameter("postfix_" + j));
            initParameter("decimalCount_" + j, getParameter("decimalCount_" + j));
        }

        System.currentTimeMillis();
        int k = 0;
        for(String s = getParameter("row_" + k); s != null; s = getParameter("row_" + k))
        {
            setParameter("row_" + k, s);
            String s1 = "rowForeground_" + k;
            initParameter(s1, getParameter(s1));
            s1 = "rowBackground_" + k;
            initParameter(s1, getParameter(s1));
            s1 = "url_" + k;
            initParameter(s1, getParameter(s1));
            s1 = "urltarget_" + k;
            initParameter(s1, getParameter(s1));
            for(int l = 0; l < i; l++)
            {
                String s2 = "url_" + k + "_" + l;
                initParameter(s2, getParameter(s2));
                s2 = "urltarget_" + k + "_" + l;
                initParameter(s2, getParameter(s2));
            }

            k++;
        }

        try
        {
            applet = getAppletContext();
        }
        catch(Exception _ex) { }
        checkScrollBars();
        adjustXpos();
        setAutomaticRepaintOn(true);
        repaint();
    }

    public void setDecimalCount(int i, int j)
    {
        try
        {
            decimalCount[i] = Math.max(0, j);
        }
        catch(IndexOutOfBoundsException _ex)
        {
            throw new IllegalArgumentException("Invalid column: " + i);
        }
        autoRepaint();
    }

    public int getDecimalCount(int i)
    {
        try
        {
            return decimalCount[i];
        }
        catch(IndexOutOfBoundsException _ex)
        {
            throw new IllegalArgumentException("Invalid column: " + i);
        }
    }

    private void adjustXpos()
    {
        Dimension dimension = getSize();
        int i = dimension.width - 2 - (vScrollbarOn ? 15 : 0);
        if(columnStretchOn)
        {
            double d = 0.0D;
            for(int l = 0; l < columnWidth.length; l++)
                d += columnOn[l] ? columnWidth[l] : 0.0D;

            int i1 = i - 2;
            for(int k1 = 0; k1 < columnWidth.length; k1++)
            {
                double d1 = columnOn[k1] ? columnWidth[k1] : 0.0D;
                columnWidth[k1] = (double)i1 * (d1 / d);
            }

        }
        int j = 3;
        int k = getColumnCount();
        for(int j1 = 0; j1 < k; j1++)
        {
            j = (int)((double)j + (columnOn[j1] ? columnWidth[j1] : 0.0D));
            columnXpos[j1] = j;
        }

        if(columnStretchOn || k == 1)
            columnXpos[columnXpos.length - 1] = i;
    }

    private void handleRowSelection(MouseEvent mouseevent, int i, int j, int k)
    {
        if(i < 0)
            return;
        if(getURL(i, j) != null)
            return;
        lastSelectedCell = j;
        Object aobj[] = getRow(i);
        switch(selectionMode)
        {
        default:
            break;

        case 0: // '\0'
            byte byte0 = ((byte)(mouseevent.isMetaDown() ? 3 : 0));
            lastSelectedRow = i;
            notifyListeners(aobj, byte0, j, k, i);
            break;

        case 1: // '\001'
            if(i != lastSelectedRow && lastSelectedRow >= 0 && lastSelectedRow < getRowCount())
            {
                int l = lastSelectedRow;
                selectRow(lastSelectedRow, false);
                notifyListeners(getRow(l), 1, -1, -1, l);
            }
            int i1 = lastSelectedRow;
            selectRow(i, true);
            if(filterBarOn)
                setFilterBarFields(aobj);
            byte byte1 = ((byte)(mouseevent.isMetaDown() ? 3 : 0));
            long l1 = System.currentTimeMillis();
            if(l1 - lastSelectedTime < 500L && i == i1)
                notifyListeners(aobj, 2, j, k, i);
            else
                notifyListeners(aobj, byte1, j, k, i);
            lastSelectedTime = l1;
            break;

        case 2: // '\002'
            selectRow(i, !isRowSelected(i));
            if(selectedRows[i])
            {
                setFilterBarFields(aobj);
                notifyListeners(aobj, 0, j, k, i);
            } else
            {
                setFilterBarFields(null);
                notifyListeners(aobj, 1, j, k, i);
            }
            break;
        }
        editFilterField(-1, false);
    }

    public void stop()
    {
        TableEvent.closeEvaluation();
        super.stop();
    }

    private void handleFilterEdit(KeyEvent keyevent)
    {
        char c = keyevent.getKeyChar();
        int i = keyevent.getKeyCode();
        int j = keyevent.getID();
        boolean flag = false;
        boolean flag1 = progressiveFilterOn;
        if(j == 400)
        {
            if(c >= ' ' && c < '\177')
            {
                if(columnFilter[currentEditField] == null)
                    columnFilter[currentEditField] = "";
                columnFilter[currentEditField] = columnFilter[currentEditField] + c;
                flag = true;
            }
        } else
        if(j == 401)
        {
            if(i == 8)
            {
                String s = columnFilter[currentEditField];
                if(s.length() > 0)
                {
                    columnFilter[currentEditField] = s.substring(0, s.length() - 1);
                    flag = true;
                }
            }
            if(i == 10)
            {
                filterPushed[currentEditField] = true;
                flag1 = true;
            }
        }
        if(flag1)
            setFilter(currentEditField, columnFilter[currentEditField]);
        if(flag && selectionMode == 1)
        {
            String s1 = columnFilter[currentEditField];
            if(s1 != null)
                s1 = s1.toLowerCase();
            int k = -1;
            for(int l = 0; l < displayRowCount; l++)
            {
                String s2 = getCellLabel(displayList[l], currentEditField).toLowerCase();
                if(!s2.startsWith(s1))
                    continue;
                k = displayList[l];
                break;
            }

            if(k > -1)
            {
                if(lastSelectedRow > -1)
                    selectRow(lastSelectedRow, false);
                gotoRow(k);
                selectRow(k, true);
            }
        }
        cursorOn = true;
        repaint();
    }

    private void paintGrid(Graphics g)
    {
        if(g == null || displayRowCount < 1)
            return;
        g.setFont(getFont());
        FontMetrics fontmetrics = g.getFontMetrics();
        Dimension dimension = getSize();
        g.setClip(0, 0, dimension.width, dimension.height);
        int i = getHeaderHeight();
        int j = fontmetrics.getHeight() + 1;
        g.setColor(getGridColor());
        int k = i + 3;
        for(int l = firstRow; l < displayRowCount; l++)
        {
            g.drawLine(0, k + j, columnXpos[columnXpos.length - 1] - 1, k + j);
            k += j;
        }

        for(int i1 = 0; i1 < columnXpos.length; i1++)
        {
            int j1 = columnXpos[i1] - offset - 1;
            g.drawLine(j1, 0, j1, rowBottom);
        }

    }

    public boolean isHeaderOn()
    {
        return headerOn;
    }

    public void setFilterOn(int i, boolean flag)
    {
        if(i < 0 || i >= filterPushed.length)
        {
            throw new IllegalArgumentException("invalid column index: " + i);
        } else
        {
            filterPushed[i] = flag;
            refilterTable();
            autoRepaint();
            return;
        }
    }

    public boolean isFilterBarOn()
    {
        return filterBarOn;
    }

    public boolean isSortingOn(int i)
    {
        if(i >= 0 && i < sortingOn.length)
            return sortingOn[i];
        else
            return false;
    }

    public int getLastSelectedCell()
    {
        return lastSelectedCell;
    }

    public static void displayVersion()
    {
        Table table = new Table(2);
        table.setRow(-1, new String[] {
            "Name:", "Table"
        });
        table.setRow(-1, new String[] {
            "Version:", getVersion()
        });
        table.setRow(-1, new String[] {
            "Copyright:", "ObjectPlanet, Inc., 1999-2001"
        });
        table.setRow(-1, new String[] {
            "Address:", "www.objectplanet.com"
        });
        table.setColumnAlignment(0, 2);
        table.setColumnWidth(0, 50);
        table.setColumnWidth(1, 150);
        Frame frame = new Frame();
        frame.add("Center", table);
        frame.setSize(250, 150);
        frame.show();
    }

    public void removeRow(int i)
    {
        int j = getRowCount();
        if(i < 0 || i >= j)
            throw new IllegalArgumentException("Invalid row: " + i);
        tableData.removeRow(i);
        int k = -1;
        for(int l = 0; l < j; l++)
        {
            if(sortedList[l] == i)
                k = l;
            if(sortedList[l] >= i)
                sortedList[l]--;
        }

        for(int i1 = k; i1 < sortedList.length - 1; i1++)
            sortedList[i1] = sortedList[i1 + 1];

        if(i >= 0 && i < selectedRows.length)
        {
            selectedRows[i] = false;
            if(lastSelectedRow == i)
            {
                lastSelectedRow = -1;
                lastSelectedCell = -1;
            }
        }
        refilterTable();
        autoRepaint();
    }

    private String getURLTarget(int i, int j)
    {
        String s = i + "_" + j;
        if(urlTargetList.get(s) != null)
            return (String)urlTargetList.get(s);
        s = i + "";
        if(urlTargetList.get(s) != null)
            return (String)urlTargetList.get(s);
        else
            return (String)urlTargetList.get("default");
    }

    public void setRowForeground(int i, Color color)
    {
        if(i > -1 && i < rowForeground.length)
            rowForeground[i] = color;
        else
            defaultRowForeground = color == null ? Color.black : color;
        autoRepaint();
    }

    public Color getRowForeground(int i)
    {
        if(i > -1 && i < rowForeground.length && rowForeground[i] != null)
            return rowForeground[i];
        else
            return defaultRowForeground;
    }

    private void startScrollerThread(int i)
    {
        if(thread != null)
        {
            thread.stop();
            thread = null;
        }
        threadType = i;
        thread = new Thread(this);
        thread.start();
    }

    public Table()
    {
        this(1);
    }

    public Table(int i)
    {
        this(new TableData(i));
    }

    public Table(TableData tabledata)
    {
        if(tabledata == null)
            throw new IllegalArgumentException("TableData is NULL");
        tableData = tabledata;
        int i = getRowCount();
        int j = getColumnCount();
        automaticRepaintOn = true;
        defaultRowBackground = SystemColor.window;
        defaultRowForeground = SystemColor.windowText;
        setBackground(SystemColor.control);
        setFont(new Font("Dialog", 0, 11));
        selectionMode = 0;
        firstRow = 0;
        lastSelectedRow = -1;
        currentEditField = -1;
        lastSortedColumn = -1;
        currentSeperator = -1;
        visibleColumnCount = tabledata.getColumnCount();
        hScrollbarOn = false;
        vScrollbarOn = false;
        upButtonPushed = false;
        downButtonPushed = false;
        aboveSliderPushed = false;
        belowSliderPushed = false;
        leftButtonPushed = false;
        rightButtonPushed = false;
        leftToSliderPushed = false;
        rightToSliderPushed = false;
        filterWildCard = "*";
        preferredSize = new Dimension(100 * j + 20, 200);
        headerOn = true;
        headerLabels = new String[j];
        rowForeground = new Color[i];
        rowBackground = new Color[i];
        listeners = new Vector();
        selectedRows = new boolean[i];
        headerPushed = new boolean[j];
        filterPushed = new boolean[j];
        columnOn = new boolean[j];
        columnWidth = new double[j];
        columnAlignment = new int[j];
        columnType = new int[j];
        columnFilter = new String[j];
        sortingOn = new boolean[j];
        for(int k = 0; k < j; k++)
        {
            columnType[k] = 0;
            columnWidth[k] = 100D;
            columnAlignment[k] = 0;
            columnFilter[k] = new String();
            columnOn[k] = true;
            sortingOn[k] = true;
        }

        displayList = new int[i];
        sortedList = new int[i];
        columnXpos = new int[j];
        columnPrefix = new String[j];
        columnPostfix = new String[j];
        columnTotal = new double[j];
        totalRowOn = new boolean[j];
        decimalCount = new int[j];
        urlList = new Hashtable();
        urlTargetList = new Hashtable();
        urlTargetList.put("default", "_self");
        checkScrollBars();
        adjustXpos();
        enableEvents(57L);
    }

    public synchronized void setColumnCount(int i)
    {
        i = Math.max(1, i);
        tableData.setColumnCount(i);
        setColumnDataCount(i);
        autoRepaint();
    }

    public int getColumnCount()
    {
        return tableData.getColumnCount();
    }

    public void setColumnAlignment(int i, int j)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        if(j != 0 && j != 1 && j != 2)
        {
            throw new IllegalArgumentException("Invalid column alignment");
        } else
        {
            columnAlignment[i] = j;
            autoRepaint();
            return;
        }
    }

    public int getColumnAlignment(int i)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        else
            return columnAlignment[i];
    }

    public final void paint(Graphics g)
    {
        Dimension dimension = getSize();
        if(offscreen == null || offscreen.getWidth(this) < dimension.width || offscreen.getHeight(this) < dimension.height)
            offscreen = createImage(dimension.width, dimension.height);
        Graphics g1 = g;
        if(offscreen != null)
            g1 = offscreen.getGraphics();
        render(g1);
        if(g1 != g)
        {
            g.drawImage(offscreen, 0, 0, this);
            g1.dispose();
        }
        if(TableEvent.evaluation)
            TableEvent.showEvaluation(this);
        super.paint(g);
    }

    public int getRowIndex(Object obj)
    {
        return tableData.getRowIndex(obj);
    }

    public int getRowIndex(int i)
    {
        if(i < 0 || i >= displayList.length)
            throw new IllegalArgumentException("Invalid position: " + i);
        else
            return displayList[i];
    }

    private URL getURL(int i, int j)
    {
        if(i < 0)
            return null;
        String s = i + "";
        if(j >= 0)
            s += "_" + j;
        URL url = (URL)urlList.get(s);
        if(url == null)
            url = (URL)urlList.get(i + "");
        return url;
    }

    /**
     * @deprecated Method setTotalRowOn is deprecated
     */

    public void setTotalRowOn(boolean flag)
    {
        setTotalRowOn(-1, flag);
    }

    public void setTotalRowOn(int i, boolean flag)
    {
        if(i >= 0 && i < totalRowOn.length)
            totalRowOn[i] = flag;
        else
        if(i == -1)
        {
            for(int j = 0; j < totalRowOn.length; j++)
                totalRowOn[j] = flag;

        }
        checkScrollBars();
        autoRepaint();
    }

    private void processMouseMoved(MouseEvent mouseevent)
    {
        int i = mouseevent.getX();
        int j = mouseevent.getY();
        Dimension dimension = getSize();
        int k = getHeaderHeight();
        int l = getFilterHeight();
        int i1 = dimension.height - 2 - l;
        i1 -= hScrollbarOn ? 15 : 0;
        int j1 = visibleColumnCount <= 1 ? dimension.width : columnXpos[columnXpos.length - 1];
        j1 = vScrollbarOn ? dimension.width - 15 : j1;
        currentSeperator = get_field_seperator(i);
        int k1 = -1;
        int l1 = get_field(i);
        int i2 = k + 2;
        int j2 = dimension.height - 2;
        j2 -= filterBarOn ? l : 0;
        j2 -= hScrollbarOn ? 15 : 0;
        j2 -= isTotalRowOn(-1) ? getTotalRowHeight() : 0;
        int k2 = getFontMetrics(getFont()).getHeight();
        int l2 = (j - k - 2) / (k2 + 1) + firstRow;
        if(j < j2 && l2 >= 0 && l2 < displayRowCount)
            k1 = displayList[l2];
        if(visibleColumnCount > 1 && j < i2 && currentSeperator >= 0)
        {
            if(headerOn)
                setCursor(RESIZE_CURSOR);
        } else
        if(j < i2 && i < (visibleColumnCount <= 1 ? dimension.width : columnXpos[columnXpos.length - 1]))
        {
            if(headerOn)
                setCursor(HAND_CURSOR);
        } else
        if(j > i1 && j < i1 + l && i < j1)
        {
            setCursor(TEXT_CURSOR);
        } else
        {
            URL url = getURL(k1, l1);
            setCursor(url == null ? DEFAULT_CURSOR : HAND_CURSOR);
            if(applet != null)
                showStatus(url == null ? "" : url.toString());
            currentSeperator = -1;
        }
    }

    private void processKeys(KeyEvent keyevent)
    {
        if(keyevent.getID() == 401 && currentEditField == -1 && selectionMode == 1)
            handleRowKeySelection(keyevent);
        if(currentEditField > -1)
            handleFilterEdit(keyevent);
    }

    private void paintHeader(Graphics g)
    {
        g.setFont(getFont());
        g.getFontMetrics();
        Dimension dimension = getSize();
        int i = getHeaderHeight();
        g.setClip(0, 0, dimension.width, dimension.height);
        g.setColor(getBackground());
        g.fillRect(3, 3, dimension.width - 4 - 1, i);
        int j = getColumnCount();
        for(int k = 0; k < j; k++)
            if(columnOn[k])
            {
                int i1 = k <= 0 ? (2 - offset) + 1 : columnXpos[k - 1] - offset;
                int j1 = k <= 0 ? columnXpos[k] - 2 - 1 : columnXpos[k] - columnXpos[k - 1];
                boolean flag = headerPushed[k];
                g.setColor(getBackground());
                g.setClip(0, 0, dimension.width, dimension.height);
                if(visibleColumnCount > 1)
                    g.draw3DRect(i1, 3, j1 - 1, i - 1, !flag);
                else
                    g.draw3DRect(i1, 3, dimension.width - 4 - 2, i - 1, !flag);
                String s = headerLabels[k];
                int k1 = 4 + (flag ? 1 : 0);
                g.setColor(getForeground());
                paintFieldLabel(g, s, k1, k, flag);
            }

        if(visibleColumnCount > 1)
        {
            int l = columnXpos[columnXpos.length - 1] - offset;
            g.setClip(0, 0, dimension.width, dimension.height);
            g.setColor(getBackground());
            g.draw3DRect(l, 3, dimension.width, i - 1, true);
        }
    }

    private void handleHorizontalScrollbar(MouseEvent mouseevent)
    {
        int i = mouseevent.getX();
        int j = 17 + hSliderSpace;
        int k = columnXpos[columnXpos.length - 1];
        if(i > 2 && i < 17)
        {
            leftButtonPushed = true;
            if(offset > 0)
            {
                offset -= 10;
                offset = Math.max(0, offset);
                int l = hSliderSpace + 30;
                hSliderPos = 18 + (int)Math.round(((double)offset / (double)(k - l)) * (double)(hSliderSpace - hSliderSize));
                startScrollerThread(1);
            }
        } else
        if(i > j && i < j + 15)
        {
            rightButtonPushed = true;
            if(k - offset > j + 15)
            {
                int i1 = k - offset - j - 15 - 1;
                offset += Math.min(10, i1);
                int l1 = hSliderSpace + 30;
                hSliderPos = 18 + (int)Math.round(((double)(offset + 3) / (double)(k - l1)) * (double)(hSliderSpace - hSliderSize));
                startScrollerThread(2);
            }
        } else
        if(i < hSliderPos && i >= 17)
        {
            leftToSliderPushed = true;
            offset -= 15 + hSliderSpace;
            offset = Math.max(offset, 0);
            int j1 = hSliderSpace + 30;
            hSliderPos = 18 + (int)Math.round(((double)offset / (double)(k - j1)) * (double)(hSliderSpace - hSliderSize));
            scrollByPageToX = i;
            startScrollerThread(5);
        } else
        if(i >= hSliderPos + hSliderSize && i <= j)
        {
            rightToSliderPushed = true;
            int k1 = k - offset - j - 15 - 1;
            offset += Math.min(15 + hSliderSpace, k1);
            int i2 = hSliderSpace + 30;
            hSliderPos = 18 + (int)Math.round(((double)(offset + 3) / (double)(k - i2)) * (double)(hSliderSpace - hSliderSize));
            scrollByPageToX = i;
            startScrollerThread(6);
        } else
        if(i > hSliderPos && i < hSliderPos + hSliderSize)
        {
            hSliderAdjusting = true;
            hSliderAdjustPos = i;
        }
    }

    private void handleRowKeySelection(KeyEvent keyevent)
    {
        int i = -1;
        for(int j = 0; j < displayRowCount; j++)
            if(displayList[j] == lastSelectedRow)
                i = j;

        switch(keyevent.getKeyCode())
        {
        default:
            break;

        case 40: // '('
            if(i + 1 >= displayRowCount)
                break;
            if(i >= 0)
            {
                selectRow(displayList[i], false);
                notifyListeners(getRow(displayList[i]), 1, -1, i, displayList[i]);
            }
            gotoRow(displayList[i + 1]);
            selectRow(displayList[i + 1], true);
            setFilterBarFields(getRow(displayList[i + 1]));
            notifyListeners(getRow(displayList[i + 1]), 0, -1, i + 1, displayList[i + 1]);
            break;

        case 38: // '&'
            if(i - 1 >= 0)
            {
                selectRow(displayList[i], false);
                selectRow(displayList[i - 1], true);
                setFilterBarFields(getRow(displayList[i - 1]));
                gotoRow(displayList[i - 1]);
                notifyListeners(getRow(displayList[i]), 1, -1, i, displayList[i]);
                notifyListeners(getRow(displayList[i - 1]), 0, -1, i - 1, displayList[i - 1]);
            }
            break;

        case 10: // '\n'
            if(lastSelectedRow >= 0)
                notifyListeners(getRow(lastSelectedRow), 2, -1, i, lastSelectedRow);
            break;
        }
        checkScrollBars();
        repaint();
    }

    private synchronized void setColumnDataCount(int i)
    {
        String as[] = new String[i];
        System.arraycopy(headerLabels, 0, as, 0, Math.min(headerLabels.length, i));
        headerLabels = as;
        int ai[] = new int[i];
        System.arraycopy(columnType, 0, ai, 0, Math.min(columnType.length, i));
        columnType = ai;
        int ai1[] = new int[i];
        System.arraycopy(columnAlignment, 0, ai1, 0, Math.min(columnAlignment.length, i));
        columnAlignment = ai1;
        boolean aflag[] = new boolean[i];
        System.arraycopy(columnOn, 0, aflag, 0, Math.min(columnOn.length, i));
        for(int j = columnOn.length; j < i; j++)
            aflag[j] = true;

        columnOn = aflag;
        visibleColumnCount = 0;
        for(int k = 0; k < i; k++)
            if(columnOn[k])
                visibleColumnCount++;

        double ad[] = new double[i];
        System.arraycopy(columnWidth, 0, ad, 0, Math.min(columnWidth.length, i));
        for(int l = columnWidth.length; l < i; l++)
            ad[l] = 100D;

        columnWidth = ad;
        columnXpos = new int[i];
        adjustXpos();
        String as1[] = new String[i];
        System.arraycopy(columnPrefix, 0, as1, 0, Math.min(columnPrefix.length, i));
        columnPrefix = as1;
        String as2[] = new String[i];
        System.arraycopy(columnPostfix, 0, as2, 0, Math.min(columnPostfix.length, i));
        columnPostfix = as2;
        boolean aflag1[] = new boolean[i];
        System.arraycopy(headerPushed, 0, aflag1, 0, Math.min(headerPushed.length, i));
        headerPushed = aflag1;
        String as3[] = new String[i];
        System.arraycopy(columnFilter, 0, as3, 0, Math.min(columnFilter.length, i));
        columnFilter = as3;
        boolean aflag2[] = new boolean[i];
        System.arraycopy(filterPushed, 0, aflag2, 0, Math.min(filterPushed.length, i));
        filterPushed = aflag2;
        double ad1[] = new double[i];
        System.arraycopy(columnTotal, 0, ad1, 0, Math.min(columnTotal.length, i));
        columnTotal = ad1;
        boolean aflag3[] = new boolean[i];
        System.arraycopy(totalRowOn, 0, aflag3, 0, Math.min(totalRowOn.length, i));
        totalRowOn = aflag3;
        int ai2[] = new int[i];
        System.arraycopy(decimalCount, 0, ai2, 0, Math.min(decimalCount.length, i));
        decimalCount = ai2;
        boolean aflag4[] = new boolean[i];
        for(int i1 = 0; i1 < aflag4.length; i1++)
            aflag4[i1] = true;

        System.arraycopy(sortingOn, 0, aflag4, 0, Math.min(sortingOn.length, i));
        sortingOn = aflag4;
    }

    public static void main(String args[])
    {
        displayVersion();
    }

    private int compare(int i, int j, int k, int l)
    {
        int i1 = getRowCount();
        if(i < 0 || i >= i1 || j < 0 || j >= i1)
            return 0;
        if(k < 0 || k >= getColumnCount())
            return 0;
        String s = getCellLabel(i, k);
        String s1 = getCellLabel(j, k);
        s = s == null ? "" : s.toLowerCase();
        s1 = s1 == null ? "" : s1.toLowerCase();
        switch(l)
        {
        case 0: // '\0'
            if(s.compareTo(s1) < 0)
                return -1;
            return s.compareTo(s1) <= 0 ? 0 : 1;

        case 1: // '\001'
        case 2: // '\002'
            try
            {
                double d = (new Double(s.trim())).doubleValue();
                double d1 = (new Double(s1.trim())).doubleValue();
                if(d < d1)
                    return -1;
                return d <= d1 ? 0 : 1;
            }
            catch(NumberFormatException _ex)
            {
                return compare(i, j, k, 0);
            }
        }
        return 0;
    }

    private int get_field(int i)
    {
        int j = getColumnCount();
        for(int k = 0; k < j; k++)
            if(columnOn[k] && i <= columnXpos[k] - 1 - offset)
                return k;

        return -1;
    }

    public void setColumnOn(int i, boolean flag)
    {
        if(i < 0 || i >= getColumnCount())
            throw new IllegalArgumentException("Invalid column: " + i);
        columnOn[i] = flag;
        visibleColumnCount = 0;
        for(int j = 0; j < columnOn.length; j++)
            if(columnOn[j])
                visibleColumnCount++;

        adjustXpos();
        autoRepaint();
    }

    private int getTotalRowHeight()
    {
        FontMetrics fontmetrics = getFontMetrics(getFont());
        if(fontmetrics != null)
            return fontmetrics.getHeight() + 3;
        else
            return 20;
    }

    public String getCellLabel(int i, int j)
    {
        Object obj = getCell(i, j);
        if(obj instanceof String)
            return (String)obj;
        else
            return null;
    }

    private void checkScrollBars()
    {
        Dimension dimension = getSize();
        FontMetrics fontmetrics = getFontMetrics(getFont());
        hScrollbarOn = false;
        int i = columnXpos[columnXpos.length - 1];
        if(!columnStretchOn && visibleColumnCount > 1)
        {
            int j = dimension.width - 2 - (vScrollbarOn ? 15 : 0);
            if(i > j || offset < 0)
                hScrollbarOn = true;
        }
        int k = getHeaderHeight();
        int l = dimension.height - k - 4;
        l -= hScrollbarOn ? 15 : 0;
        l -= filterBarOn ? getFilterHeight() : 0;
        l -= isTotalRowOn(-1) ? getTotalRowHeight() : 0;
        int i1 = fontmetrics.getHeight() + 1;
        maxDisplayRowCount = l / i1;
        int j1 = Math.max(0, maxDisplayRowCount);
        int k1 = displayRowCount - firstRow;
        vScrollerTop = k + 2;
        if(k1 < j1 && firstRow > 0)
            firstRow = Math.max(displayRowCount - maxDisplayRowCount, 0);
        vScrollbarOn = false;
        if(k1 > j1 || firstRow > 0)
            vScrollbarOn = true;
        vSliderSpace = dimension.height - k - 30 - 2;
        if(hScrollbarOn)
            vSliderSpace -= 15;
        hSliderSpace = dimension.width - 30 - 4 - 1;
        if(vScrollbarOn)
            hSliderSpace -= 15;
        j1 = Math.min(j1, displayRowCount);
        vSliderSize = (int)Math.round(((double)j1 / (double)displayRowCount) * (double)vSliderSpace) - 2;
        vSliderSize = Math.max(vSliderSize, 6);
        vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
        int l1 = hSliderSpace + 30;
        int i2 = l1 + 2;
        if(i - offset < i2)
        {
            offset -= i2 - (i - offset);
            offset = Math.max(0, offset);
        }
        hSliderSize = (int)Math.round(((double)l1 / (double)i) * (double)hSliderSpace);
        hSliderSize = Math.max(hSliderSize, 6);
        hSliderPos = 18 + (int)Math.round(((double)offset / (double)(i - l1)) * (double)(hSliderSpace - hSliderSize));
    }

    public void setTableData(TableData tabledata)
    {
        if(tabledata == null)
            throw new IllegalArgumentException("Table data is NULL");
        tableData = tabledata;
        setColumnDataCount(tabledata.getColumnCount());
        sortedList = new int[tabledata.getRowCount()];
        for(int i = 0; i < sortedList.length; i++)
            sortedList[i] = i;

        refilterTable();
        autoRepaint();
    }

    public TableData getTableData()
    {
        return tableData;
    }

    private int[] createLargerArray(int ai[], int i)
    {
        if(ai != null)
        {
            int j = Math.max(100, Math.min(10, ai.length));
            int ai1[] = new int[ai.length + j];
            System.arraycopy(ai, 0, ai1, 0, ai.length);
            for(int l = ai.length; l < ai1.length; l++)
                ai1[l] = i;

            return ai1;
        }
        ai = new int[10];
        for(int k = 0; k < ai.length; k++)
            ai[k] = i;

        return ai;
    }

    private boolean[] createLargerArray(boolean aflag[])
    {
        if(aflag != null)
        {
            int i = Math.max(100, Math.min(10, aflag.length));
            boolean aflag1[] = new boolean[aflag.length + i];
            System.arraycopy(aflag, 0, aflag1, 0, aflag.length);
            return aflag1;
        } else
        {
            return new boolean[10];
        }
    }

    private Color[] createLargerArray(Color acolor[])
    {
        if(acolor != null)
        {
            int i = Math.max(100, Math.min(10, acolor.length));
            Color acolor1[] = new Color[acolor.length + i];
            System.arraycopy(acolor, 0, acolor1, 0, acolor.length);
            return acolor1;
        } else
        {
            return new Color[10];
        }
    }

    public void setHeaderOn(boolean flag)
    {
        headerOn = flag;
        autoRepaint();
    }

    public void setFilterBarOn(boolean flag)
    {
        filterBarOn = flag;
        checkScrollBars();
        autoRepaint();
    }

    public void setLocale(Locale locale)
    {
        super.setLocale(locale);
        autoRepaint();
    }

    public void removeTableListener(TableListener tablelistener)
    {
        listeners.removeElement(tablelistener);
    }

    public void setColumnWidth(int i, int j)
    {
        if(i >= 0 && i < columnWidth.length)
        {
            j = Math.max(0, j);
            columnWidth[i] = j;
            adjustXpos();
            checkScrollBars();
            autoRepaint();
        }
    }

    public int getColumnWidth(int i)
    {
        if(i >= 0 && i < columnWidth.length)
            return (int)Math.round(columnWidth[i]);
        else
            return 0;
    }

    public void render(Graphics g)
    {
        if(tableData.hasChangedSince(lastPaintTime))
            calculateTotals();
        Dimension dimension = getSize();
        g.setClip(0, 0, dimension.width, dimension.height);
        g.setColor(defaultRowBackground);
        g.fillRect(0, 0, dimension.width, dimension.height);
        paintRows(g);
        if(gridOn)
            paintGrid(g);
        if(headerOn)
            paintHeader(g);
        if(filterBarOn)
            paintFilter(g);
        if(isTotalRowOn(-1))
            paintTotalRow(g);
        paintScrollBars(g);
        paintBorder(g);
        lastPaintTime = System.currentTimeMillis();
    }

    public void setCell(int i, int j, Object obj)
    {
        tableData.setCell(i, j, obj);
        autoRepaint();
    }

    public Object getCell(int i, int j)
    {
        return tableData.getCell(i, j);
    }

    public void gotoRowPosition(int i)
    {
        i = Math.max(i, 0);
        i = Math.min(i, displayRowCount);
        if(i != -1)
            if(i < firstRow)
                firstRow = i;
            else
            if(i >= firstRow + maxDisplayRowCount)
                firstRow = i - (maxDisplayRowCount - 1);
            else
                return;
        firstRow = Math.max(firstRow, 0);
        vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
        repaint();
    }

    public void setSortingOn(int i, boolean flag)
    {
        if(i >= 0 && i < sortingOn.length)
            sortingOn[i] = flag;
    }

    private void paintArrowButton(Graphics g, int i, int j, int k, int l, int i1, boolean flag)
    {
        g.setClip(i, j, k, l);
        paint3DBox(g, i, j, k, l, flag);
        int j1 = i + k / 2 + (flag ? 1 : 0);
        int k1 = j + l / 2 + (flag ? 1 : 0);
        g.setColor(Color.black);
        int ai[] = new int[3];
        int ai1[] = new int[3];
        switch(i1)
        {
        case 0: // '\0'
            ai[0] = j1 - l / 5 - 1;
            ai[1] = j1 + l / 5 + 1;
            ai[2] = j1;
            ai1[0] = k1 + l / 16 + 1;
            ai1[1] = k1 + l / 16 + 1;
            ai1[2] = k1 - l / 5 - 1;
            g.fillPolygon(ai, ai1, 3);
            break;

        case 1: // '\001'
            ai[0] = j1 - l / 5;
            ai[1] = j1 + l / 5 + 1;
            ai[2] = j1;
            ai1[0] = k1 - l / 16 - 1;
            ai1[1] = k1 - l / 16 - 1;
            ai1[2] = k1 + l / 5;
            g.fillPolygon(ai, ai1, 3);
            break;

        case 2: // '\002'
            g.drawLine(j1 - 2, k1, j1 - 2, k1);
            g.drawLine(j1 - 1, k1 - 1, j1 - 1, k1 + 1);
            g.drawLine(j1, k1 - 2, j1, k1 + 2);
            g.drawLine(j1 + 1, k1 - 3, j1 + 1, k1 + 3);
            break;

        case 3: // '\003'
            g.drawLine(j1 + 2, k1, j1 + 2, k1);
            g.drawLine(j1 + 1, k1 - 1, j1 + 1, k1 + 1);
            g.drawLine(j1, k1 - 2, j1, k1 + 2);
            g.drawLine(j1 - 1, k1 - 3, j1 - 1, k1 + 3);
            break;
        }
        Dimension dimension = getSize();
        g.setClip(0, 0, dimension.width, dimension.height);
    }

    public int setRow(int i, Object aobj[])
    {
        if(aobj != null && aobj.length > 0)
            return setRow(i, aobj[0], aobj);
        else
            return setRow(i, null, aobj);
    }

    public int setRow(int i, Object obj, Object aobj[])
    {
        int j = tableData.getRowCount();
        int k = tableData.setRow(i, obj, aobj);
        boolean flag = i < 0 || k >= j;
        if(k >= sortedList.length)
        {
            sortedList = createLargerArray(sortedList, -1);
            flag = true;
        }
        if(flag)
            sortedList[k] = k;
        if(flag && matchesFilter(aobj, columnFilter, filterPushed))
        {
            if(displayRowCount >= displayList.length)
                displayList = createLargerArray(displayList, -1);
            displayList[displayRowCount++] = k;
        }
        if(flag && getRowCount() > selectedRows.length)
        {
            selectedRows = createLargerArray(selectedRows);
            rowForeground = createLargerArray(rowForeground);
            rowBackground = createLargerArray(rowBackground);
        }
        checkScrollBars();
        autoRepaint();
        return k;
    }

    public Object[] getRow(int i)
    {
        if(i < 0 || i >= getRowCount())
            throw new IllegalArgumentException("Invalid row: " + i);
        else
            return tableData.getRow(i);
    }

    public void selectRow(int i, boolean flag)
    {
        if(i < 0 || i >= getRowCount())
            throw new IllegalArgumentException("Invalid row index: " + i);
        selectedRows[i] = flag;
        if(flag)
            lastSelectedRow = i;
        autoRepaint();
    }

    protected void processEvent(AWTEvent awtevent)
    {
        if(!isEnabled())
            return;
        if(awtevent instanceof MouseEvent)
            switch(awtevent.getID())
            {
            case 503:
                processMouseMoved((MouseEvent)awtevent);
                break;

            case 501:
                processMousePressed((MouseEvent)awtevent);
                break;

            case 506:
                processMouseDragged((MouseEvent)awtevent);
                break;

            case 502:
                processMouseReleased((MouseEvent)awtevent);
                break;
            }
        else
        if(awtevent instanceof KeyEvent)
            processKeys((KeyEvent)awtevent);
        else
        if(awtevent.getID() == 101)
        {
            adjustXpos();
            checkScrollBars();
            repaint();
        } else
        if(awtevent.getID() == 100 && TableEvent.evaluation)
            TableEvent.showEvaluation(this);
        super.processEvent(awtevent);
    }

    public void update(Graphics g)
    {
        paint(g);
    }

    private int get_field_seperator(int i)
    {
        int j = getColumnCount();
        for(int k = j - 1; k >= 0; k--)
            if(columnOn[k] && i > columnXpos[k] - offset - 3 && i < (columnXpos[k] - offset) + 2)
                return k;

        return -1;
    }

    public void setFilterWildCard(String s)
    {
        if(s != null && s.length() > 0)
            filterWildCard = s;
        else
            filterWildCard = null;
    }

    public String getFilterWildCard()
    {
        return filterWildCard;
    }

    public void setPrefix(int i, String s)
    {
        if(i >= 0 && i < columnPrefix.length)
        {
            columnPrefix[i] = s;
            autoRepaint();
        }
    }

    private String[] getStringValues(String s, String s1)
    {
        s1 = s1 != null ? s1 : ",";
        String as[] = null;
        if(s != null)
        {
            StringTokenizer stringtokenizer = new StringTokenizer(s, s1);
            as = new String[stringtokenizer.countTokens()];
            for(int i = 0; i < as.length; i++)
                as[i] = stringtokenizer.nextToken().trim();

        }
        return as;
    }

    public boolean isColumnStretchOn()
    {
        return columnStretchOn;
    }

    public String getPrefix(int i)
    {
        if(i >= 0 && i < columnPrefix.length)
            return columnPrefix[i];
        else
            return null;
    }

    public void setParameter(String s, String s1)
    {
        if(s == null)
            return;
        s = s.toLowerCase().trim();
        if(s.equals("columncount"))
            try
            {
                setColumnCount(Integer.parseInt(s1));
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid columnCount: " + s1);
            }
        else
        if(s.startsWith("row_"))
            try
            {
                int i = Integer.parseInt(s.substring(4));
                String as1[] = getStringValues(s1, fieldSeparator);
                setRow(i, as1);
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid row index: " + s);
            }
        else
        if(s.equals("header"))
        {
            if(s1 != null)
            {
                String as[] = getStringValues(s1, fieldSeparator);
                setHeader(as);
            }
        } else
        if(s.equals("headeroff"))
            setHeaderOn(s1 == null || !s1.trim().toLowerCase().equals("true"));
        else
        if(s.equals("columnwidth"))
        {
            if(s1 != null && s1.trim().length() > 0)
            {
                Long along[] = getLongValues(s1);
                if(along != null)
                {
                    int l2 = getColumnCount();
                    for(int j4 = 0; j4 < l2; j4++)
                        if(j4 < along.length && along[j4] != null)
                            setColumnWidth(j4, along[j4].intValue());
                        else
                            setColumnWidth(j4, 100);

                }
            }
        } else
        if(s.equals("columnstretchon"))
            setColumnStretchOn(s1 != null && s1.trim().toLowerCase().equals("true"));
        else
        if(s.equals("filterbaron"))
            setFilterBarOn(s1 != null && s1.trim().toLowerCase().equals("true"));
        else
        if(s.equals("progressivefilteron"))
            setProgressiveFilterOn(s1 != null && s1.trim().toLowerCase().equals("true"));
        else
        if(s.equals("filterwildcard"))
            setFilterWildCard(s1);
        else
        if(s.equals("totalrowon"))
        {
            s1 = s1 == null ? "" : s1.trim().toLowerCase();
            if(s1.equals("true"))
            {
                setTotalRowOn(-1, true);
            } else
            {
                for(int j = 0; j < totalRowOn.length; j++)
                    totalRowOn[j] = false;

                Long along1[] = getLongValues(s1);
                if(along1 != null)
                {
                    for(int i3 = 0; i3 < along1.length; i3++)
                        if(along1[i3] != null)
                        {
                            int k4 = (int)along1[i3].longValue();
                            if(k4 >= 0 && k4 < totalRowOn.length)
                                totalRowOn[k4] = true;
                        }

                }
            }
        } else
        if(s.equals("selectionmode"))
        {
            setSelectionMode(0);
            if(s1 != null && s1.length() > 0)
                if(s1.trim().toLowerCase().equals("single"))
                    setSelectionMode(1);
                else
                if(s1.trim().toLowerCase().equals("multiple"))
                    setSelectionMode(2);
        } else
        if(s.equals("columnalignment"))
        {
            int k = getColumnCount();
            if(s1 != null && s1.trim().length() > 0)
            {
                String as2[] = getStringValues(s1, ",");
                for(int l4 = 0; l4 < k; l4++)
                {
                    setColumnAlignment(l4, 0);
                    if(l4 < as2.length && as2[l4] != null)
                        if(as2[l4].toLowerCase().equals("center"))
                            setColumnAlignment(l4, 1);
                        else
                        if(as2[l4].toLowerCase().equals("right"))
                            setColumnAlignment(l4, 2);
                }

            } else
            {
                for(int j3 = 0; j3 < k; j3++)
                    setColumnAlignment(j3, 0);

            }
        } else
        if(s.equals("columntype"))
        {
            int l = getColumnCount();
            for(int k3 = 0; k3 < l; k3++)
                setColumnType(k3, 0);

            if(s1 != null && s1.trim().length() > 0)
            {
                String as3[] = getStringValues(s1, ",");
                for(int i5 = 0; i5 < l; i5++)
                    if(i5 < as3.length && as3[i5] != null && as3[i5].toLowerCase().equals("number"))
                        setColumnType(i5, 1);
                    else
                    if(i5 < as3.length && as3[i5] != null && as3[i5].toLowerCase().equals("currency"))
                        setColumnType(i5, 2);

            }
        } else
        if(s.equals("rowforeground"))
        {
            setRowForeground(-1, getForeground());
            if(s1 != null && s1.trim().length() > 0)
            {
                Color color = createColor(s1);
                if(color != null)
                    setRowForeground(-1, color);
            }
        } else
        if(s.startsWith("rowforeground_"))
            try
            {
                int i1 = Integer.parseInt(s.substring(14));
                setRowForeground(i1, createColor(s1));
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid row index: " + s);
            }
        else
        if(s.equals("rowbackground"))
        {
            setRowBackground(-1, Color.white);
            if(s1 != null && s1.trim().length() > 0)
            {
                Color color1 = createColor(s1);
                if(color1 != null)
                    setRowBackground(-1, color1);
            }
        } else
        if(s.startsWith("rowbackground_"))
            try
            {
                int j1 = Integer.parseInt(s.substring(14));
                setRowBackground(j1, createColor(s1));
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid row index: " + s);
            }
        else
        if(s.equals("foreground"))
        {
            if(s1 != null && s1.trim().length() > 0)
            {
                Color color2 = createColor(s1);
                if(color2 != null)
                    setForeground(color2);
            }
        } else
        if(s.equals("background"))
        {
            if(s1 != null && s1.trim().length() > 0)
            {
                Color color3 = createColor(s1);
                if(color3 != null)
                    setBackground(color3);
            }
        } else
        if(s.startsWith("prefix_"))
            try
            {
                int k1 = Integer.parseInt(s.substring(7));
                setPrefix(k1, s1);
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid prefix column index: " + s);
            }
        else
        if(s.startsWith("postfix_"))
            try
            {
                int l1 = Integer.parseInt(s.substring(8));
                setPostfix(l1, s1);
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid prefix column index: " + s);
            }
        else
        if(s.startsWith("decimalcount_"))
        {
            int i2 = 0;
            try
            {
                i2 = Integer.parseInt(s.substring(13));
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid prefix column index: " + s);
            }
            catch(IllegalArgumentException _ex)
            {
                System.out.println("Invalid prefix column index: " + s);
            }
            try
            {
                int l3 = Integer.parseInt(s1);
                setDecimalCount(i2, l3);
            }
            catch(NumberFormatException _ex)
            {
                System.out.println("Invalid decimal count: " + s1);
            }
        } else
        if(s.equals("sortingoff"))
        {
            s1 = s1 == null ? "" : s1.trim().toLowerCase();
            if(s1.equals("true"))
            {
                for(int j2 = 0; j2 < sortingOn.length; j2++)
                    sortingOn[j2] = false;

            } else
            {
                for(int k2 = 0; k2 < sortingOn.length; k2++)
                    sortingOn[k2] = true;

                Long along2[] = getLongValues(s1);
                if(along2 != null)
                {
                    for(int i4 = 0; i4 < along2.length; i4++)
                        if(along2[i4] != null)
                        {
                            int j5 = (int)along2[i4].longValue();
                            if(j5 >= 0 && j5 < sortingOn.length)
                                sortingOn[j5] = false;
                        }

                }
            }
        } else
        if(s.equals("gridon"))
            setGridOn(s1 != null && s1.trim().toLowerCase().equals("true"));
        else
        if(s.equals("gridcolor"))
            setGridColor(createColor(s1));
        else
        if(s.startsWith("url_"))
        {
            s = s.substring(4);
            urlList.remove(s);
            if(s1 != null)
            {
                URL url = createURL(s1);
                if(url != null)
                    urlList.put(s, url);
            }
        } else
        if(s.equals("urlcolor"))
            urlColor = createColor(s1);
        else
        if(s.equals("urltarget"))
            urlTargetList.put("default", s1 == null ? "_self" : ((Object) (s1)));
        else
        if(s.startsWith("urltarget_"))
        {
            s = s.substring(10);
            urlTargetList.remove(s);
            if(s1 != null)
                urlTargetList.put(s, s1);
        } else
        if(s.equals("fieldseparator"))
        {
            fieldSeparator = ",";
            if(s1 != null && s1.length() == 1)
                fieldSeparator = s1;
        } else
        if(s.equals("locale"))
        {
            if(s1 != null && s1.trim().length() > 0)
            {
                StringTokenizer stringtokenizer = new StringTokenizer(s1, ", ");
                String s2 = stringtokenizer.nextToken();
                String s3 = s2;
                if(stringtokenizer.hasMoreElements())
                    s3 = stringtokenizer.nextToken();
                setLocale(new Locale(s2.toUpperCase(), s3.toUpperCase()));
            } else
            {
                setLocale(null);
            }
        } else
        {
            System.out.println("invalid parameter: <param name=" + s + " value=" + s1 + ">");
        }
    }

    private boolean matchesFilter(Object aobj[], String as[], boolean aflag[])
    {
        if(aobj == null || as == null || aflag == null)
            return true;
        for(int i = 0; i < aobj.length; i++)
        {
            String s = "";
            if(aobj[i] instanceof String)
                s = ((String)aobj[i]).toLowerCase();
            if(i < aflag.length && aflag[i] && (i < as.length && as[i] != null && !as[i].equals("") && !as[i].equals(filterWildCard)))
                if(filterWildCard != null && as[i].startsWith(filterWildCard) && as[i].endsWith(filterWildCard))
                {
                    String s1 = as[i].toLowerCase().substring(1, as[i].length() - 1);
                    int j = s.indexOf(s1);
                    if(j == -1)
                        return false;
                } else
                if(as[i].endsWith("<>"))
                {
                    String s2 = as[i].toLowerCase().substring(0, as[i].length() - 2);
                    int k = s.compareTo(s2);
                    if(k == 0)
                        return false;
                } else
                if(as[i].endsWith(">"))
                {
                    String s3 = as[i].toLowerCase().substring(0, as[i].length() - 1);
                    if(columnType[i] == 0)
                    {
                        int l = s.compareTo(s3);
                        if(l < 0 || l == 0)
                            return false;
                    } else
                    {
                        try
                        {
                            double d = (new Double(s.trim())).doubleValue();
                            double d4 = (new Double(s3)).doubleValue();
                            if(d <= d4)
                                return false;
                        }
                        catch(NumberFormatException _ex)
                        {
                            return false;
                        }
                    }
                } else
                if(as[i].endsWith(">="))
                {
                    String s4 = as[i].toLowerCase().substring(0, as[i].length() - 2);
                    if(columnType[i] == 0)
                    {
                        int i1 = s.compareTo(s4);
                        if(i1 < 0)
                            return false;
                    } else
                    {
                        try
                        {
                            double d1 = (new Double(s.trim())).doubleValue();
                            double d5 = (new Double(s4)).doubleValue();
                            if(d1 < d5)
                                return false;
                        }
                        catch(NumberFormatException _ex)
                        {
                            return false;
                        }
                    }
                } else
                if(as[i].endsWith("<"))
                {
                    String s5 = as[i].toLowerCase().substring(0, as[i].length() - 1);
                    if(columnType[i] == 0)
                    {
                        int j1 = s.compareTo(s5);
                        if(j1 > 0 || j1 == 0)
                            return false;
                    } else
                    {
                        try
                        {
                            double d2 = (new Double(s.trim())).doubleValue();
                            double d6 = (new Double(s5)).doubleValue();
                            if(d2 >= d6)
                                return false;
                        }
                        catch(NumberFormatException _ex)
                        {
                            return false;
                        }
                    }
                } else
                if(as[i].endsWith("<="))
                {
                    String s6 = as[i].toLowerCase().substring(0, as[i].length() - 2);
                    if(columnType[i] == 0)
                    {
                        int k1 = s.compareTo(s6);
                        if(k1 > 0)
                            return false;
                    } else
                    {
                        try
                        {
                            double d3 = (new Double(s.trim())).doubleValue();
                            double d7 = (new Double(s6)).doubleValue();
                            if(d3 > d7)
                                return false;
                        }
                        catch(NumberFormatException _ex)
                        {
                            return false;
                        }
                    }
                } else
                if(filterWildCard == null || as[i].endsWith(filterWildCard))
                {
                    String s7 = as[i].toLowerCase();
                    if(filterWildCard != null)
                        s7 = s7.substring(0, s7.length() - 1);
                    if(!s.startsWith(s7))
                        return false;
                } else
                if(as[i].startsWith(filterWildCard))
                {
                    String s8 = as[i].toLowerCase().substring(1, as[i].length());
                    if(!s.endsWith(s8))
                        return false;
                } else
                if(!as[i].toLowerCase().equals(s))
                    return false;
        }

        return true;
    }

    private Long[] getLongValues(String s)
    {
        Long along[] = null;
        if(s != null && s.length() > 0)
        {
            StringTokenizer stringtokenizer = new StringTokenizer(s, ",");
            along = new Long[stringtokenizer.countTokens()];
            for(int i = 0; i < along.length; i++)
                try
                {
                    along[i] = new Long(stringtokenizer.nextToken().trim());
                }
                catch(NumberFormatException _ex)
                {
                    along[i] = null;
                }

        }
        return along;
    }

    private void adjustHorizontalScrollbar(MouseEvent mouseevent)
    {
        int i = mouseevent.getX();
        int j = i - hSliderAdjustPos;
        hSliderPos += j;
        hSliderPos = Math.max(hSliderPos, 18);
        hSliderPos = Math.min(hSliderPos, ((17 + hSliderSpace) - hSliderSize) + 1);
        int k = 30 + hSliderSpace;
        int l = hSliderPos - 2 - 15 - 1;
        offset = (int)Math.round((double)(l * (columnXpos[columnXpos.length - 1] - k - 3)) / (double)(hSliderSpace - hSliderSize));
        hSliderAdjustPos = i;
        repaint();
    }

    private void processMouseReleased(MouseEvent mouseevent)
    {
        int i = mouseevent.getX();
        int j = mouseevent.getY();
        int k = get_field(i);
        if(selectedHeader >= 0 && selectedHeader < headerPushed.length && sortingOn[selectedHeader] && headerPushed[selectedHeader])
        {
            headerPushed[selectedHeader] = false;
            int l = getHeaderHeight();
            if(!adjusting && j < l + 2 && k == selectedHeader && headerOn)
                if(selectedHeader == lastSortedColumn && isFlipped)
                {
                    sortColumn(selectedHeader, 1);
                    isFlipped = false;
                } else
                {
                    sortColumn(selectedHeader, 0);
                    isFlipped = true;
                }
        }
        Dimension dimension = getSize();
        int i1 = getHeaderHeight();
        int j1 = dimension.height - 2;
        j1 -= filterBarOn ? getFilterHeight() : 0;
        j1 -= hScrollbarOn ? 15 : 0;
        j1 -= isTotalRowOn(-1) ? getTotalRowHeight() : 0;
        int k1 = getFontMetrics(getFont()).getHeight();
        int l1 = (j - getHeaderHeight() - 2) / (k1 + 1) + firstRow;
        int i2 = -1;
        if(j >= i1 && j <= j1 && l1 >= 0 && l1 < displayRowCount)
            i2 = displayList[l1];
        if(i2 >= 0 && i2 == clickedRow && k == clickedCell)
        {
            URL url = getURL(i2, k);
            if(url != null && applet != null)
            {
                String s = getURLTarget(i2, k);
                applet.showDocument(url, s);
            }
        }
        if(thread != null && threadType != 0)
        {
            thread.stop();
            thread = null;
            cursorOn = false;
        }
        adjusting = false;
        upButtonPushed = false;
        downButtonPushed = false;
        leftButtonPushed = false;
        aboveSliderPushed = false;
        belowSliderPushed = false;
        rightButtonPushed = false;
        leftToSliderPushed = false;
        rightToSliderPushed = false;
        vSliderAdjusting = false;
        hSliderAdjusting = false;
        repaint();
    }

    private void refilterTable()
    {
        displayRowCount = 0;
        int i = getRowCount();
        int ai[] = new int[i];
        for(int j = 0; j < i; j++)
        {
            Object aobj[] = getRow(sortedList[j]);
            if(matchesFilter(aobj, columnFilter, filterPushed))
                ai[displayRowCount++] = sortedList[j];
        }

        displayList = new int[displayRowCount];
        System.arraycopy(ai, 0, displayList, 0, displayList.length);
        checkScrollBars();
        calculateTotals();
    }

    public void removeAll()
    {
        tableData.removeAll();
        lastSelectedRow = -1;
        lastSelectedCell = -1;
        sortedList = new int[10];
        selectedRows = new boolean[10];
        rowForeground = new Color[10];
        rowBackground = new Color[10];
        refilterTable();
        autoRepaint();
    }

    public void setHeader(String as[])
    {
        for(int i = 0; i < headerLabels.length; i++)
            if(as != null && i < as.length)
                headerLabels[i] = as[i];
            else
                headerLabels[i] = null;

        autoRepaint();
    }

    public String[] getHeader()
    {
        return headerLabels;
    }

    public boolean isAutomaticRepaintOn()
    {
        return automaticRepaintOn;
    }

    private int getFilterHeight()
    {
        return !filterBarOn ? 0 : 17;
    }

    private void handleVerticalScrollbar(MouseEvent mouseevent)
    {
        int i = mouseevent.getY();
        int j = getHeaderHeight();
        int k = j + 15 + vSliderSpace + 15;
        if(i > vScrollerTop && i < vScrollerTop + upButtonHeight)
        {
            upButtonPushed = true;
            if(firstRow > 0)
            {
                firstRow--;
                vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                startScrollerThread(3);
            }
        } else
        if(i > k - downButtonHeight && i < k)
        {
            downButtonPushed = true;
            if(displayRowCount - firstRow > maxDisplayRowCount)
            {
                firstRow++;
                vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
                startScrollerThread(4);
            }
        } else
        if(i < vSliderPos && i >= vScrollerTop + upButtonHeight)
        {
            aboveSliderPushed = true;
            firstRow -= maxDisplayRowCount;
            firstRow = Math.max(firstRow, 0);
            vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
            scrollByPageToY = i;
            startScrollerThread(7);
        } else
        if(i >= vSliderPos + vSliderSize && i < vScrollerTop + upButtonHeight + vSliderSpace + 1)
        {
            belowSliderPushed = true;
            firstRow += maxDisplayRowCount;
            firstRow = Math.min(firstRow, displayRowCount - maxDisplayRowCount);
            vSliderPos = vScrollerTop + 1 + 15 + (int)Math.round(((double)firstRow / (double)(displayRowCount - maxDisplayRowCount)) * (double)(vSliderSpace - vSliderSize - 2));
            scrollByPageToY = i;
            startScrollerThread(8);
        } else
        if(i > vSliderPos && i < vSliderPos + vSliderSize)
        {
            vSliderAdjusting = true;
            vSliderAdjustPos = i;
        }
    }

    public int getLastSelectedRow()
    {
        return lastSelectedRow;
    }

    public int getRowCount()
    {
        return tableData.getRowCount();
    }

    public int getFilteredRowCount()
    {
        return displayRowCount;
    }

    public void setRowBackground(int i, Color color)
    {
        if(i > -1 && i < rowBackground.length)
            rowBackground[i] = color;
        else
            defaultRowBackground = color == null ? Color.white : color;
        autoRepaint();
    }

    public Color getRowBackground(int i)
    {
        if(i > -1 && i < rowBackground.length && rowBackground[i] != null)
            return rowBackground[i];
        else
            return defaultRowBackground;
    }

    public void setGridOn(boolean flag)
    {
        gridOn = flag;
        autoRepaint();
    }

    private void setFilterBarFields(Object aobj[])
    {
        for(int i = 0; i < columnFilter.length; i++)
            if(aobj != null && i < aobj.length && (aobj[i] instanceof String))
                columnFilter[i] = aobj[i] == null ? null : ((String)aobj[i]).trim();
            else
                columnFilter[i] = null;

        autoRepaint();
    }

    private int paintFieldLabel(Graphics g, String s, int i, int j, boolean flag)
    {
        if(g == null)
            if(j > 0 && j < columnXpos.length)
                return columnXpos[j - 1] - offset;
            else
                return 2 - offset;
        Dimension dimension = getSize();
        FontMetrics fontmetrics = g.getFontMetrics();
        s = s == null ? "" : s;
        int k = fontmetrics.stringWidth(s);
        int l = (j <= 0 ? 3 : columnXpos[j - 1]) - offset;
        int i1 = j <= 0 ? columnXpos[0] - 2 - 1 : columnXpos[j] - columnXpos[j - 1];
        switch(columnAlignment[j])
        {
        default:
            break;

        case 0: // '\0'
            l += 3;
            break;

        case 2: // '\002'
            if(visibleColumnCount > 1)
                l = Math.max(columnXpos[j] - offset - k - 2, l + 3);
            else
                l = dimension.width - k - 2 - 2;
            break;

        case 1: // '\001'
            int j1 = visibleColumnCount <= 1 ? dimension.width / 2 : l + i1 / 2;
            l = Math.max(j1 - k / 2, l + 3);
            break;
        }
        l += flag ? 1 : 0;
        if(visibleColumnCount > 1)
            g.setClip(l, 0, i1 - 6, dimension.height);
        int k1 = fontmetrics.getHeight();
        if(isEnabled())
        {
            g.drawString(s, l, (i - 1) + k1 + (flag ? 1 : 0));
        } else
        {
            g.setColor(getBackground().brighter());
            g.drawString(s, l + 1, (i - 1) + k1 + (flag ? 1 : 0) + 1);
            g.setColor(Color.black);
            g.drawString(s, l, (i - 1) + k1 + (flag ? 1 : 0));
        }
        return l;
    }

    public void setSelectionMode(int i)
    {
        if(i != 0 && i != 1 && i != 2)
        {
            throw new IllegalArgumentException("Invalid selection mode");
        } else
        {
            selectionMode = i;
            return;
        }
    }

    public int getSelectionMode()
    {
        return selectionMode;
    }

    public int[] getDisplayedRows()
    {
        int ai[] = new int[displayRowCount];
        System.arraycopy(displayList, 0, ai, 0, displayRowCount);
        return ai;
    }

    private void qsort(int ai[], int i, int j, int k)
    {
        int l = i;
        int i1 = j;
        if(j > i)
        {
            int j1 = ai[(i + j) / 2];
            while(l <= i1)
            {
                while(l < j && compare(ai[l], j1, k, columnType[k]) == -1)
                    l++;
                for(; i1 > i && compare(ai[i1], j1, k, columnType[k]) == 1; i1--);
                if(l <= i1)
                {
                    int k1 = ai[l];
                    ai[l] = ai[i1];
                    ai[i1] = k1;
                    l++;
                    i1--;
                }
            }
            if(i < i1)
                qsort(ai, i, i1, k);
            if(l < j)
                qsort(ai, l, j, k);
        }
    }

    public void setProgressiveFilterOn(boolean flag)
    {
        progressiveFilterOn = flag;
    }

    public void setPreferredSize(int i, int j)
    {
        preferredSize = new Dimension(i, j);
        autoRepaint();
    }

    public Dimension getPreferredSize()
    {
        return new Dimension(preferredSize);
    }

    private void paintScrollBars(Graphics g)
    {
        Dimension dimension = getSize();
        int i = getHeaderHeight();
        g.setClip(0, 0, dimension.width, dimension.height);
        if(vScrollbarOn)
        {
            byte byte0 = 15;
            int j = dimension.height - i - 4 - 1;
            if(hScrollbarOn)
                j -= byte0;
            int l = dimension.width - 2 - byte0;
            int i1 = 2 + i + 1;
            g.setColor(getBackground().darker());
            g.fillRect(l, i1, byte0, dimension.height);
            if(vSliderSpace > 3)
            {
                upButtonHeight = 15;
                downButtonHeight = 15;
            } else
            {
                upButtonHeight = (j - 1) / 2;
                downButtonHeight = j - upButtonHeight - 1;
            }
            paintArrowButton(g, l, i1, byte0, upButtonHeight, 0, upButtonPushed);
            paintArrowButton(g, l, (i1 + j) - downButtonHeight, byte0, downButtonHeight, 1, downButtonPushed);
            if(vSliderSpace - 2 > vSliderSize)
                paint3DBox(g, l, vSliderPos, byte0, vSliderSize, false);
        }
        if(hScrollbarOn)
        {
            byte byte1 = 15;
            int k = dimension.width - 4 - 1;
            if(vScrollbarOn)
                k -= byte1;
            byte byte2 = 3;
            int j1 = dimension.height - byte1 - 2;
            g.setColor(getBackground().darker());
            g.fillRect(byte2 + 15, j1, hSliderSpace, byte1);
            paintArrowButton(g, byte2, j1, byte1, byte1, 2, leftButtonPushed);
            paintArrowButton(g, (byte2 + k) - byte1, j1, byte1, byte1, 3, rightButtonPushed);
            if(hSliderSpace - 2 > hSliderSize)
                paint3DBox(g, hSliderPos, j1, hSliderSize, 15, false);
        }
    }

    private void notifyListeners(Object aobj[], int i, int j, int k, int l)
    {
        TableEvent tableevent = new TableEvent(this, aobj, i, j, k, l);
        for(Enumeration enumeration = listeners.elements(); enumeration.hasMoreElements(); ((TableListener)enumeration.nextElement()).tableSelection(tableevent));
    }

    static
    {
        TableEvent.version = getVersion();
    }
}
