[TableView] Permettre l'éditon d'une ligne uniquement

Version imprimable

14/11/2016, 11h06
sixone

[TableView] Permettre l'éditon d'une ligne uniquement

Bonjour,

Je découvre en ce moment JavaFx et je cherche à utiliser les TableView.

Dans mon projet, j'ai une TableView composé de deux lignes et de plusieurs colonnes. Sur ces deux lignes, je souhaite qu'une seule des deux soit editable.
Jusqu'à présent j'ai réussi à rendre ma TableView editable (ou non) uniquement en fonction des colonnes.

Est-il possible avec ce composant de sélectionner l'édition d'une cellule en fonction de la ligne ou de la cellule ?

Merci en avance ;)

Teddy

C'est au niveau de la cellule que tu peux gérer cela, par exemple en faisant comme suit, ce qui rend la second ligne non-éditable :

Code:

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public class Main extends Application {
 
    private static final class Toto {
 
        public Toto(final String a, final String b) {
            setA(a);
            setB(b);
        }
 
        private final StringProperty a = new SimpleStringProperty(this, "a");
 
        public final String getA() {
            return a.get();
        }
 
        public final void setA(final String value) {
            a.set(value);
        }
 
        public final StringProperty aProperty() {
            return a;
        }
 
        private final StringProperty b = new SimpleStringProperty(this, "b");
 
        public final String getB() {
            return b.get();
        }
 
        public final void setB(final String value) {
            b.set(value);
        }
 
        public final StringProperty bProperty() {
            return b;
        }
    }
 
    private static class MyTextFieldTableCell<K, V> extends TextFieldTableCell<K, V> {
 
        @Override
        public void updateIndex(int i) {
            super.updateIndex(i);
            editableProperty().set(i != 1);
        }
    };
 
    @Override
    public void start(Stage primaryStage) throws Exception {
        final TableColumn<Toto, String> aColumn = new TableColumn<>("a");
        aColumn.setEditable(true);
        aColumn.setCellValueFactory(feature -> feature.getValue().aProperty());
        aColumn.setCellFactory(column -> new MyTextFieldTableCell());
        final TableColumn<Toto, String> bColumn = new TableColumn<>("b");
        bColumn.setEditable(true);
        bColumn.setCellValueFactory(feature -> feature.getValue().bProperty());
        bColumn.setCellFactory(column -> new MyTextFieldTableCell());
        final TableView<Toto> tableView = new TableView<>();
        tableView.setEditable(true);
        tableView.setColumnResizePolicy(TableView.CONSTRAINED_RESIZE_POLICY);
        tableView.getColumns().setAll(aColumn, bColumn);
        final Toto[] values = {
            new Toto("aaa", "bbbb"),
            new Toto("ccc", "ddd"),};
        tableView.getItems().setAll(values);
        final StackPane root = new StackPane(tableView);
        final Scene scene = new Scene(root);
        primaryStage.setScene(scene);
        primaryStage.show();
    }
 
}

Ici la méthode updateIndex() de la cellule active ou désactive la capacité d’édition en fonction du numéro de la ligne.

Bon ici c'est codé en dur mais on pourrait passer au constructeur de la cellule une référence de méthode, un callback ou même une propriété pour vérifier l’édition lorsque updateIndex() est invoquée. Dans le cas suivant on fournit un callback pour faire le test dans la cellule :

Code:

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
    private static class MyTextFieldTableCell<K, V> extends TextFieldTableCell<K, V> {
 
        private final Function<Integer, Boolean> testRowEditable;
 
        public MyTextFieldTableCell(final Function<Integer, Boolean> testRowEditable) {
            super();
            Objects.requireNonNull(testRowEditable);
            this.testRowEditable = testRowEditable;
        }
 
        @Override
        public void updateIndex(int i) {
            super.updateIndex(i);
            final boolean isRowEditable = testRowEditable.apply(i);
            editableProperty().set(isRowEditable);
        }
    };
 
[...]
 
final Function<Integer, Boolean> isRowEditable = rowIndex -> rowIndex != 1;
 
[...]
 
aColumn.setCellFactory(column -> new MyTextFieldTableCell(isRowEditable));
 
[...]
 
bColumn.setCellFactory(column -> new MyTextFieldTableCell(isRowEditable));

1 pièce(s) jointe(s)

Merci Bouye,

J'avais vu la fonction UpdateItem mais pas UpdateIndex :)

J'ai un peu modifié la classe MyTextFieldTableCell car elle affichait bien un textField mais ne permettait pas de valider une modification faite par l'utilisateur, pour ceux que ça pourrait intéresser ;)

Code:

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
private static class MyTextFieldTableCell<S, T> extends TextFieldTableCell<S, T> {
 
        private final Function<Integer, Boolean> testRowEditable;
 
        public MyTextFieldTableCell(StringConverter<T> converter, final Function<Integer, Boolean> testRowEditable) {
            super(converter);
            Objects.requireNonNull(testRowEditable);
            this.testRowEditable = testRowEditable;
        }
 
        public static <S> Callback<TableColumn<S,String>, TableCell<S,String>> forTableColumn(final Function<Integer, Boolean> testRowEditable) {
            return forTableColumn(new DefaultStringConverter(), testRowEditable);
        }
 
        public static <S,T> Callback<TableColumn<S,T>, TableCell<S,T>> forTableColumn(
                final StringConverter<T> converter, final Function<Integer, Boolean> testRowEditable) {
            return new Callback<TableColumn<S,T>, TableCell<S,T>>() {
                @Override
                public TableCell<S,T> call(TableColumn<S,T> list) {
                    return new MyTextFieldTableCell<S,T>(converter, testRowEditable);
                }
            };
        }
 
        @Override
        public void updateIndex(int i) {
            super.updateIndex(i);
            final boolean isRowEditable = testRowEditable.apply(i);
            editableProperty().set(isRowEditable);
        }
    }

Code:

a.setCellFactory(MyTextFieldTableCell.forTableColumn(isRowEditable));

Je profite aussi de cette conversation pour poser une seconde question sur les tableView, est-il possible d'ajouter un "rowHeader" comme l'image suivante à une TableView ?
Pièce jointe 224869

Merci

Teddy

15/11/2016, 12h09
bouye

Pas que je sache (à moins de faire une colonne spéciale). Voir peut-être du coté de ControlsFX qui propose une table plus orientée "tableur" je crois.