java - DefaultTableCellRenderer 内 JTable 中的旧值

Question

我几周来一直在尝试通过使用 RGBtoHSV 更改背景颜色来使 JTable 中的 Cell 闪烁，我是能够使用我在网上搜索到的方法来刷新单行，但当涉及到多行时，它似乎不起作用。

我尝试创建自定义渲染器类，但仍然无法找到一种方法，让旧值与新值在旧值 < 新值时闪烁单元格。

我获取单元格的 oldValue 的所有尝试都失败了，因此它不在那里。我尝试过 TableCellListener，这是我使用 googlefu 找到的一个类，但我不知道如何将其实现到渲染器中，尽管将其实现到表中是成功的。

DefaultTableCellRenderer cTaxas = new DefaultTableCellRenderer() {

        Color gray = new Color(212, 212, 212);

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected,
                boolean hasFocus, int row, int column) {
            Component cellComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row,
                    column);

            if (table.getValueAt(row, column) != null && !isSelected && (row % 2) == 0) {
                cellComponent.setBackground(gray);
                cellComponent.setForeground(Color.BLACK);
            } else if (table.getValueAt(row, column) != null && !isSelected) {
                cellComponent.setBackground(Color.WHITE);
                cellComponent.setForeground(Color.BLACK);
            }

            return cellComponent;
        }

    };
    cTaxas.setHorizontalAlignment(SwingConstants.CENTER);

编辑:我正在尝试实现类似 TableCellListener.class 我在搜索时找到的东西，但在 DefaultCellRenderer 中。

public class TableCellListener implements PropertyChangeListener, Runnable {
private JTable table;
private Action action;

private int row;
private int column;
private Object oldValue;
private Object newValue;

/**
 * Create a TableCellListener.
 *
 * @param table
 *            the table to be monitored for data changes
 * @param action
 *            the Action to invoke when cell data is changed
 */
public TableCellListener(JTable table, Action action) {
    this.table = table;
    this.action = action;
    this.table.addPropertyChangeListener(this);
}

/**
 * Create a TableCellListener with a copy of all the data relevant to the
 * change of data for a given cell.
 *
 * @param row
 *            the row of the changed cell
 * @param column
 *            the column of the changed cell
 * @param oldValue
 *            the old data of the changed cell
 * @param newValue
 *            the new data of the changed cell
 */
private TableCellListener(JTable table, int row, int column, Object oldValue, Object newValue) {
    this.table = table;
    this.row = row;
    this.column = column;
    this.oldValue = oldValue;
    this.newValue = newValue;
}

/**
 * Get the column that was last edited
 *
 * @return the column that was edited
 */
public int getColumn() {
    return column;
}

/**
 * Get the new value in the cell
 *
 * @return the new value in the cell
 */
public Object getNewValue() {
    return newValue;
}

/**
 * Get the old value of the cell
 *
 * @return the old value of the cell
 */
public Object getOldValue() {
    return oldValue;
}

/**
 * Get the row that was last edited
 *
 * @return the row that was edited
 */
public int getRow() {
    return row;
}

/**
 * Get the table of the cell that was changed
 *
 * @return the table of the cell that was changed
 */
public JTable getTable() {
    return table;
}

//
// Implement the PropertyChangeListener interface
//
@Override
public void propertyChange(PropertyChangeEvent e) {
    // A cell has started/stopped editing

    if ("tableCellEditor".equals(e.getPropertyName())) {
        if (table.isEditing())
            processEditingStarted();
        else
            processEditingStopped();
    }
}

/*
 * Save information of the cell about to be edited
 */
private void processEditingStarted() {
    // The invokeLater is necessary because the editing row and editing
    // column of the table have not been set when the "tableCellEditor"
    // PropertyChangeEvent is fired.
    // This results in the "run" method being invoked

    SwingUtilities.invokeLater(this);
}

/*
 * See above.
 */
@Override
public void run() {
    row = table.convertRowIndexToModel(table.getEditingRow());
    column = table.convertColumnIndexToModel(table.getEditingColumn());
    oldValue = table.getModel().getValueAt(row, column);
    newValue = null;
}

/*
 * Update the Cell history when necessary
 */
private void processEditingStopped() {
    newValue = table.getModel().getValueAt(row, column);

    // The data has changed, invoke the supplied Action

    if (!newValue.equals(oldValue)) {
        // Make a copy of the data in case another cell starts editing
        // while processing this change

        TableCellListener tcl = new TableCellListener(getTable(), getRow(), getColumn(), getOldValue(),
                getNewValue());

        ActionEvent event = new ActionEvent(tcl, ActionEvent.ACTION_PERFORMED, "");
        action.actionPerformed(event);
    }
}

}

我在 JTable 中使用了 celllistener，如下所示:

Action action = new AbstractAction() {
public void actionPerformed(ActionEvent e)
{
    TableCellListener tcl = (TableCellListener)e.getSource();
    System.out.println("Row   : " + tcl.getRow());
    System.out.println("Column: " + tcl.getColumn());
    System.out.println("Old   : " + tcl.getOldValue());
    System.out.println("New   : " + tcl.getNewValue());
}
};
TableCellListener tcl = new TableCellListener(table, action);

我正在尝试让此类在 JTables 渲染器中工作，以便当旧值小于从数据库中提取的新值时，我可以刷新 Cell。

EDIT2:我希望有人能够阐明如何在渲染器中获取旧值或闪烁单元格表的不同方法。

Answer 1

您似乎有两个要求

1. 如何获取旧值
2. 但是当涉及多行时，它似乎不起作用。

不太确定它们之间的关系。您一次只能更改编辑器中的一个值，因此我认为您只需要一次闪烁一行的行颜色。

无论如何，这里有一些(十年)的旧代码，允许您指定多个单元格、行或列同时以不同的颜色闪烁。闪烁会一直持续，直到您自行停止为止。

所以我想您可以使用 TableCellListener 将新单元格/行添加到致盲渲染器。

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import javax.swing.Timer;
import javax.swing.*;
import javax.swing.table.*;

public class TableColor extends JFrame
{
    ColorRenderer colorRenderer;

    public TableColor()
    {
        String[] columnNames = {"Date", "String", "Integer", "Boolean"};
        Object[][] data =
        {
            {new Date(), "A", new Integer(1), new Boolean(true)},
            {new Date(), "B", new Integer(2), new Boolean(false)},
            {new Date(), "C", new Integer(3), new Boolean(true)},
            {new Date(), "D", new Integer(4), new Boolean(false)}
        };

        final DefaultTableModel model = new DefaultTableModel(data, columnNames);
        final JTable table = new JTable( model )
        {
            public Class getColumnClass(int column)
            {
                return getValueAt(0, column).getClass();
            }

            //  Apply background to existing renderer

            public Component prepareRenderer(
                TableCellRenderer renderer, int row, int column)
            {
                Component c = super.prepareRenderer(renderer, row, column);
                colorRenderer.setBackground(c, row, column);
                return c;
            }
        };
        table.setPreferredScrollableViewportSize(table.getPreferredSize());
        JScrollPane scrollPane = new JScrollPane( table );
        getContentPane().add( scrollPane );

        JButton button = new JButton( "Add Row" );
        button.addActionListener( new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
//              model.addRow( createRow() );
                model.setRowCount( model.getRowCount() + 1 );
                int row = table.getRowCount() - 1;
//              table.changeSelection(row, 0, false, false);
                table.requestFocusInWindow();
                colorRenderer.setRowColor(row, Color.YELLOW);
            }
        });
        getContentPane().add(button, BorderLayout.SOUTH);

        //  Create blinking color renderer

        colorRenderer = new ColorRenderer( table );
        colorRenderer.setCellColor(1, 1, Color.RED);
        colorRenderer.setRowColor(1, Color.GREEN);
        colorRenderer.setRowColor(3, Color.GREEN);
        colorRenderer.setColumnColor(1, Color.BLUE);
        colorRenderer.startBlinking(1000);
    }

    public static void main(String[] args)
    {
        TableColor frame = new TableColor();
        frame.setDefaultCloseOperation( EXIT_ON_CLOSE );
        frame.pack();
        frame.setVisible(true);
    }

    /*
    **  Color cell background
    */
    class ColorRenderer implements ActionListener
    {
        private JTable table;
        private AbstractTableModel model;
        private Map colors;
        private boolean isBlinking = true;
        private Timer timer;
        private Point location;

        public ColorRenderer(JTable table)
        {
            this.table = table;
            model = (AbstractTableModel)table.getModel();
            colors = new HashMap();
            location = new Point();
        }

        public void setBackground(Component c, int row, int column)
        {
            //  Don't override the background color of a selected cell

            if ( table.isCellSelected(row, column) ) return;

            //  The default render does not reset the background color
            //  that was set for the previous cell, so reset it here

            if (c instanceof DefaultTableCellRenderer)
            {
                c.setBackground( table.getBackground() );
            }

            //  Don't highlight this time

            if ( !isBlinking ) return;

            //  In case columns have been reordered, convert the column number

            column = table.convertColumnIndexToModel(column);

            //  Get cell color

            Object key = getKey(row, column);
            Object o = colors.get( key );

            if (o != null)
            {
                c.setBackground( (Color)o );
                return;
            }

            //  Get row color

            key = getKey(row, -1);
            o = colors.get( key );

            if (o != null)
            {
                c.setBackground( (Color)o );
                return;
            }

            //  Get column color

            key = getKey(-1, column);
            o = colors.get( key );

            if (o != null)
            {
                c.setBackground( (Color)o );
                return;
            }

        }

        public void setCellColor(int row, int column, Color color)
        {
            Point key = new Point(row, column);
            colors.put(key, color);
        }

        public void setColumnColor(int column, Color color)
        {
            setCellColor(-1, column, color);
        }

        public void setRowColor(int row, Color color)
        {
            setCellColor(row, -1, color);
        }

        private Object getKey(int row, int column)
        {
            location.x = row;
            location.y = column;
            return location;
        }

        public void startBlinking(int interval)
        {
            timer = new Timer(interval, this);
            timer.start();
        }

        public void stopBlinking()
        {
            timer.stop();
        }

        public void actionPerformed(ActionEvent e)
        {
            isBlinking = !isBlinking;

            Iterator it = colors.keySet().iterator();

            while ( it.hasNext() )
            {
                Point key = (Point)it.next();
                int row = key.x;
                int column = key.y;

                if (column == -1)
                {
                    model.fireTableRowsUpdated(row, row);
                }
                else if (row == -1)
                {
                    int rows = table.getRowCount();

                    for (int i = 0; i < rows; i++)
                    {
                        model.fireTableCellUpdated(i, column);
                    }
                }
                else
                {
                    model.fireTableCellUpdated(row, column);
                }
            }
        }
    }
}