JTable - Obtener una celda en el modo Editar al presionar Tab

Question

Esto posiblemente tiene una solución trivial, pero estoy al final de mi anclaje, así que espero que alguien pueda ayudar.

Uso una JTable que tiene un renderizador personalizado y un editor personalizado para un conjunto de columnas.
El procesador utiliza un componente JLabel y el editor utiliza un componente JSpinner.
Nuestros usuarios desean poder ingresar valores en una columna, y luego presionar TAB o ENTER para pasar a la siguiente celda editable en la tabla.
Si entiendo correctamente, este es el comportamiento predeterminado de una JTable.

Sin embargo, esto no parece funcionar correctamente para mí. Hasta que el usuario haga clic en la celda, solo se muestra JLabel.
El JSpinner (es decir, CellEditor) solo se muestra cuando un usuario hace doble clic en la celda. Entonces, parece que la celda va al modo "editar" solo en MouseEvents, pero no cuando tiene foco.

¿Cómo hago para que la celda pase al modo de edición tan pronto como tiene foco?

Answer 1

Puede lograr esto programáticamente, simplemente escuche los eventos de enfoque en la celda, en el enfoque y la edición permitidos, comience la edición.

Más información sobre este thread y example

Answer 2

Gracias n00213f. El hilo y el ejemplo de tu publicación fueron útiles. Al sobrecargar el método changeSelection en JTable como se insinúa en el hilo, JTable verifica si una celda es editable cada vez que se cambia la selección. Si la celda es editable, mostrará el CellEditor y transferirá el foco al componente editor.

Para completar, aquí está mi solución:

JTable myTable = new javax.swing.JTable() 
    { 
      public void changeSelection(final int row, final int column, boolean toggle, boolean extend) 
      { 
       super.changeSelection(row, column, toggle, extend); 
       myTable.editCellAt(row, column); 
       myTable.transferFocus(); 
      } 
    }; 

Answer 3

He aquí un fragmento de código que puse juntos por un proyecto en el que estaba trabajando. El código se ha probado y verificado para una tabla que tiene celdas no editables en la primera y la última columna. La clase restringe la tabulación solo a las celdas editables de la tabla. También es compatible con desplazamiento-tabulación a la pestaña en reversa.

public class JTableCellTabbing { 
/** 
* 
* Creates a new {@code JTableCellTabbing} object. 
* 
* 
*/ 
private JTableCellTabbing() {   
} 

/** 
* 
* Set Action Map for tabbing and shift-tabbing for the JTable 
* 
* 
* @param theTable - Jtable with NRows and MCols of cells 
* @param startRow - valid start row for tabbing [ 0 - (numRows-1) ] 
* @param numRows - Number of rows for tabbing 
* @param startCol - valid start col for tabbing [ 0 - (numCols-1) ] 
* @param numCols - Number of columns for tabbing 
*/ 
@SuppressWarnings("serial") 
static public void setTabMapping(final JTable theTable, final int startRow, final int numRows, final int startCol, final int numCols) { 
    if (theTable == null) { 
     throw new IllegalArgumentException("theTable is null"); 
    } 

    // Calculate last row and column for tabbing 
    final int endRow = startRow + (numRows - 1); 
    final int endCol = startCol + (numCols - 1); 

    // Check for valid range 
    if ((startRow > endRow) || (startCol > endCol)) { 
     throw new IllegalArgumentException("Table Size incorrect");    
    } 

    // Get Input and Action Map to set tabbing order on the JTable 
    InputMap im = theTable.getInputMap(JTable.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); 
    ActionMap am = theTable.getActionMap(); 

    // Get Tab Keystroke 
    KeyStroke tabKey = KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0);      
    am.put(im.get(tabKey), new AbstractAction() { 

     @Override 
     public void actionPerformed(ActionEvent e) { 
      int row = theTable.getSelectedRow(); 
      int col = theTable.getSelectedColumn(); 

      col++; 

      // Move to next row and left column 
      if (col > endCol) { 
       col = startCol; 
       row++; 
      } 

      // Move to top row 
      if (row > endRow) { 
       row = startRow; 
      } 

      // Move cell selection 
      theTable.changeSelection(row, col, false, false); 
     }    
    }); 

    // Get Shift tab Keystroke 
    KeyStroke shiftTab = 
     KeyStroke.getKeyStroke(KeyEvent.VK_TAB, java.awt.event.InputEvent.SHIFT_DOWN_MASK);      
    am.put(im.get(shiftTab), new AbstractAction() { 

     @Override 
     public void actionPerformed(ActionEvent e) { 
      int row = theTable.getSelectedRow(); 
      int col = theTable.getSelectedColumn(); 

      col--; 

      // Move to top right cell 
      if (col < startCol) { 
       col = endCol; 
       row--; 
      } 

      // Move to bottom row 
      if (row < startRow) { 
       row = endRow; 
      } 

      // Move cell selection 
      theTable.changeSelection(row, col, false, false); 
     }    
    });      
} 

}

Y aquí es cómo se utiliza la clase para su mesa:

JTable myTable = new JTable(); 
// Set up table attributes.... 
JTableCellTabbing.setTabMapping(myTable, 0, NUM_ROWS, 1, (NUM_COLS-1));