Rendre une colonne d'un arbre éditable

**Narizuke** · 09/06/2015, 17h35

Bonjour à tous,

J'aurais une petite question. J'ai un arbre de ce genre :

Item1,valeur1,valeur2,valeur3 :
-sous-item1
-sous-item2
-sous-item3

Item1,valeur1,valeur2,valeur3 :
-sous-item1
-sous-item2
-sous-item3

J'utilise un tree pour créer mon arbre, par contre, est-il possible que mes valeurs1,valeurs2 et valeurs3 soient éditables ?

Je connais très peu l'utilisation des arbres en java, du coup, j'aurais besoin de votre aide. Merci d'avance.

**joel.drigo** · 09/06/2015, 18h44

Salut,

Un Tree ? Sous quel environnement graphique, SWT ?

**Narizuke** · 09/06/2015, 19h51

Merci pour votre réponse.
en effet, c'est sous swt, j'ai oublié de préciser.

**joel.drigo** · 09/06/2015, 20h29

Regarde la doc de la classe TreeEditor, il y a un exemple. Mais ce sera beaucoup plus simple avec JFace (voir Tutoriel Vogella (Voir ce fil aussi, avec quelques infos : http://www.developpez.net/forums/d14...ewer-combobox/).

**Narizuke** · 10/06/2015, 09h27

Merci pour la réponse. Je vais essayer avec ce que tu m'as donné

**Narizuke** · 10/06/2015, 16h27

J'ai réussi à rendre mes colonnes éditables en passant pas un TreeEditor :

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
 
            tree.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
 
            	final int column = cursor.getColumn();
 
        	// Clean up any previous editor control
                Control oldEditor = editor.getEditor();
                if (oldEditor != null) oldEditor.dispose();
 
                TreeItem item = (TreeItem)e.item;
 
                if (item == null) return;
 
                // The control that will be the editor must be a child of the Tree
                Text newEditor = new Text(tree, SWT.NONE);
                newEditor.setText(item.getText(column));
                newEditor.addModifyListener(new ModifyListener() {
                        public void modifyText(ModifyEvent e) {
                                Text text = (Text)editor.getEditor();
                                editor.getItem().setText(column,text.getText());
                        }
                });
                newEditor.selectAll();
                newEditor.setFocus();
                editor.setEditor(newEditor, item,column);
 
            }
		});

Par contre, en passant par ma variable int column = cursor.getColumn(); qui récupère donc le numéro de la colonne sélectionnée, j'ai un comportement étrange. Je clique dans ma cellule, modifie ma valeur mais cette modif n'est répercutée que quand je clique ailleurs. Avez-vous déjà rencontré ce problème ?

**joel.drigo** · 10/06/2015, 17h23

Le ModifyListener réagit à la sortie du champ (perte de focus), et à rien d'autre. En fait, il faut pouvoir détecter que la saisie est considérée comme terminée : on ne peut le savoir automatiquement (l'utilisateur peut toujours commencer à taper, faire autre chose, puis terminer). On va donc utiliser une action bien identifiée de l'utilisateur pour déterminer qu'il a terminé. Le ModifyListener marche bien pour les changements de champs (attention pour la fermeture de fenêtre : il me semble que le champ ne perd pas forcément le focus). Mais on peut réagir aussi à l'appui de la touche Enter : cela se fait par un TraverseListener. A noter que le VerifyListener permet de réagir à la saisie caractère par caractère (mais que justement, on ne peut utiliser comme je viens de le dire).

Voici un exemple, sous la forme d'une wrapper qui ajoute ce genre d'automatismes à un TableViewer (le principe est le même puisque c'est le même écouteur d'évènement). On y utilise également un KeyListener pour gérer les flêches du clavier (haut, bas, droite, gauche) qui peuvent être pratiques pour se déplacer de lignes en lignes ou de colonnes en colonnes.

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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
 
/**
 * Well ... the JFace <CODE>TableViewer<CODE> class does not provide
 * text celleditor keyboard support like if TAB is pressed in a column,
 * the focus does not go into the next column etc.,
 * 
 * After observing JDT method signature refactoring widget which does the
 * desired keyboard support, a generic utility listener has been developed
 * on the same lines.
 * 
 * Usage goes as ...
 * 
 * <P><PRE><CODE>
 * 
 *              TableViewer tblViewer = new TableViewer(SWT.SINGLE | SWT.FULL_SELECTION | SWT.| SWT.H_SCROLL | SWT.V_SCROLL | SWT.BORDER)
 *              ...
 *              CellEditor[] cellEditors = ...
 *              ...
 *              tblViewer.setCellEditors(cellEditors);
 *              
 *              TableViewerKeyBoardSupport support = new TableViewerKeyBoardSupport(tblViewer);
 *              support.startSupport();
 *  
 * </CODE></PRE></P>
 */
public class TableViewerKeyBoardSupport {
 
	protected TableViewer fTableViewer = null;
 
	public TableViewerKeyBoardSupport(TableViewer tableViewer) {
		fTableViewer = tableViewer;
	}
 
	/**
         * After the cell editors have been set on tableviewer, this method should
         * be called to start giving keyboard support.
         */
	public void startSupport() {
		/* add table key listener */
		getTable().addKeyListener(new TableKeyListener(this));
 
		/* add table traverse listener */
		getTable().addTraverseListener(new TableTraverseListener(this));
 
		/* add table-textcelleditors key and traverse listeners */
		CellEditor[] cellEditors = fTableViewer.getCellEditors();
		if (cellEditors != null) {
			for (int colIndex = 0; colIndex < cellEditors.length; colIndex++) {
				CellEditor cellEditor = cellEditors[colIndex];
				if (cellEditor != null) {
					cellEditor.getControl().addKeyListener(
							new CellEditorKeyListener(this, cellEditor,
									colIndex));
					cellEditor.getControl().addTraverseListener(
							new CellEditorTraverseListener(this, cellEditor,
									colIndex));
				}
			}
		}
 
	}
 
	protected TableViewer getTableViewer() {
		return fTableViewer;
	}
 
	protected Table getTable() {
		return fTableViewer.getTable();
	}
 
	protected int nextColumn(int column) {
		return (column >= getTable().getColumnCount() - 1) ? 0 : column + 1;
	}
 
	protected int prevColumn(int column) {
		return (column <= 0) ? getTable().getColumnCount() - 1 : column - 1;
	}
 
	protected void editColumnOrNextPossible(final int column) {
		Object selectedElem = getSelectedElement();
		if (selectedElem == null)
			return;
 
		int nextColumn = column;
		do {
			fTableViewer.editElement(selectedElem, nextColumn);
			if (fTableViewer.isCellEditorActive())
				return;
			nextColumn = nextColumn(nextColumn);
		} while (nextColumn != column);
	}
 
	protected void editColumnOrPrevPossible(int column) {
		Object selectedElem = getSelectedElement();
		if (selectedElem == null)
			return;
 
		int prevColumn = column;
		do {
			fTableViewer.editElement(selectedElem, prevColumn);
			if (fTableViewer.isCellEditorActive())
				return;
			prevColumn = prevColumn(prevColumn);
		} while (prevColumn != column);
	}
 
	private Object getSelectedElement() {
		IStructuredSelection selection = (IStructuredSelection) fTableViewer
				.getSelection();
		if (selection == null || selection.isEmpty())
			return null;
 
		return selection.getFirstElement();
	}
 
	static class CellEditorKeyListener extends KeyAdapter {
		private TableViewerKeyBoardSupport fKeyBoardSupporter = null;
		private CellEditor fEditor = null;
		private int fEditorColumn = -1;
 
		public CellEditorKeyListener(
				TableViewerKeyBoardSupport keyBoardSupporter, CellEditor editor,
				int editorColumn) {
			fKeyBoardSupporter = keyBoardSupporter;
			fEditor = editor;
			fEditorColumn = editorColumn;
		}
 
		public void keyPressed(KeyEvent e) {
			if (e.stateMask == SWT.MOD1 || e.stateMask == SWT.MOD2) {
				if (e.keyCode == SWT.ARROW_UP || e.keyCode == SWT.ARROW_DOWN) {
					// allow starting multi-selection even if in edit mode
					fEditor.deactivate();
					e.doit = false;
					return;
				}
			}
 
			if (e.stateMask != SWT.NONE)
				return;
 
			switch (e.keyCode) {
			case SWT.ARROW_DOWN:
				e.doit = false;
				int nextRow = fKeyBoardSupporter.getTable().getSelectionIndex() + 1;
				if (nextRow >= fKeyBoardSupporter.getTable().getItemCount())
					break;
				fKeyBoardSupporter.getTable().setSelection(nextRow);
				fKeyBoardSupporter.editColumnOrPrevPossible(fEditorColumn);
				break;
 
			case SWT.ARROW_UP:
				e.doit = false;
				int prevRow = fKeyBoardSupporter.getTable().getSelectionIndex() - 1;
				if (prevRow < 0)
					break;
				fKeyBoardSupporter.getTable().setSelection(prevRow);
				fKeyBoardSupporter.editColumnOrPrevPossible(fEditorColumn);
				break;
 
			case SWT.F2:
				e.doit = false;
				fEditor.deactivate();
				break;
			}
		}
	}
 
	static class CellEditorTraverseListener implements TraverseListener {
		private TableViewerKeyBoardSupport fKeyBoardSupporter = null;
		private CellEditor fEditor = null;
		private int fEditorColumn = -1;
 
		public CellEditorTraverseListener(
				TableViewerKeyBoardSupport keyBoardSupporter, CellEditor editor,
				int editorColumn) {
			fKeyBoardSupporter = keyBoardSupporter;
			fEditor = editor;
			fEditorColumn = editorColumn;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see
		 * org.eclipse.swt.events.TraverseListener#keyTraversed(org.eclipse.swt.
		 * events.TraverseEvent)
		 */
		public void keyTraversed(TraverseEvent e) {
 
			switch (e.detail) {
			case SWT.TRAVERSE_TAB_NEXT:
				fKeyBoardSupporter.editColumnOrNextPossible(fKeyBoardSupporter
						.nextColumn(fEditorColumn));
				e.detail = SWT.TRAVERSE_NONE;
				break;
 
			case SWT.TRAVERSE_TAB_PREVIOUS:
				fKeyBoardSupporter.editColumnOrPrevPossible(fKeyBoardSupporter
						.prevColumn(fEditorColumn));
				e.detail = SWT.TRAVERSE_NONE;
				break;
 
			case SWT.TRAVERSE_ESCAPE:
				fKeyBoardSupporter.getTableViewer().cancelEditing();
				e.detail = SWT.TRAVERSE_NONE;
				break;
 
			case SWT.TRAVERSE_RETURN:
				fEditor.deactivate();
				e.detail = SWT.TRAVERSE_NONE;
				break;
 
			default:
				break;
			}
		}
	}
 
	static class TableTraverseListener implements TraverseListener {
		private TableViewerKeyBoardSupport fKeyBoardSupporter = null;
 
		public TableTraverseListener(TableViewerKeyBoardSupport keyBoardSupporter) {
			fKeyBoardSupporter = keyBoardSupporter;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see
		 * org.eclipse.swt.events.TraverseListener#keyTraversed(org.eclipse.swt.
		 * events.TraverseEvent)
		 */
		public void keyTraversed(TraverseEvent e) {
			if (e.detail == SWT.TRAVERSE_RETURN && e.stateMask == SWT.NONE) {
				fKeyBoardSupporter.editColumnOrNextPossible(0);
				e.detail = SWT.TRAVERSE_NONE;
			}
		}
	}
 
	static class TableKeyListener extends KeyAdapter {
		private TableViewerKeyBoardSupport fKeyBoardSupporter = null;
 
		public TableKeyListener(TableViewerKeyBoardSupport keyBoardSupporter) {
			fKeyBoardSupporter = keyBoardSupporter;
		}
 
		/*
		 * (non-Javadoc)
		 * 
		 * @see
		 * org.eclipse.swt.events.KeyListener#keyPressed(org.eclipse.swt.events.
		 * KeyEvent)
		 */
		public void keyPressed(KeyEvent e) {
			if (e.keyCode == SWT.F2 && e.stateMask == SWT.NONE) {
				fKeyBoardSupporter.editColumnOrNextPossible(0);
				e.doit = false;
			}
		}
	}
 
}

Attention, la gestion de la saisie par l'EditingSupport est évidemment différente de ta gestion à la main du champ et de la mise à jour du modèle.

**Narizuke** · 11/06/2015, 11h10

Merci pour toutes ces explications.
Ce que je trouve bizarre dans mon code, c'est que si je remplace ma variable column par une valeur en dure et que je supprime le TreeCursor, j'ai bien une réaction caractère par caractère dans ma cellule sélectionnée.

**Narizuke** · 11/06/2015, 11h52

Bon ducoup, j'ai finté mon problème. C'est lourd, mais au moins ça fonctionne :

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
 
tree.addSelectionListener(new SelectionAdapter() {
            public void widgetSelected(SelectionEvent e) {
 
            	//final int column = cursor.getColumn();
 
        		// Clean up any previous editor control
                Control oldEditor = editor1.getEditor();
                if (oldEditor != null) oldEditor.dispose();
 
                oldEditor = editor2.getEditor();
                if (oldEditor != null) oldEditor.dispose();
 
                oldEditor = editor3.getEditor();
                if (oldEditor != null) oldEditor.dispose();
 
                oldEditor = editor4.getEditor();
                if (oldEditor != null) oldEditor.dispose();
 
                TreeItem item = (TreeItem)e.item;
 
                if (item == null) return;
 
                // For OTD 
                // The control that will be the editor must be a child of the Tree
                Text newEditor = new Text(tree, SWT.NONE);
                newEditor.setText(item.getText(3));
                newEditor.addModifyListener(new ModifyListener() {
                        public void modifyText(ModifyEvent e) {
                                Text text = (Text)editor1.getEditor();
                                editor1.getItem().setText(3,text.getText());
                        }
                });
                newEditor.selectAll();
                newEditor.setFocus();
                editor1.setEditor(newEditor, item,3);
 
                // For Depth before regrooving
                // The control that will be the editor must be a child of the Tree
                Text newEditor2 = new Text(tree, SWT.NONE);
                newEditor2.setText(item.getText(4));
                newEditor2.addModifyListener(new ModifyListener() {
                        public void modifyText(ModifyEvent e) {
                                Text text = (Text)editor2.getEditor();
                                editor2.getItem().setText(4,text.getText());
                        }
                });
                newEditor2.selectAll();
                newEditor2.setFocus();
                editor2.setEditor(newEditor2, item,4);
 
                // For Regrooving depth
                // The control that will be the editor must be a child of the Tree
                Text newEditor3 = new Text(tree, SWT.NONE);
                newEditor3.setText(item.getText(5));
                newEditor3.addModifyListener(new ModifyListener() {
                        public void modifyText(ModifyEvent e) {
                                Text text = (Text)editor3.getEditor();
                                editor3.getItem().setText(5,text.getText());
                        }
                });
                newEditor3.selectAll();
                newEditor3.setFocus();
                editor3.setEditor(newEditor3, item,5);
 
                // For rtdMin
                // The control that will be the editor must be a child of the Tree
                Text newEditor4 = new Text(tree, SWT.NONE);
                newEditor4.setText(item.getText(6));
                newEditor4.addModifyListener(new ModifyListener() {
                        public void modifyText(ModifyEvent e) {
                                Text text = (Text)editor4.getEditor();
                                editor4.getItem().setText(6,text.getText());
                        }
                });
                newEditor4.selectAll();
                newEditor4.setFocus();
                editor4.setEditor(newEditor4, item,6);
 
            }
		});