Discussion :

[Okwolus]

Bonjour à tous,

Je travaille sur un logiciel métier, ou j'utilise à un moment un JTable à remplir avec des Double pour y effectuer des calculs.
Mes cellules sont initialisées à 0.0 et lorsque je double-clique dans une cellule, le curseur se met à la fin du chiffre. ( 0.0| <- comme ça ), donc il faut soit supprimer à la touche Del, soit sélectionner le chiffre et supprimer.

Hors, pour plus de confort et de rapidité pour mes utilisateurs, j'aimerais que le chiffre soit de suite sélectionner au double-clique pour le supprimer immédiatement.
Faut-il le faire dans le Renderer ou dans le setValueAt/getValueAt ?

Merci pour vos réponses

[joel.drigo]

Salut,

tu peux faire ça dans le CellEditor, par exemple si tu utilises un DefaultCellEditor, tu le replaces par une classe qui étend DefaultCellEditor, et qui a pour constructeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
public class SelectAllCellEditor extends DefaultCellEditor
{
    public SelectAllCellEditor(final JTextField textField ) {
        super( textField );
        textField.addFocusListener( new FocusAdapter()
        {
            public void focusGained( final FocusEvent e )
            {
                textField.selectAll();
            }
        } );
    }
}

[Okwolus]

Bonjour et merci pour ta réponse!

Juste une dernière question : tu appliques la modif de classe à un Textfield, mais les données dans mes cellules sont des Double.

Donc si j'ai bien compris, la cellule se tranforme en Textfield de façon transparente au moment de l'édition?

[joel.drigo]

Par défaut, une JTable installe certains éditeurs par défaut. Mais on peut les remplacer, par l'une la méthode setDefaultEditor(class, editor), qui associe une classe avec une instance d'éditeur. Si tu ne fais pas ça, ça utilisera l'éditeur par défaut (une classe interne de JTable, appelée NumberEditor, qui utilise justement un JTextField). Pour utiliser l'éditeur que je t'ai indiqué, il faut bien sûr l'affecter à la JTable, en l'associant avec Double.class.

Il est possible également d'associer un éditeur avec une colonne particulière (Par l'instance de TableColumn).

Si tu veux généraliser le comportement sur toutes les colonnes, il faudra le faire pour toutes les colonnes, ou tous les classes (susceptibles d'être utilisées pour représenter des données de ton modèle). Et, bien sûr, choisir les implémentations adéquates, et étendre celles-ci de manière similaire à SelectAllCellEditor, quand ça a un sens (par exemple pour un booléen, ce sera le DefaultCellEditor à base de JCheckBox qui pourra être utilisé, et là ça n'a pas de sens de faire cette sélection automatique).

[joel.drigo]

Il est en effet nécessaire de passer un JTextField en argument du constructeur : le DefaultCellEditeur est une implémentation par défaut, qui gère toute la mécanique interne de CellEditor mais pas le composant d'édition en lui-même, afin de laisser plus de liberté à l'utilisateur de cette gestion (l'alignement, le format pour un JTextFormattedField, etc...). Il étend AbstractCellEditor : on peut bien sûr étendre cette abstraction si on veut faire un éditeur avec un comportement spécifique, différent de celui par défaut. L'exemple donnée était juste à titre indicatif, mais s'il ne s'agit que d'ajouter que la sélection complète lorsque le champ prend le focus, c'est suffisant.

Si tu veux pouvoir faire new SelectAllTableCellEditor(), tu peux modifier la classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class SelectAllCellEditor extends DefaultCellEditor {
 
    public SelectAllCellEditor() {
        this( new JTextField() ); // on créé une instance de JTextField
    }
 
    private SelectAllCellEditor(final JTextField textField) {
        super( textField );
        textField.setHorizontalAlignment(JTextField.RIGHT); // en général un nombre est aligné à droite
        textField.addFocusListener( new FocusAdapter()
        {
            public void focusGained( final FocusEvent e )
            {
                textField.selectAll();
            }
        } );
    }
}

[Okwolus]

Merci pour les précisions, c'est toujours sympa de savoir comment cela fonctionne en arrière-plan ^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
JTable tableauExcentration = new JTable(new ModeleExcentrationMethodeRapide());
tableauExcentration.setRowHeight(30);
tableauExcentration.setDefaultRenderer(Double.class, new DoubleRenderer());
tableauExcentration.setDefaultEditor(Double.class, new SelectionAutoCellEditor(new JTextField()));

Ça fonctionne parfaitement, merci

EDIT: désolé, j'ai supprimé l'ancien message en pensant avoir finalement trouvé par moi même et tu étais déjà entrain d'y répondre, mais enfait ça fonctionne toujours pas

Quand je clique dans la cellule, je vois que le Double initialisé à l'intérieur ( 0.0 en l’occurrence) se transforme en JTextField avec 0.0 bien sélectionné en entier (je suppose qu'il passe en String comme c'est dans un JTextField), mais quand je valide la cellule plante sur le JTextField et le chiffre ne reviens pas en Double.

Je suppose qu'il faut lui dire de caster cette fois le String modifié en Double mais je ne sais pas par quel moyen

[joel.drigo]

Ah oui, je n'avais pas tilté sur le fait qu'il y au redéfinition étrange dans le constructeur de DefaultCellEditor : et ne voyant rien de spécial au niveau du NumberEditor de la JTable, je me demande comme lui fait pour fonctionner. Je n'ai pas le temps de trop regarder dans le détail pour comprendre, donc je dirais qu'on peut s'inspirer du contructeur de DefaultCellEditor (ou réimplémenter la logique dans un AbstractCellEditor) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public DefaultCellEditor(final JTextField textField) {
        editorComponent = textField;
        this.clickCountToStart = 2;
        delegate = new EditorDelegate() {
            public void setValue(Object value) {
                textField.setText((value != null) ? value.toString() : "");
            }
 
            public Object getCellEditorValue() {
                return textField.getText();
            }
        };
        textField.addActionListener(delegate);
    }

Essaye donc, avec new SelectedAllCellEditor(new JFormattedTextField()) (en plus tu y auras gagner une possibilité de formater ta saisie) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 public SelectAllCellEditor(final JFormattedTextField  textField) {
        super( textField ); 
        textField.addFocusListener( new FocusAdapter()
        {
            public void focusGained( final FocusEvent e )
            {
                textField.selectAll();
            }
        } );
 
            textField.removeActionListener(delegate);
            delegate = new EditorDelegate() {
               public void setValue(Object value) {
                   textField.setValue( value );
               }
 
            public Object getCellEditorValue() {
                return textField.getValue();
            }
           }; 
           textField.addActionListener(delegate);
 
    }

[Okwolus]

Hello,

J'ai intégré la solution du formattedTF et j'ai donc limité la saisie aux doubles.

Mais, la sélection auto ne se fait plus! De plus, dans l'éditeur en formattedTF, c'est la virgule qui sert de séparateur, alors qu'avant c'était bien le point.
Donc c'est affiché avec un point comme séparateur, mais dans l'éditeur, il faut insérer une virgule. Est-ce dans le format de formattedTF qu'on peut gérer ça ?

[joel.drigo]

Salut,

Tu as mis un format du genre new DecimalFormat("#,##0.##") (ou DecimalFormat.getNumberInstance()...), et quand tu tapes le point sur le pavé numérique par exemple, tu voudrais que ça saisisse la virgule, c'est ça ?

Dans ce cas, ajoute au JFormattedTextField, un KeyListener comme ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
field.addKeyListener(new KeyAdapter(){
 
   final char decimalSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();
 
   public void keyTyped(KeyEvent e) { 
      if (e.getKeyChar()== '.')
         e.setKeyChar(decimalSeparator);
   }
 
});

Le JFormattedTextField est toujours un peu "roots" je trouve : ça reste un champ de saisie de texte, formaté certes, avec une conversion auto à la fin, mais on peut saisir n'importe quoi dedans car il n'y a aucune gestion particulière des touches, le format étant utilisé uniquement pour convertir le texte en valeur et inversement. Je suppose d'ailleurs que c'est en partie pour ça qu'on t'a demandé de sélectionner tout à la prise du focus. On peut autrement en gérant plus précisément la saisie dans le champ.

Si tu veux en plus ne pouvoir saisir que des chiffres et une seule virgule, tu peux faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
field.addKeyListener(new KeyAdapter() {
 
   final char decimalSeparator = DecimalFormatSymbols.getInstance() .getDecimalSeparator();
 
   public void keyTyped(KeyEvent e) {
      char c = e.getKeyChar();
      if (c ==  '.') {
         if (field.getText().indexOf(decimalSeparator) >= 0) { 
            Toolkit.getDefaultToolkit().beep();
            e.consume();
         } else {
            e.setKeyChar(decimalSeparator);
         }
      }
      else if ( c!=decimalSeparator && !Character.isDigit(e.getKeyChar()) ) {
         Toolkit.getDefaultToolkit().beep();
         e.consume();
      }
    }
 
});

Ou en encore plus user-friendly : si on saisit le . (ou la virgule au début, ça insert automatiquement un 0 devant, et si on la saisit au milieu alors qu'on en a déjà une, ça supprime tout ce qu'il y derrière) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
field.addKeyListener(new KeyAdapter() {
 
  final char decimalSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();
 
  public void keyTyped(KeyEvent e) {
    char c = e.getKeyChar();
    if (e.getKeyChar() == '.') {
      e.setKeyChar(decimalSeparator);
      handleDecimalSeparator(e);
    }
    else if ( c==decimalSeparator ) {
      handleDecimalSeparator(e);
    }
    else if ( !Character.isDigit(e.getKeyChar()) ) {
      cancel(e);
    }
  }
 
  private void handleDecimalSeparator(KeyEvent e) {
    int index = field.getText().indexOf(decimalSeparator);
    int start = field.getSelectionStart();
    int end = field.getSelectionEnd();
    if (index >= 0) { 
      if ( start==end ) {
        if ( index>=start ) {
          field.setText(field.getText().substring(0,start));
        }
        else {
          cancel(e);
        }
      }
      else {
        if ( index<start ) {
          cancel(e);
        }
        else if ( index>end ) {
          field.setText(field.getText().substring(0,end+1));
        }
      }
    } 
    if ( start==0 ) {
      field.setText( "0" + field.getText() );
      field.setSelectionStart(start+1);
      field.setSelectionEnd(end+1);
    }
    else {
      field.setSelectionStart(start);
      field.setSelectionEnd(end);
    }
  }
 
  private void cancel(KeyEvent e) {
    Toolkit.getDefaultToolkit().beep();
    e.consume();
  }
 
});

Ou qui déplace la virgule, si on en tape une à un autre endroit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
field.addKeyListener(new KeyAdapter() {
 
  final char decimalSeparator = DecimalFormatSymbols.getInstance().getDecimalSeparator();
 
  public void keyTyped(KeyEvent e) {
    char c = e.getKeyChar();
    if (e.getKeyChar() == '.') {
      e.setKeyChar(decimalSeparator);
      handleDecimalSeparator(e);
    }
    else if ( c==decimalSeparator ) {
      handleDecimalSeparator(e);
    }
    else if ( !Character.isDigit(e.getKeyChar()) ) {
      cancel(e);
    }
  }
 
  private void handleDecimalSeparator(KeyEvent e) {
    int index = field.getText().indexOf(decimalSeparator);
    int start = field.getSelectionStart();
    int end = field.getSelectionEnd();
    if (index >= 0) { 
      if ( start==end ) {
        field.setText(field.getText().substring(0,index) + field.getText().substring(index+1));
        if ( index<start ) {
          start--;
          end--;
        }
      }
      else {
        if ( index<start ) {
          field.setText(field.getText().substring(0,index) + field.getText().substring(index+1));
          start--;
          end--;
        }
        else if ( index>end ) {
          field.setText(field.getText().substring(0,index) + field.getText().substring(index+1));
        }
      }
    } 
    if ( start==0 ) {
      field.setText( "0" + field.getText() );
      field.setSelectionStart(start+1);
      field.setSelectionEnd(end+1);
    }
    else {
      field.setSelectionStart(start);
      field.setSelectionEnd(end);
    }
  }
 
  private void cancel(KeyEvent e) {
    Toolkit.getDefaultToolkit().beep();
    e.consume();
  }
 
});

[Okwolus]

Merci pour toutes les infos !

J'ai mis en place ta solution pour le . se transformant en virgule, ça fonctionne bien.

Mais tu n'as pas forcément résolu l'essentiel dans ça ^^

La sélection du contenu au focus ne se fait pas c'est bizarre, j'ai aussi essayé cette solution à l'intérieur de l'éditeur en JFormattedTextField

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
super(textField);  
		     textField.addFocusListener(new FocusAdapter(){
		    	 public void focusGained(final FocusEvent e){
		    		 textField.setSelectionStart(0);
		    		 textField.setSelectionEnd(textField.getText().length());
		         }
		     });

,sans succès

Le traitement fonctionne bien, la virgule est insérer comme il faut, et lorsqu'on valide avec entrée la valeur retourne au format Double correctement, mais la sélection du chiffre au double-clique de la cellule ne fait pas automatiquement.

Pour ta solution de virgule engendrant automatiquement un chiffre en 0,#### c'est pas la peine, les chiffres sont toujours très grand dans mon tableau.

De plus, je ne peux valider ma saisie qu'en appuyant sur la touche entrée. S je clique sur une case à côté au que je veux passer à la cellule voisine avec Tabulation ou avec Shift-Tabulation, la saisie est annulée.

[joel.drigo]

Il faut exécuter la sélection dans l'EDT (j'avais oublié ça, ne faisant plus que du SWT depuis des années, et j'ai oublié pourquoi la prise du focus n'est pas elle-même déjà dans l'EDT) :

D'ailleurs, j'avais oublié l'existence des méthodes select() et selectAll() aussi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
textField.addFocusListener(new FocusAdapter() {
    @Override
    public void focusGained(FocusEvent e) { 
        SwingUtilities.invokeLater(()-> textField.selectAll());
    }
});

[joel.drigo]

De plus, je ne peux valider ma saisie qu'en appuyant sur la touche entrée. S je clique sur une case à côté au que je veux passer à la cellule voisine avec Tabulation ou avec Shift-Tabulation, la saisie est annulée.

Normalement, la validation se fait à la perte du focus, et
ça se paramètre par JFormattedTextField.setFocusLostBehavior() . Là, je ne vois pas trop pourquoi ça ne fonctionne pas : je ne sais plus comment se comporte la JTable sur l'utilisation de TAB et SHIFT-TAB (cherche sur google des choses comme Focus traversal, ou Traversal policy for jtable...). Commence peut-être par la documentation Oracle.