cachetablepanel.java

自行开发的高缓存table

    }

    public void deleteIDFromAll(IDType idtype)
    {
        int i = searchIDFromIDList(idtype, idList);
        if(i != -1)
            deleteIDFromAll(i);
    }

    public void deleteIDFromAll(int i)
    {
        if(i >= 0 && i < idList.size())
        {
            idList.removeElementAt(i);
            cacheTable.currentItemIndex = current;
            setIDList(idList);
        }
    }

    public void deleteItem(IDType idtype)
    {
        int i = searchIDFromIDList(idtype, idList);
        if(i != -1)
            deleteItem(i);
    }

    public void deleteItem(int i)
    {
        if(i >= 0 && i < idList.size())
        {
            idList.removeElementAt(i);
            cacheTable.currentItemIndex = current;
            setIDList(idList);
        }
    }

    public void deleteItems(IDList idlist)
    {
        if(idlist == null || idlist.size() == 0)
            return;
        Object obj = null;
        for(int i = 0; i < idlist.size(); i++)
        {
            IDType idtype = (IDType)idlist.elementAt(i);
            int j = searchIDFromIDList(idtype, idList);
            if(j >= 0 && j < idList.size())
                idList.removeElementAt(j);
        }

        setIDList(idList);
    }

    public void addItem(IDType idtype)
    {
        if(idtype != null)
        {
            idList.addElement(idtype);
            cacheTable.currentItemIndex = current;
            setIDList(idList);
        }
    }

    public void insertItem(IDType idtype, int i)
    {
        if(idtype != null && i >= 0 && i < idList.size())
        {
            idList.insertElementAt(idtype, i);
            cacheTable.currentItemIndex = current;
            setIDList(idList);
        }
    }

    public int getCacheTableRowCount()
    {
        return cacheTable.getRowCount();
    }

    public boolean isCacheTableCellEditable(int i, int j)
    {
        return cacheTable.isCellEditable(0, i);
    }

    public int getSelectedIndex()
    {
        return selectedIndex;
    }

    public int[] getSelectedIndices()
    {
        return convertVctToArray(selectedRows);
    }

    private int[] convertVctToArray(Vector vector)
    {
        if(vector != null)
        {
            int ai[] = new int[vector.size()];
            for(int i = 0; i < ai.length; i++)
                ai[i] = ((Integer)vector.elementAt(i)).intValue();

            return ai;
        } else
        {
            int ai1[] = new int[1];
            ai1[0] = -1;
            return ai1;
        }
    }

    public IDType getSelectedItem()
    {
        return (IDType)idList.elementAt(selectedIndex);
    }

    public IDList getSelectedItems()
    {
        if(selectedIndex != -1)
        {
            int ai[] = convertVctToArray(selectedRows);
            IDList idlist = new IDList();
            for(int i = 0; i < ai.length; i++)
                idlist.add(idList.elementAt(ai[i]));

            return idlist;
        } else
        {
            return null;
        }
    }

    public int isItemInCurrentShownTable(IDType idtype)
    {
        int i = searchIDFromIDList(idtype, idList);
        if(i >= upEdge && i < lowEdge)
            return i - upEdge;
        else
            return -1;
    }

    public int getCurrentItemIndexInShowTable()
    {
        if(cacheTable == null || cacheTable.getRowCount() == 0)
            return -1;
        else
            return current / rowHeight - upEdge;
    }

    public void insertItemInCurrentShownTable(IDType idtype)
    {
        idList.insertElementAt(idtype, current / rowHeight);
        cachedIDList.insertElementAt(idtype, current / rowHeight - upEdge);
        lowEdge++;
        max = max + rowHeight;
        cacheScrlPane.getViewport().remove(cacheTable);
        cacheScrlPane.getViewport().add(cacheTable);
        setViewportPoint();
        if(selectedRows != null)
        {
            for(int i = 0; i < selectedRows.size(); i++)
            {
                Integer integer = (Integer)selectedRows.elementAt(i);
                if(integer.intValue() >= current / rowHeight)
                {
                    integer = new Integer(integer.intValue() + 1);
                    selectedRows.setElementAt(integer, i);
                }
            }

        }
        revalidate();
        repaint();
    }

    private void cacheTable_valueChanged(ListSelectionEvent listselectionevent)
    {
        if(selectedRows == null)
            return;
        if(!listselectionevent.getValueIsAdjusting() && !isSelectAll)
        {
            for(int i = 0; i < selectedRows.size(); i++)
            {
                int j = ((Integer)selectedRows.elementAt(i)).intValue();
                if(j >= idList.size())
                    selectedRows.removeElementAt(i);
            }

            if(selectedRows.size() <= 0)
                selectedIndex = -1;
            if(!ctrlPressed || !shiftPressed)
                if(ctrlPressed || shiftPressed)
                {
                    if(!iSetSelection)
                    {
                        int k = selectedRows.size();
                        for(int l = k; l > 0; l--)
                        {
                            int k1 = ((Integer)selectedRows.elementAt(l - 1)).intValue();
                            if(k1 >= upEdge && k1 < lowEdge)
                                selectedRows.removeElementAt(l - 1);
                        }

                    }
                    int ai[] = cacheTable.getSelectedRows();
                    for(int i1 = ai.length; i1 > 0; i1--)
                        if(!selectedRows.contains(new Integer(upEdge + ai[i1 - 1])))
                            selectedRows.add(new Integer(upEdge + ai[i1 - 1]));

                    if(selectedRows.size() > 0)
                    {
                        selectedRows.sort();
                        selectedIndex = ((Integer)selectedRows.elementAt(0)).intValue();
                    } else
                    {
                        selectedIndex = -1;
                    }
                } else
                if(!shiftPressed)
                {
                    selectedIndex = upEdge + cacheTable.getSelectedRow();
                    selectedRows.removeAllElements();
                    int ai1[] = cacheTable.getSelectedRows();
                    for(int j1 = 0; j1 < ai1.length; j1++)
                        selectedRows.add(new Integer(upEdge + ai1[j1]));

                }
        }
    }

    public boolean lessThan(Object obj, Object obj1)
    {
        return ((Integer)obj).intValue() < ((Integer)obj1).intValue();
    }

    public boolean lessThanOrEqual(Object obj, Object obj1)
    {
        return ((Integer)obj).intValue() <= ((Integer)obj1).intValue();
    }

    public void setSelectAll(boolean flag)
    {
        isSelectAll = flag;
        if(isSelectAll)
        {
            if(selectedRows == null)
                selectedRows = new SortVector(this);
            selectedRows.removeAllElements();
            addAllItems();
            if(cacheTable == null)
                return;
            cacheTable.selectAll();
        }
    }

    protected void addAllItems()
    {
        if(idList != null && idList.size() > 0)
        {
            int i = idList.size();
            for(int j = 0; j < i; j++)
                selectedRows.add(new Integer(j));

        }
    }

    public void dispose()
    {
        MemoryMgr.disposeMemory(this);
        disposeFields();
    }

    private void disposeFields()
    {
        long l = System.currentTimeMillis();
        try
        {
            Class class1 = getClass();
            Field afield[] = class1.getDeclaredFields();
            for(int i = 0; i < afield.length; i++)
                try
                {
                    int j = afield[i].getModifiers();
                    if(!Modifier.isFinal(j) && !Modifier.isStatic(j))
                        afield[i].set(this, null);
                }
                catch(IllegalAccessException illegalaccessexception) { }
                catch(Exception exception1) { }

        }
        catch(Exception exception) { }
        long l1 = System.currentTimeMillis();
        Trace.print(getClass().getName(), "disposeFields()", "  Time taken=" + (l1 - l) + " ms");
    }

    private RequestDataListener _listener;
    private int min;
    private int max;
    private int current;
    private int blockIncrement;
    private int unitIncrement;
    private int visibleAmount;
    private int rowHeight;
    public IDList idList;
    private IDList cachedIDList;
    private int cacheSize;
    private int upEdge;
    private int lowEdge;
    private int oldUp;
    private int oldLow;
    private int compPos;
    private int selectedIndex;
    private SortVector selectedRows;
    private int requestDataEvent;
    private boolean isInit;
    private boolean isProgramSetValue;
    private boolean needToReadData;
    private boolean ctrlPressed;
    private boolean shiftPressed;
    private boolean iSetSelection;
    private IDListTable cacheTable;
    private DefaultTableModel model;
    private int hValue;
    private JScrollPane cacheScrlPane;
    private JScrollBar cacheScrlBar;
    boolean isSelectAll;
    private boolean APressed;






}