JTable - Amener une cellule en mode Edit en appuyant sur Tab

C'est peut-être une solution triviale, mais je suis au bout du rouleau, donc j'espère que quelqu'un peut vous aider.

- Je utiliser un JTable qui a une coutume convertisseur et un éditeur personnalisé pour un ensemble de colonnes.
Le moteur de rendu utilise un composant JLabel et l'éditeur utilise un JSpinner composant.
Nos utilisateurs veulent être en mesure de saisir des valeurs dans une colonne, puis appuyez sur TAB ou ENTRÉE pour passer à la prochaine cellule modifiable dans le tableau.
Si je comprends bien, c'est le comportement par défaut pour un JTable.

Toutefois, cela ne semble pas fonctionner correctement pour moi. Jusqu'à ce que l'utilisateur clique sur la cellule, seul le JLabel est affiché.
Le JSpinner (c'est à dire CellEditor) s'affiche uniquement lorsqu'un utilisateur double-clique sur la cellule. Donc il semble que la cellule va en mode "modifier" uniquement sur MouseEvents, mais pas quand il a le focus.

Comment puis-je obtenir de la cellule pour aller dans le mode d'édition dès qu'il a le focus?

source d'informationauteur Luhar

  1. 4

    Vous pouvez le faire par programmation, il vous suffit d'écouter les événements de focus sur la cellule, sur l'accent et l'édition de permis, de commencer le montage.

    Plus sur ce fil et exemple

  2. 18

    Merci n00213f. Au fil et à l'exemple de votre post a été utile. Par la surcharge du changeSelection méthode dans JTable comme évoqué dans le fil, JTable vérifie si la cellule est modifiable à chaque fois que la sélection est modifiée. Si la cellule est modifiable, il va montrer le CellEditor et de transfert de l'accent à l'éditeur de composant.

    Pour être complet, voici ma solution:

      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();
            }
  };
  3. 2

    Voici un extrait de code que j'ai mis ensemble pour un projet sur lequel je travaillais. Le code a été testé et vérifié pour une table qui est non-modifiable cellules dans la première et la dernière colonne. La classe restreint surbrillance uniquement les cellules modifiables de la table. Il prend également en charge shift-tab pour tab dans le sens inverse.

    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);
}            
});                    
}

    }

    Et voici comment la classe est utilisé pour votre table:

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