Remove row being edited from JTable

I have a JTable and a button next to it that calls deleteSelectedRows(), which does exactly what it sounds like:

public void deleteSelectedRows() {
    int[] selected = jTable.getSelectedRows();
    for(int i = selected.length - 1; i >= 0; i--) {
        model.removeRow(selected[i]);
    }
    if(model.getRowCount() < 1) {
        addEmptyRow();
    }
}

But if a cell was in the act of being edited when it (and/or cells above it) were deleted, the edited cell stayed while the rest left, like this:

And then trying to exit out of the editing threw an ArrayIndexOutOfBoundsException since row 5 was trying to be accessed and there was only one row left in the table.

I then tried all sorts of fun and games with jTable.getEditingRow(). At first, adding an if(selected[i] != editing) before the removal seemed to work, but then removing rows above the edited cell caused problems.

Then I tried this:

public void deleteSelectedRows() {
    int[] selected = jTable.getSelectedRows();
    int editing = jTable.getEditingRow();
    for(int s : selected) { //PS: Is there a better way of doing a linear search?
        if(s == editing) {
            return;
        }
    }
    for(int i = selected.length - 1; i >= 0; i--) {
        model.removeRow(selected[i]);
    }
    if(model.getRowCount() < 1) {
        addEmptyRow();
    }
}

But that doesn't delete anything, ever. Judging from printlns I sprinkled around, the last cell to be highlighted (that has the special border seen here on spam) is considered part of the editing row, and thus triggers my early return.

So I don't really care开发者_JAVA技巧 whether the solution involves fixing the original problem--that of the wacky results when a cell being edited is deleted--or this new problem--that of getEditingRow() not behaving as I expected, it's just that I need at least one of those to happen. That said, I would be interested to hear both solutions just out of academic curiosity. Thanks in advance.

Try to include the following lines before removing any rows from your model:

if (table.isEditing()) {
    table.getCellEditor().stopCellEditing();
}

As Howard stated, it is necessary to stop the cell editing before modifying the model. But it is also necessary to check if the cell is actually being modified to avoid null pointer exceptions. This is because the getCellEditor() method will return null if the table isn't being edited at the moment:

if (myTable.isEditing()) // Only if it's is being edited
         myTable.getCellEditor().stopCellEditing();
    ...

there are cases where the cell editor may refuse to stop editing, that can happen i.e. if you are using some complex editor that is waiting for user input on a dialog. In that case you should add an extra check:

if (myTable.isEditing()) 
   if (!myTable.getCellEditor().stopCellEditing()) {

     // If your update is user-generated:
     JOptionPane.showMessageDialog(null, "Please complete cell edition first.");

     // Either way return without doing the update.
     return;
   }

In your code, you are trying to delete only the rows that are not being edited, but that would also throw an ArrayOutOfBounds Exception when the cell editor stops editing. The best is to stop it before the refresh.

Finally, there seems to be also a property you can set in your table:

 table.putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);

as explained here.

Whilst stopping any and all cells from editing before applying any changes works, it's a bit like using a sledge hammer to crack a nut. What happens, for example, if the cell that is editing is not the one being deleted? This is the next problem you'll encounter. For that reason and others there is a better way. Firstly, use the framework to do the heavy lifting for you. Attach a TableModelListener to your table model table.getModel().addTableModelListener()... then in your listeners implementation catch the delete event and process as follows:

/**
 * Implements {@link TableModelListener}. This fine grain notification tells listeners
 * the exact range of cells, rows, or columns that changed.
 *
 * @param e the event, containing the location of the changed model.
 */
@Override
public void tableChanged(TableModelEvent e) {

    if (TableModelEvent.DELETE == e.getType()) {
        // If the cell or cells beng edited are within the range of the cells that have
        // been been changed, as declared in the table event, then editing must either
        // be cancelled or stopped.
        if (table.isEditing()) {
            TableCellEditor editor = table.getDefaultEditor(ViewHolder.class);
            if (editor != null) {
                // the coordinate of the cell being edited.
                int editingColumn = table.getEditingColumn();
                int editingRow = table.getEditingRow();
                // the inclusive coordinates of the cells that have changed.
                int changedColumn = e.getColumn();
                int firstRowChanged = e.getFirstRow();
                int lastRowChanged = e.getLastRow();
                // true, if the cell being edited is in the range of cells changed
                boolean editingCellInRangeOfChangedCells =
                        (TableModelEvent.ALL_COLUMNS == changedColumn ||
                                changedColumn == editingColumn) &&
                                editingRow >= firstRowChanged &&
                                editingRow <= lastRowChanged;

                if (editingCellInRangeOfChangedCells) {
                    editor.cancelCellEditing();
                }
            }
        }
    }
}

In the example above I've assigned my own editor as the default editor for the table table.setDefaultRenderer(ViewHolder.class, new Renderer()); table.setDefaultEditor(ViewHolder.class, new Editor());.

Additionally instead of using a specific view I use a ViewHolder. The reason for this is to make the table generic in terms of the views it displays. Here is the generic ViewHolder.class:

/**
 * Holds the view in a table cell. It is used by both the {@link Renderer}
 * and {@link Editor} as a generic wrapper for the view.
 */
public static abstract class ViewHolder {

    private static final String TAG = "ViewHolder" + ": ";

    // the position (index) of the model data in the model list
    protected final int position;
    // the model
    protected Object model;
    // the view to be rendered
    protected final Component view;
    // the views controller
    protected final Object controller;

    /**
     * @param view     the view to be rendered
     * @param position the position (index) of the data
     */
    public ViewHolder(int position,
                      Object model,
                      Component view,
                      Object controller) {

        this.position = position;

        if (view == null) {
            throw new IllegalArgumentException("item view may not be null");
        }
        if (model == null) {
            throw new IllegalArgumentException("model may not be null");
        }

        this.controller = controller;
        this.model = model;
        this.view = view;
    }

Now, each time your renderer or editor is called, construct a ViewHolder class and pass in your view / controller / position etc, and you're done.

The important thing to note here is that you do not have to catch the delete or change event before it happens. You should, in fact, catch it after the model changes. Why? Well after a change you know what has changed, because the TableModelListener tells you, helping you determine as to what to do next.