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).

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

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