Discussion :

[Djobird]

Bon, je crois qu'il y'a vraiment un truc que j'ai raté avec ce principe.

Voici un exemple d'editor que j'utilise :

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
 
public class QueryAttributeTableCellEditor extends AbstractCellEditor implements TableCellEditor {
 
    JComboBox component;
    Logger logger = Logger.getLogger(QueryAttributeTableCellEditor.class);
 
 
    public Object getCellEditorValue() {
        Object value;
 
        value = component.getSelectedItem();
        return value;
    }
 
 
    public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
        QueryAttribute attribute;
 
        if (value instanceof QueryAttribute) {
            attribute = (QueryAttribute) value;
 
            component = OperatorComponentFactory.getInstance().createComponent(column, attribute);
 
        } else {
            logger.warn("Anormaly coverage, value must be an instance of QueryAttribute");
 
        }
 
 
        return component;
    }
}

Ce qui me pose souci, c'est qu'en effectuant ainsi, dés que je modifie légèrement ma Jtable (redimensionnement d'une colonne, édition d'une cellule), cela me créé un nouveau component pour chaque cellule, au lieu de reprendre le component existant.

Ce qui implique d'une part une grosse charge puisque cela créé/détruit des dizaines de composants à chaque fois pour rien, plus d'autres problèmes.

Alors, est ce que j'ai définitivement raté un truc la dessus et il est possible d'implémenter un renderer/editor sans qu'il créé un nouveau composant à chaque affichage, ou alors ce comportement tout à fait normal ?

[dinobogan]

un editor utilise toujours la même instance de Component.
Dans ton editor, j'ai l'impression que tu créés une nouvelle instance à chaque appel avec la méthode "createComponent".

[Djobird]

un editor utilise toujours la même instance de Component.
Dans ton editor, j'ai l'impression que tu créés une nouvelle instance à chaque appel avec la méthode "createComponent".

Tout à fait, ca fait un new à chaque fois. Mais comment puis je faire autrement ?

[tchize_]

normalement, le principe des renderer / editor, c'est justement de ne pas avoir à créer autant de composants qu'il n'y a de cellules. ainsi, on peut très bien faire des tables de 10000 lignes sans trops de surcharage, alors que 10.000 composants, ce serait la cata. C'st donc à tois de faire les opérations suivantes:

dans getTableCellEditorComponent(), tu prépare ta combobox, en réutilisant celle que tu as déjà. Ca implique, la remplir avec les valeurs possibles dans la case, y sélectionner par défaut la valeur actuelle de la case.

et dans getcelleditorvalue, tu garde ton code. De toutes facons, il n'y a qu'une cellule en cours d'édition à la fois

[Djobird]

Bonjour, merci pour les réponses, j'ai modifié ma fonction createComponent pour qu'il ne retour plus qu'il fonctionne comme si chaque composant était un singleton.

Par contre j'ai encore un problème. J'ai un autre composant perso qui peut être affiché dans ma JTable. Ce composant étant de JPanel, et il contient DatePicker pour choisir une date un formattedText pour choisir une heure.

Voici son code :

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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
 
public class TimeChooser extends JPanel {
 
    Logger logger = Logger.getLogger(TimeChooser.class);
    private DateFormat dateFormat;
    private DateFormat timeFormat;
 
    /** Creates new form BeanForm */
    public TimeChooser() {
        dateFormat = DateFormat.getDateInstance(SHORT);
        timeFormat = DateFormat.getTimeInstance(SHORT);
 
 
        dateFormat.setLenient(false);
        timeFormat.setLenient(false);
 
 
        initComponents();
        jXDatePicker1.getFormats()[0] = dateFormat;
        initTimeValue();
    }
 
    /**
     * Initialise value 
     */
    private void initTimeValue() {
 
        jXDatePicker1.setDate(null);
    }
 
    /**
     * Parse time, and set Date and Time value
     * @param time
     */
    public void setTime(String time) {
        try {
            if (!time.equals(QueryAttribute.DEFAULT_ATTRIBUTE_VALUE)) {
                Date date = DateFormat.getInstance().parse(time);
                jXDatePicker1.setDate(date);
                Calendar cal = Calendar.getInstance();
                cal.setTime(date);
                jFormattedTextField1.setText(timeFormat.format(cal.getTime()));
            }
 
        } catch (ParseException ex) {
            logger.warn(ex.getMessage());
            Exceptions.printStackTrace(ex);
        }
    }
 
    /**
     * Parse Date and Time ans return a String
     * @return
     */
    public String getTime() {
 
        String timeString;
        try {
 
            Calendar cal = Calendar.getInstance();
            Calendar calTime = getTimeCalendar();
            Date date = jXDatePicker1.getDate();
 
            //If both of time choose return a null value, the returned stay to ""
            if (date == null && calTime == null) {
                timeString = "";
            } else {
                //We initialize the date to current date, and next we will set the different value 
                cal.setTime(new Date());
 
                if (date != null) {
                    cal.setTime(date);
                }
 
                if (calTime != null) {
                    cal.set(Calendar.HOUR_OF_DAY, calTime.get(Calendar.HOUR_OF_DAY));
                    cal.set(Calendar.MINUTE, calTime.get(Calendar.MINUTE));
                }
 
                timeString = dateFormat.format(cal.getTime());
                timeString += " ";
                timeString += timeFormat.format(cal.getTime());
            }
 
        } catch (ParseException ex) {
            timeString = "";
            logger.info(ex.getMessage());
        }
        return timeString;
    }
 
    /**
     * Parse Time, and return the hour with String
     * @return
     * @throws java.text.ParseException
     */
    public int getHours() throws ParseException {
        int hour = -1;
 
        Calendar cal = getTimeCalendar();
        if (cal != null) {
            hour = cal.get(Calendar.HOUR_OF_DAY);
        }
        return hour;
    }
 
    /***
     * Parse Time and return the minute with String
     * @return 
     * @throws java.text.ParseException
     */
    public int getMinutes() throws ParseException {
        int minute = -1;
 
        Calendar cal = getTimeCalendar();
        if (cal != null) {
            minute = cal.get(Calendar.MINUTE);
        }
        return minute;
    }
 
    /**
     * Parse Time, and return it with Calendar
     * @return
     * @throws java.text.ParseException
     */
    private Calendar getTimeCalendar() throws ParseException {
        Calendar cal = Calendar.getInstance();
        if (!jFormattedTextField1.getText().equals("") && jFormattedTextField1.isValid()) {
            String text = jFormattedTextField1.getText();
 
 
 
 
            Date date = timeFormat.parse(text);
            cal.setTime(date);
        } else {
            cal = null;
        }
        return cal;
    }

Plusieurs cellules ont un renderer et un editor de ce type. Or, lorsque je choisis une date, tous les autres TimeChooser se remplissent alors de la même date.

Edit : Par contre, la valeur dans le model n'est pas modifié, seul l'affichage via la Jtable l'est.

[tchize_]

À chaque appel de getComponent, c'est à toi de mettre ton datepicker à la bonne valeur. Si la même date apparait partout, c'est que tu ne fais pas cette opération. De la même manière qu'avec un label, on ferait dans getComponent label.setText(valeur), avant de retourner le composant datepicker, tu dois faire un datePicker.setDate(valeur) ou quelque chose d'équivalent (suivant la manière dont tu prévois de définir la valeur de ton datepicker).