Iniziare la modifica in una cella JTable solo con chiavi ragionevoli

Question

Penso che il componente JTable dovrebbe fare un lavoro migliore di filtraggio delle chiavi che potrebbero iniziare a modificare. Voglio dire, con l'implementazione corrente, se digiti DEL, Ctrl + Shift + CANC, F5, F7, ad esempio, in una cella modificabile, apparirà l'editor di celle. Secondo me, avviare un editor di celle con chiavi come queste è molto poco intuitivo per l'utente finale.

Inoltre, c'è un altro problema: JTable non è a conoscenza degli altri possibili legami di chiave definiti nel modulo. Se hai una combinazione di tasti Ctrl + Maiusc + C definita per un pulsante nel modulo, se digiti questa combinazione di tasti in JTable, la tabella inizierà la modifica e la tua azione di associazione ai tasti dei pulsanti verrà richiamata successivamente. Penso che ci dovrebbe essere un modo semplice per prevenire questo invece di disabilitare tutti quelli già definiti nella mappatura delle associazioni di chiavi della tabella.

C'è qualche componente di terze parti che ha già risolto, almeno in parte, alcuni di questi problemi, in particolare quello per iniziare a modificare con una chiave ragionevole? Non mi piacerebbe fare tutto il noioso filtraggio me stesso.

Qualsiasi aiuto sarebbe apprezzato. Grazie.

Marcos

UPDATE

Per il momento sto usando questa "soluzione" altamente imperfetto, che almeno rende le cose meno peggio per il momento. Miglioramenti, commenti e suggerimenti sono apprezzati.

@Override 
    public boolean isCellEditable(EventObject e) 
    { 
     if (e instanceof MouseEvent) 
     { 
      return ((MouseEvent) e).getClickCount() >= 
       _delegate.getMouseClickCountToStartEditing(); 
     } 
     else if (e instanceof KeyEvent) 
     { 
      KeyEvent event = (KeyEvent) e; 

      int key = event.getKeyCode(); 
      if ((key >= KeyEvent.VK_F1 && key <= KeyEvent.VK_F12) && 
       KeyStroke.getKeyStrokeForEvent(event) != _startEditingKey) 
      { 
       return false; 
      } 

      int ctrlAlt = KeyEvent.CTRL_DOWN_MASK | KeyEvent.ALT_DOWN_MASK; 
      if ((event.getModifiersEx() & ctrlAlt) == ctrlAlt) 
      { 
       return true; 
      } 

      if ((event.getModifiersEx() & ctrlAlt) != 0) 
      { 
       return false; 
      } 

      return true; 
     } 
     else 
     { 
      // Is this else really needed? Are there other events types 
      // other than mouse and key events? 
      return true; 
     } 
    } 

    // _startEditingKey is obtained with this method 
    private KeyStroke getStartEditingKey() 
    { 
     InputMap bindings = TheTable.this.getInputMap(
      JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT); 
     for (KeyStroke key : bindings.allKeys()) 
     { 
      Object binding = bindings.get(key); 
      if ("startEditing".equals(binding)) 
      { 
       return KeyStroke.getKeyStroke(
        key.getKeyCode(), key.getModifiers(), true); 
      } 
     } 
     return null; 
    } 

Answer 1

È possibile associare qualsiasi tasto desiderato per startEditing l'azione del tavolo, come mostrato here e here. È possibile disabilitare le chiavi indesiderate, come mostrato here. Alcune sfumature aggiuntive sono mostrate here e l'articolo citato here da @camickr.

Answer 2

è possibile implementare un editor personalizzato che riporta di non essere modificabile se il KeyEvent ha modificatori che si desidera ignorare:

DefaultCellEditor editor = new DefaultCellEditor(new JTextField()) { 

    @Override 
    public boolean isCellEditable(EventObject e) { 
     if (e instanceof KeyEvent) { 
      return startWithKeyEvent((KeyEvent) e); 
     } 
     return super.isCellEditable(e); 
    } 

    private boolean startWithKeyEvent(KeyEvent e) { 
     // check modifiers as needed, this here is just a quick example ;-) 
     if ((e.getModifiersEx() & KeyEvent.CTRL_DOWN_MASK) != 0) { 
      return false; 
     }  
     // check for a list of function key strokes 
     if (excludes.contains(KeyStroke.getKeyStrokeForEvent(e)) { 
      return false; 
     } 
     return true; 
    } 

}; 
JTable table = new JTable(new AncientSwingTeam()); 
table.setDefaultEditor(Object.class, editor); 

Edit: per un filtraggio più affidabile in grado di gestire correttamente le combinazioni CTRL-ALT, potresti dare un'occhiata a DefaultEditorKit.DefaultKeyTypedAction: delegando sostanzialmente a un metodo nascosto in SunToolkit e gestendo keyTyped (vs keyPressed necessario per filtrare gli eventi che sono probabili candidati per un carattere stampabile valido dopo aver avviato la modifica) potrebbe ancora darti un'idea di come farlo (la fonte del suntoolkit è probabilmente disponibile in openjdk, non è stata cercata prima, però)