Mercurial > projects > dwt-addons
annotate dwtx/jface/viewers/TreeViewer.d @ 43:ea8ff534f622
Fix override and super aliases
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Fri, 11 Apr 2008 01:24:25 +0200 |
parents | da5ad8eedf5d |
children | a6683645b0d7 |
rev | line source |
---|---|
10 | 1 /******************************************************************************* |
2 * Copyright (c) 2004, 2007 IBM Corporation and others. | |
3 * All rights reserved. This program and the accompanying materials | |
4 * are made available under the terms of the Eclipse Public License v1.0 | |
5 * which accompanies this distribution, and is available at | |
6 * http://www.eclipse.org/legal/epl-v10.html | |
7 * | |
8 * Contributors: | |
9 * IBM Corporation - initial API and implementation | |
10 * Tom Schindl <tom.schindl@bestsolution.at> - concept of ViewerRow, | |
11 * refactoring (bug 153993), bug 167323, 191468 | |
12 * Port to the D programming language: | |
13 * Frank Benoit <benoit@tionex.de> | |
14 *******************************************************************************/ | |
15 | |
16 module dwtx.jface.viewers.TreeViewer; | |
17 | |
18 import dwtx.jface.viewers.AbstractTreeViewer; | |
19 import dwtx.jface.viewers.TreeViewerRow; | |
20 import dwtx.jface.viewers.IBaseLabelProvider; | |
21 import dwtx.jface.viewers.ColumnViewerEditor; | |
22 import dwtx.jface.viewers.IContentProvider; | |
23 import dwtx.jface.viewers.TreeSelection; | |
24 import dwtx.jface.viewers.ViewerRow; | |
25 import dwtx.jface.viewers.ISelection; | |
26 import dwtx.jface.viewers.TreeViewerEditor; | |
27 import dwtx.jface.viewers.ColumnViewerEditorActivationStrategy; | |
28 import dwtx.jface.viewers.ColumnViewerEditorActivationEvent; | |
29 import dwtx.jface.viewers.ILazyTreeContentProvider; | |
30 import dwtx.jface.viewers.ILazyTreePathContentProvider; | |
31 import dwtx.jface.viewers.TreePath; | |
32 import dwtx.jface.viewers.TreeExpansionEvent; | |
33 import dwtx.jface.viewers.ViewerCell; | |
34 | |
35 import tango.util.collection.LinkSeq; | |
36 import tango.util.collection.model.Seq; | |
37 import tango.util.collection.model.SeqView; | |
38 | |
39 import dwt.DWT; | |
40 import dwt.events.DisposeEvent; | |
41 import dwt.events.DisposeListener; | |
42 import dwt.events.TreeEvent; | |
43 import dwt.events.TreeListener; | |
44 import dwt.graphics.Point; | |
45 import dwt.widgets.Composite; | |
46 import dwt.widgets.Control; | |
47 import dwt.widgets.Event; | |
48 import dwt.widgets.Item; | |
49 import dwt.widgets.Listener; | |
50 import dwt.widgets.Tree; | |
51 import dwt.widgets.TreeItem; | |
52 import dwt.widgets.Widget; | |
53 import dwtx.jface.util.Policy; | |
54 | |
55 import dwt.dwthelper.utils; | |
56 import dwt.dwthelper.Runnable; | |
40
da5ad8eedf5d
debug prints, dwt.dwthelper restructure, ...
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
57 import tango.util.log.Trace; |
10 | 58 |
59 /** | |
60 * A concrete viewer based on an DWT <code>Tree</code> control. | |
61 * <p> | |
62 * This class is not intended to be subclassed outside the viewer framework. It | |
63 * is designed to be instantiated with a pre-existing DWT tree control and | |
64 * configured with a domain-specific content provider, label provider, element | |
65 * filter (optional), and element sorter (optional). | |
66 * </p> | |
67 * <p> | |
68 * Content providers for tree viewers must implement either the | |
69 * {@link ITreeContentProvider} interface, (as of 3.2) the | |
70 * {@link ILazyTreeContentProvider} interface, or (as of 3.3) the | |
71 * {@link ILazyTreePathContentProvider}. If the content provider is an | |
72 * <code>ILazyTreeContentProvider</code> or an | |
73 * <code>ILazyTreePathContentProvider</code>, the underlying Tree must be | |
74 * created using the {@link DWT#VIRTUAL} style bit, and the tree viewer will not | |
75 * support sorting or filtering. | |
76 * </p> | |
77 */ | |
78 public class TreeViewer : AbstractTreeViewer { | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
79 alias AbstractTreeViewer.addTreeListener addTreeListener; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
80 alias AbstractTreeViewer.getLabelProvider getLabelProvider; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
81 alias AbstractTreeViewer.getSelection getSelection; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
82 alias AbstractTreeViewer.preservingSelection preservingSelection; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
83 alias AbstractTreeViewer.remove remove; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
84 alias AbstractTreeViewer.setSelection setSelection; |
10 | 85 |
86 private static final String VIRTUAL_DISPOSE_KEY = Policy.JFACE | |
87 ~ ".DISPOSE_LISTENER"; //$NON-NLS-1$ | |
88 | |
89 /** | |
90 * This viewer's control. | |
91 */ | |
92 private Tree tree; | |
93 | |
94 /** | |
95 * Flag for whether the tree has been disposed of. | |
96 */ | |
97 private bool treeIsDisposed = false; | |
98 | |
99 private bool contentProviderIsLazy; | |
100 | |
101 private bool contentProviderIsTreeBased; | |
102 | |
103 /** | |
104 * The row object reused | |
105 */ | |
106 private TreeViewerRow cachedRow; | |
107 | |
108 /** | |
109 * true if we are inside a preservingSelection() call | |
110 */ | |
111 private bool preservingSelection_; | |
112 | |
113 /** | |
114 * Creates a tree viewer on a newly-created tree control under the given | |
115 * parent. The tree control is created using the DWT style bits | |
116 * <code>MULTI, H_SCROLL, V_SCROLL,</code> and <code>BORDER</code>. The | |
117 * viewer has no input, no content provider, a default label provider, no | |
118 * sorter, and no filters. | |
119 * | |
120 * @param parent | |
121 * the parent control | |
122 */ | |
123 public this(Composite parent) { | |
124 this(parent, DWT.MULTI | DWT.H_SCROLL | DWT.V_SCROLL | DWT.BORDER); | |
125 } | |
126 | |
127 /** | |
128 * Creates a tree viewer on a newly-created tree control under the given | |
129 * parent. The tree control is created using the given DWT style bits. The | |
130 * viewer has no input, no content provider, a default label provider, no | |
131 * sorter, and no filters. | |
132 * | |
133 * @param parent | |
134 * the parent control | |
135 * @param style | |
136 * the DWT style bits used to create the tree. | |
137 */ | |
138 public this(Composite parent, int style) { | |
139 this(new Tree(parent, style)); | |
140 } | |
141 | |
142 /** | |
143 * Creates a tree viewer on the given tree control. The viewer has no input, | |
144 * no content provider, a default label provider, no sorter, and no filters. | |
145 * | |
146 * @param tree | |
147 * the tree control | |
148 */ | |
149 public this(Tree tree) { | |
150 super(); | |
151 this.tree = tree; | |
152 hookControl(tree); | |
153 } | |
154 | |
155 /* | |
156 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
157 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
158 protected override void addTreeListener(Control c, TreeListener listener) { |
10 | 159 (cast(Tree) c).addTreeListener(listener); |
160 } | |
161 | |
162 /* | |
163 * (non-Javadoc) | |
164 * | |
165 * @see dwtx.jface.viewers.ColumnViewer#getColumnViewerOwner(int) | |
166 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
167 protected override Widget getColumnViewerOwner(int columnIndex) { |
10 | 168 if (columnIndex < 0 || ( columnIndex > 0 && columnIndex >= getTree().getColumnCount() ) ) { |
169 return null; | |
170 } | |
171 | |
172 if (getTree().getColumnCount() is 0)// Hang it off the table if it | |
173 return getTree(); | |
174 | |
175 return getTree().getColumn(columnIndex); | |
176 } | |
177 | |
178 /* | |
179 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
180 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
181 protected override Item[] getChildren(Widget o) { |
10 | 182 if (auto ti = cast(TreeItem)o ) { |
183 return ti.getItems(); | |
184 } | |
185 if (auto t = cast(Tree)o ) { | |
186 return t.getItems(); | |
187 } | |
188 return null; | |
189 } | |
190 | |
191 /* | |
192 * (non-Javadoc) Method declared in Viewer. | |
193 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
194 public override Control getControl() { |
10 | 195 return tree; |
196 } | |
197 | |
198 /* | |
199 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
200 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
201 protected override bool getExpanded(Item item) { |
10 | 202 return (cast(TreeItem) item).getExpanded(); |
203 } | |
204 | |
205 /* | |
206 * (non-Javadoc) | |
207 * | |
208 * @see dwtx.jface.viewers.ColumnViewer#getItemAt(dwt.graphics.Point) | |
209 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
210 protected override Item getItemAt(Point p) { |
10 | 211 TreeItem[] selection = tree.getSelection(); |
212 | |
213 if( selection.length is 1 ) { | |
214 int columnCount = tree.getColumnCount(); | |
215 | |
216 for( int i = 0; i < columnCount; i++ ) { | |
217 if( selection[0].getBounds(i).contains(p) ) { | |
218 return selection[0]; | |
219 } | |
220 } | |
221 } | |
222 | |
223 return getTree().getItem(p); | |
224 } | |
225 | |
226 /* | |
227 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
228 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
229 protected override int getItemCount(Control widget) { |
10 | 230 return (cast(Tree) widget).getItemCount(); |
231 } | |
232 | |
233 /* | |
234 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
235 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
236 protected override int getItemCount(Item item) { |
10 | 237 return (cast(TreeItem) item).getItemCount(); |
238 } | |
239 | |
240 /* | |
241 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
242 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
243 protected override Item[] getItems(Item item) { |
10 | 244 return (cast(TreeItem) item).getItems(); |
245 } | |
246 | |
247 /** | |
248 * The tree viewer implementation of this <code>Viewer</code> framework | |
249 * method ensures that the given label provider is an instance of either | |
250 * <code>ITableLabelProvider</code> or <code>ILabelProvider</code>. If | |
251 * it is an <code>ITableLabelProvider</code>, then it provides a separate | |
252 * label text and image for each column. If it is an | |
253 * <code>ILabelProvider</code>, then it provides only the label text and | |
254 * image for the first column, and any remaining columns are blank. | |
255 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
256 public override IBaseLabelProvider getLabelProvider() { |
10 | 257 return super.getLabelProvider(); |
258 } | |
259 | |
260 /* | |
261 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
262 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
263 protected override Item getParentItem(Item item) { |
10 | 264 return (cast(TreeItem) item).getParentItem(); |
265 } | |
266 | |
267 /* | |
268 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
269 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
270 protected override Item[] getSelection(Control widget) { |
10 | 271 return (cast(Tree) widget).getSelection(); |
272 } | |
273 | |
274 /** | |
275 * Returns this tree viewer's tree control. | |
276 * | |
277 * @return the tree control | |
278 */ | |
279 public Tree getTree() { | |
280 return tree; | |
281 } | |
282 | |
283 /* | |
284 * (non-Javadoc) | |
285 * | |
286 * @see dwtx.jface.viewers.AbstractTreeViewer#hookControl(dwt.widgets.Control) | |
287 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
288 protected override void hookControl(Control control) { |
10 | 289 super.hookControl(control); |
290 Tree treeControl = cast(Tree) control; | |
291 | |
292 if ((treeControl.getStyle() & DWT.VIRTUAL) !is 0) { | |
293 treeControl.addDisposeListener(new class DisposeListener { | |
294 public void widgetDisposed(DisposeEvent e) { | |
295 treeIsDisposed = true; | |
296 unmapAllElements(); | |
297 } | |
298 }); | |
299 treeControl.addListener(DWT.SetData, new class Listener { | |
300 | |
301 public void handleEvent(Event event) { | |
302 if (contentProviderIsLazy) { | |
303 TreeItem item = cast(TreeItem) event.item; | |
304 TreeItem parentItem = item.getParentItem(); | |
305 int index = event.index; | |
306 virtualLazyUpdateWidget( | |
307 parentItem is null ? cast(Widget) getTree() | |
308 : parentItem, index); | |
309 } | |
310 } | |
311 | |
312 }); | |
313 } | |
314 } | |
315 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
316 protected override ColumnViewerEditor createViewerEditor() { |
10 | 317 return new TreeViewerEditor(this,null,new ColumnViewerEditorActivationStrategy(this),ColumnViewerEditor.DEFAULT); |
318 } | |
319 | |
320 /* | |
321 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
322 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
323 protected override Item newItem(Widget parent, int flags, int ix) { |
10 | 324 TreeItem item; |
325 | |
326 if ( cast(TreeItem)parent ) { | |
327 item = cast(TreeItem) createNewRowPart(getViewerRowFromItem(parent), | |
328 flags, ix).getItem(); | |
329 } else { | |
330 item = cast(TreeItem) createNewRowPart(null, flags, ix).getItem(); | |
331 } | |
332 | |
333 return item; | |
334 } | |
335 | |
336 /* | |
337 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
338 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
339 protected override void removeAll(Control widget) { |
10 | 340 (cast(Tree) widget).removeAll(); |
341 } | |
342 | |
343 /* | |
344 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
345 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
346 protected override void setExpanded(Item node, bool expand) { |
10 | 347 (cast(TreeItem) node).setExpanded(expand); |
348 if (contentProviderIsLazy) { | |
349 // force repaints to happen | |
350 getControl().update(); | |
351 } | |
352 } | |
353 | |
354 /* | |
355 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
356 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
357 protected override void setSelection(SeqView!(Item) items) { |
10 | 358 |
359 Item[] current = getSelection(getTree()); | |
360 | |
361 // Don't bother resetting the same selection | |
362 if (isSameSelection(items, current)) { | |
363 return; | |
364 } | |
365 | |
366 getTree().setSelection( cast(TreeItem[]) items.toArray()); | |
367 } | |
368 | |
369 /* | |
370 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
371 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
372 protected override void showItem(Item item) { |
10 | 373 getTree().showItem(cast(TreeItem) item); |
374 } | |
375 | |
376 /* | |
377 * (non-Javadoc) | |
378 * | |
379 * @see dwtx.jface.viewers.AbstractTreeViewer#getChild(dwt.widgets.Widget, | |
380 * int) | |
381 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
382 protected override Item getChild(Widget widget, int index) { |
10 | 383 if (auto ti = cast(TreeItem)widget ) { |
384 return ti.getItem(index); | |
385 } | |
386 if (auto t = cast(Tree)widget ) { | |
387 return t.getItem(index); | |
388 } | |
389 return null; | |
390 } | |
391 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
392 protected override void assertContentProviderType(IContentProvider provider) { |
10 | 393 if ( null !is cast(ILazyTreeContentProvider)provider |
394 || null !is cast(ILazyTreePathContentProvider)provider ) { | |
395 return; | |
396 } | |
397 super.assertContentProviderType(provider); | |
398 } | |
399 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
400 protected override Object[] getRawChildren(Object parent) { |
10 | 401 if (contentProviderIsLazy) { |
402 return new Object[0]; | |
403 } | |
404 return super.getRawChildren(parent); | |
405 } | |
406 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
407 override void preservingSelection(Runnable updateCode, bool reveal) { |
10 | 408 if (preservingSelection_){ |
409 // avoid preserving the selection if called reentrantly, | |
410 // see bug 172640 | |
411 updateCode.run(); | |
412 return; | |
413 } | |
414 preservingSelection_ = true; | |
415 try { | |
416 super.preservingSelection(updateCode, reveal); | |
417 } finally { | |
418 preservingSelection_ = false; | |
419 } | |
420 } | |
421 | |
422 /** | |
423 * For a TreeViewer with a tree with the VIRTUAL style bit set, set the | |
424 * number of children of the given element or tree path. To set the number | |
425 * of children of the invisible root of the tree, you can pass the input | |
426 * object or an empty tree path. | |
427 * | |
428 * @param elementOrTreePath | |
429 * the element, or tree path | |
430 * @param count | |
431 * | |
432 * @since 3.2 | |
433 */ | |
434 public void setChildCount(Object elementOrTreePath, int count) { | |
435 if (isBusy()) | |
436 return; | |
39 | 437 preservingSelection(new class(elementOrTreePath,count) Runnable { |
10 | 438 Object elementOrTreePath_; |
439 int count_; | |
39 | 440 this(Object a,int b){ |
441 elementOrTreePath_=a; | |
442 count_=b; | |
10 | 443 } |
444 public void run() { | |
445 if (internalIsInputOrEmptyPath(elementOrTreePath_)) { | |
446 getTree().setItemCount(count_); | |
447 return; | |
448 } | |
449 Widget[] items = internalFindItems(elementOrTreePath_); | |
450 for (int i = 0; i < items.length; i++) { | |
451 TreeItem treeItem = cast(TreeItem) items[i]; | |
452 treeItem.setItemCount(count_); | |
453 } | |
454 } | |
455 }); | |
456 } | |
457 | |
458 /** | |
459 * For a TreeViewer with a tree with the VIRTUAL style bit set, replace the | |
460 * given parent's child at index with the given element. If the given parent | |
461 * is this viewer's input or an empty tree path, this will replace the root | |
462 * element at the given index. | |
463 * <p> | |
464 * This method should be called by implementers of ILazyTreeContentProvider | |
465 * to populate this viewer. | |
466 * </p> | |
467 * | |
468 * @param parentElementOrTreePath | |
469 * the parent of the element that should be updated, or the tree | |
470 * path to that parent | |
471 * @param index | |
472 * the index in the parent's children | |
473 * @param element | |
474 * the new element | |
475 * | |
476 * @see #setChildCount(Object, int) | |
477 * @see ILazyTreeContentProvider | |
478 * @see ILazyTreePathContentProvider | |
479 * | |
480 * @since 3.2 | |
481 */ | |
482 public void replace(Object parentElementOrTreePath, int index, | |
483 Object element) { | |
484 if (isBusy()) | |
485 return; | |
486 Item[] selectedItems = getSelection(getControl()); | |
487 TreeSelection selection = cast(TreeSelection) getSelection(); | |
488 Widget[] itemsToDisassociate; | |
489 if (auto tp = cast(TreePath)parentElementOrTreePath ) { | |
490 TreePath elementPath = tp | |
491 .createChildPath(element); | |
492 itemsToDisassociate = internalFindItems(elementPath); | |
493 } else { | |
494 itemsToDisassociate = internalFindItems(element); | |
495 } | |
496 if (internalIsInputOrEmptyPath(parentElementOrTreePath)) { | |
497 if (index < tree.getItemCount()) { | |
498 TreeItem item = tree.getItem(index); | |
499 selection = adjustSelectionForReplace(selectedItems, selection, item, element, getRoot()); | |
500 // disassociate any different item that represents the | |
501 // same element under the same parent (the tree) | |
502 for (int i = 0; i < itemsToDisassociate.length; i++) { | |
503 if (auto itemToDisassociate = cast(TreeItem)itemsToDisassociate[i]) { | |
504 if (itemToDisassociate !is item | |
505 && itemToDisassociate.getParentItem() is null) { | |
506 int indexToDisassociate = getTree().indexOf( | |
507 itemToDisassociate); | |
508 disassociate(itemToDisassociate); | |
509 getTree().clear(indexToDisassociate, true); | |
510 } | |
511 } | |
512 } | |
513 Object oldData = item.getData(); | |
514 updateItem(item, element); | |
515 if (!/+TreeViewer.this.+/opEquals(oldData, element)) { | |
516 item.clearAll(true); | |
517 } | |
518 } | |
519 } else { | |
520 Widget[] parentItems = internalFindItems(parentElementOrTreePath); | |
521 for (int i = 0; i < parentItems.length; i++) { | |
522 TreeItem parentItem = cast(TreeItem) parentItems[i]; | |
523 if (index < parentItem.getItemCount()) { | |
524 TreeItem item = parentItem.getItem(index); | |
525 selection = adjustSelectionForReplace(selectedItems, selection, item, element, parentItem.getData()); | |
526 // disassociate any different item that represents the | |
527 // same element under the same parent (the tree) | |
528 for (int j = 0; j < itemsToDisassociate.length; j++) { | |
529 if ( auto itemToDisassociate = cast(TreeItem)itemsToDisassociate[j] ) { | |
530 if (itemToDisassociate !is item | |
531 && itemToDisassociate.getParentItem() is parentItem) { | |
532 int indexToDisaccociate = parentItem | |
533 .indexOf(itemToDisassociate); | |
534 disassociate(itemToDisassociate); | |
535 parentItem.clear(indexToDisaccociate, true); | |
536 } | |
537 } | |
538 } | |
539 Object oldData = item.getData(); | |
540 updateItem(item, element); | |
541 if (!/+TreeViewer.this.+/opEquals(oldData, element)) { | |
542 item.clearAll(true); | |
543 } | |
544 } | |
545 } | |
546 } | |
547 // Restore the selection if we are not already in a nested preservingSelection: | |
548 if (!preservingSelection_) { | |
549 setSelectionToWidget(selection, false); | |
550 // send out notification if old and new differ | |
551 ISelection newSelection = getSelection(); | |
552 if (!(cast(Object)newSelection).opEquals(cast(Object)selection)) { | |
553 handleInvalidSelection(selection, newSelection); | |
554 } | |
555 } | |
556 } | |
557 | |
558 /** | |
559 * Fix for bug 185673: If the currently replaced item was selected, add it | |
560 * to the selection that is being restored. Only do this if its getData() is | |
561 * currently null | |
562 * | |
563 * @param selectedItems | |
564 * @param selection | |
565 * @param item | |
566 * @param element | |
567 * @return | |
568 */ | |
569 private TreeSelection adjustSelectionForReplace(Item[] selectedItems, | |
570 TreeSelection selection, TreeItem item, Object element, Object parentElement) { | |
571 if (item.getData() !is null || selectedItems.length is selection.size() | |
572 || parentElement is null) { | |
573 // Don't do anything - we are not seeing an instance of bug 185673 | |
574 return selection; | |
575 } | |
576 for (int i = 0; i < selectedItems.length; i++) { | |
577 if (item is selectedItems[i]) { | |
578 // The current item was selected, but its data is null. | |
579 // The data will be replaced by the given element, so to keep | |
580 // it selected, we have to add it to the selection. | |
581 TreePath[] originalPaths = selection.getPaths(); | |
582 int length_ = originalPaths.length; | |
583 TreePath[] paths = new TreePath[length_ + 1]; | |
584 System.arraycopy(originalPaths, 0, paths, 0, length_); | |
585 // set the element temporarily so that we can call getTreePathFromItem | |
586 item.setData(element); | |
587 paths[length_] = getTreePathFromItem(item); | |
588 item.setData(null); | |
589 return new TreeSelection(paths, selection.getElementComparer()); | |
590 } | |
591 } | |
592 // The item was not selected, return the given selection | |
593 return selection; | |
594 } | |
595 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
596 public override bool isExpandable(Object element) { |
10 | 597 if (contentProviderIsLazy) { |
598 TreeItem treeItem = cast(TreeItem) internalExpand(element, false); | |
599 if (treeItem is null) { | |
600 return false; | |
601 } | |
602 virtualMaterializeItem(treeItem); | |
603 return treeItem.getItemCount() > 0; | |
604 } | |
605 return super.isExpandable(element); | |
606 } | |
607 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
608 protected override Object getParentElement(Object element) { |
10 | 609 bool oldBusy = busy; |
610 busy = true; | |
611 try { | |
612 if (contentProviderIsLazy && !contentProviderIsTreeBased && !(cast(TreePath)element )) { | |
613 ILazyTreeContentProvider lazyTreeContentProvider = cast(ILazyTreeContentProvider) getContentProvider(); | |
614 return lazyTreeContentProvider.getParent(element); | |
615 } | |
616 if (contentProviderIsLazy && contentProviderIsTreeBased && !(cast(TreePath)element )) { | |
617 ILazyTreePathContentProvider lazyTreePathContentProvider = cast(ILazyTreePathContentProvider) getContentProvider(); | |
618 TreePath[] parents = lazyTreePathContentProvider | |
619 .getParents(element); | |
620 if (parents !is null && parents.length > 0) { | |
621 return parents[0]; | |
622 } | |
623 } | |
624 return super.getParentElement(element); | |
625 } finally { | |
626 busy = oldBusy; | |
627 } | |
628 } | |
629 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
630 protected override void createChildren(Widget widget) { |
10 | 631 if (contentProviderIsLazy) { |
632 Object element = widget.getData(); | |
633 if (element is null && cast(TreeItem)widget ) { | |
634 // parent has not been materialized | |
635 virtualMaterializeItem(cast(TreeItem) widget); | |
636 // try getting the element now that updateElement was called | |
637 element = widget.getData(); | |
638 } | |
639 if (element is null) { | |
640 // give up because the parent is still not materialized | |
641 return; | |
642 } | |
643 Item[] children = getChildren(widget); | |
644 if (children.length is 1 && children[0].getData() is null) { | |
645 // found a dummy node | |
646 virtualLazyUpdateChildCount(widget, children.length); | |
647 children = getChildren(widget); | |
648 } | |
649 // touch all children to make sure they are materialized | |
650 for (int i = 0; i < children.length; i++) { | |
651 if (children[i].getData() is null) { | |
652 virtualLazyUpdateWidget(widget, i); | |
653 } | |
654 } | |
655 return; | |
656 } | |
657 super.createChildren(widget); | |
658 } | |
659 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
660 protected override void internalAdd(Widget widget, Object parentElement, |
10 | 661 Object[] childElements) { |
662 if (contentProviderIsLazy) { | |
663 if (auto ti = cast(TreeItem)widget ) { | |
664 int count = ti.getItemCount() + childElements.length; | |
665 ti.setItemCount(count); | |
666 ti.clearAll(false); | |
667 } else { | |
668 Tree t = cast(Tree) widget; | |
669 t.setItemCount(t.getItemCount() + childElements.length); | |
670 t.clearAll(false); | |
671 } | |
672 return; | |
673 } | |
674 super.internalAdd(widget, parentElement, childElements); | |
675 } | |
676 | |
677 private void virtualMaterializeItem(TreeItem treeItem) { | |
678 if (treeItem.getData() !is null) { | |
679 // already materialized | |
680 return; | |
681 } | |
682 if (!contentProviderIsLazy) { | |
683 return; | |
684 } | |
685 int index; | |
686 Widget parent = treeItem.getParentItem(); | |
687 if (parent is null) { | |
688 parent = treeItem.getParent(); | |
689 } | |
690 Object parentElement = parent.getData(); | |
691 if (parentElement !is null) { | |
692 if ( auto t = cast(Tree)parent ) { | |
693 index = t.indexOf(treeItem); | |
694 } else { | |
695 index = (cast(TreeItem) parent).indexOf(treeItem); | |
696 } | |
697 virtualLazyUpdateWidget(parent, index); | |
698 } | |
699 } | |
700 | |
701 /* | |
702 * (non-Javadoc) | |
703 * | |
704 * @see dwtx.jface.viewers.AbstractTreeViewer#internalRefreshStruct(dwt.widgets.Widget, | |
705 * java.lang.Object, bool) | |
706 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
707 protected override void internalRefreshStruct(Widget widget, Object element, |
10 | 708 bool updateLabels) { |
709 if (contentProviderIsLazy) { | |
710 // clear all starting with the given widget | |
711 if (auto t = cast(Tree)widget ) { | |
712 t.clearAll(true); | |
713 } else if (cast(TreeItem)widget ) { | |
714 (cast(TreeItem) widget).clearAll(true); | |
715 } | |
716 int index = 0; | |
717 Widget parent = null; | |
718 if (auto treeItem = cast(TreeItem)widget ) { | |
719 parent = treeItem.getParentItem(); | |
720 if (parent is null) { | |
721 parent = treeItem.getParent(); | |
722 } | |
723 if (cast(Tree)parent ) { | |
724 index = (cast(Tree) parent).indexOf(treeItem); | |
725 } else { | |
726 index = (cast(TreeItem) parent).indexOf(treeItem); | |
727 } | |
728 } | |
729 virtualRefreshExpandedItems(parent, widget, element, index); | |
730 return; | |
731 } | |
732 super.internalRefreshStruct(widget, element, updateLabels); | |
733 } | |
734 | |
735 /** | |
736 * Traverses the visible (expanded) part of the tree and updates child | |
737 * counts. | |
738 * | |
739 * @param parent the parent of the widget, or <code>null</code> if the widget is the tree | |
740 * @param widget | |
741 * @param element | |
742 * @param index the index of the widget in the children array of its parent, or 0 if the widget is the tree | |
743 */ | |
744 private void virtualRefreshExpandedItems(Widget parent, Widget widget, Object element, int index) { | |
745 if ( cast(Tree)widget ) { | |
746 if (element is null) { | |
747 (cast(Tree) widget).setItemCount(0); | |
748 return; | |
749 } | |
750 virtualLazyUpdateChildCount(widget, getChildren(widget).length); | |
751 } else if ((cast(TreeItem) widget).getExpanded()) { | |
752 // prevent SetData callback | |
753 (cast(TreeItem)widget).setText(" "); //$NON-NLS-1$ | |
754 virtualLazyUpdateWidget(parent, index); | |
755 } else { | |
756 return; | |
757 } | |
758 Item[] items = getChildren(widget); | |
759 for (int i = 0; i < items.length; i++) { | |
760 Item item = items[i]; | |
761 Object data = item.getData(); | |
762 virtualRefreshExpandedItems(widget, item, data, i); | |
763 } | |
764 } | |
765 | |
766 /* | |
767 * To unmap elements correctly, we need to register a dispose listener with | |
768 * the item if the tree is virtual. | |
769 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
770 protected override void mapElement(Object element, Widget item) { |
10 | 771 super.mapElement(element, item); |
772 // make sure to unmap elements if the tree is virtual | |
773 if ((getTree().getStyle() & DWT.VIRTUAL) !is 0) { | |
774 // only add a dispose listener if item hasn't already on assigned | |
775 // because it is reused | |
776 if (item.getData(VIRTUAL_DISPOSE_KEY) is null) { | |
777 item.setData(VIRTUAL_DISPOSE_KEY, new ValueWrapperBool(true)); | |
39 | 778 item.addDisposeListener(new class(item) DisposeListener { |
10 | 779 Widget item_; |
39 | 780 this(Widget a){ |
781 item_=a; | |
10 | 782 } |
783 public void widgetDisposed(DisposeEvent e) { | |
784 if (!treeIsDisposed) { | |
785 Object data = item_.getData(); | |
786 if (usingElementMap() && data !is null) { | |
787 unmapElement(data, item_); | |
788 } | |
789 } | |
790 } | |
791 }); | |
792 } | |
793 } | |
794 } | |
795 | |
796 /* | |
797 * (non-Javadoc) | |
798 * | |
799 * @see dwtx.jface.viewers.ColumnViewer#getRowPartFromItem(dwt.widgets.Widget) | |
800 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
801 protected override ViewerRow getViewerRowFromItem(Widget item) { |
10 | 802 if( cachedRow is null ) { |
803 cachedRow = new TreeViewerRow(cast(TreeItem) item); | |
804 } else { | |
805 cachedRow.setItem(cast(TreeItem) item); | |
806 } | |
807 | |
808 return cachedRow; | |
809 } | |
810 | |
811 /** | |
812 * Create a new ViewerRow at rowIndex | |
813 * | |
814 * @param parent | |
815 * @param style | |
816 * @param rowIndex | |
817 * @return ViewerRow | |
818 */ | |
819 private ViewerRow createNewRowPart(ViewerRow parent, int style, int rowIndex) { | |
820 if (parent is null) { | |
821 if (rowIndex >= 0) { | |
822 return getViewerRowFromItem(new TreeItem(tree, style, rowIndex)); | |
823 } | |
824 return getViewerRowFromItem(new TreeItem(tree, style)); | |
825 } | |
826 | |
827 if (rowIndex >= 0) { | |
828 return getViewerRowFromItem(new TreeItem(cast(TreeItem) parent.getItem(), | |
829 DWT.NONE, rowIndex)); | |
830 } | |
831 | |
832 return getViewerRowFromItem(new TreeItem(cast(TreeItem) parent.getItem(), | |
833 DWT.NONE)); | |
834 } | |
835 | |
836 /* | |
837 * (non-Javadoc) | |
838 * | |
839 * @see dwtx.jface.viewers.AbstractTreeViewer#internalInitializeTree(dwt.widgets.Control) | |
840 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
841 protected override void internalInitializeTree(Control widget) { |
10 | 842 if (contentProviderIsLazy) { |
843 if (cast(Tree)widget && widget.getData() !is null) { | |
844 virtualLazyUpdateChildCount(widget, 0); | |
845 return; | |
846 } | |
847 } | |
848 super.internalInitializeTree(tree); | |
849 } | |
850 | |
851 /* | |
852 * (non-Javadoc) | |
853 * | |
854 * @see dwtx.jface.viewers.AbstractTreeViewer#updatePlus(dwt.widgets.Item, | |
855 * java.lang.Object) | |
856 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
857 protected override void updatePlus(Item item, Object element) { |
10 | 858 if (contentProviderIsLazy) { |
859 Object data = item.getData(); | |
860 int itemCount = 0; | |
861 if (data !is null) { | |
862 // item is already materialized | |
863 itemCount = (cast(TreeItem) item).getItemCount(); | |
864 } | |
865 virtualLazyUpdateHasChildren(item, itemCount); | |
866 } else { | |
867 super.updatePlus(item, element); | |
868 } | |
869 } | |
870 | |
871 /** | |
872 * Removes the element at the specified index of the parent. The selection is updated if required. | |
873 * | |
874 * @param parentOrTreePath the parent element, the input element, or a tree path to the parent element | |
875 * @param index child index | |
876 * @since 3.3 | |
877 */ | |
878 public void remove(Object parentOrTreePath_, int index_) { | |
879 if (isBusy()) | |
880 return; | |
39 | 881 preservingSelection(new class((cast(TreeSelection) getSelection()).getPaths(),parentOrTreePath_,index_) Runnable { |
10 | 882 Seq!(TreePath) oldSelection; |
883 Object parentOrTreePath; | |
884 int index; | |
39 | 885 this(TreePath[] a,Object b,int c){ |
886 parentOrTreePath=b; | |
887 index=c; | |
10 | 888 oldSelection = new LinkSeq!(TreePath); |
39 | 889 foreach( p; a){ |
10 | 890 oldSelection.append( p ); |
891 } | |
892 } | |
893 public void run() { | |
894 TreePath removedPath = null; | |
895 if (internalIsInputOrEmptyPath(parentOrTreePath)) { | |
896 Tree tree = cast(Tree) getControl(); | |
897 if (index < tree.getItemCount()) { | |
898 TreeItem item = tree.getItem(index); | |
899 if (item.getData() !is null) { | |
900 removedPath = getTreePathFromItem(item); | |
901 disassociate(item); | |
902 } | |
903 item.dispose(); | |
904 } | |
905 } else { | |
906 Widget[] parentItems = internalFindItems(parentOrTreePath); | |
907 for (int i = 0; i < parentItems.length; i++) { | |
908 TreeItem parentItem = cast(TreeItem) parentItems[i]; | |
909 if (index < parentItem.getItemCount()) { | |
910 TreeItem item = parentItem.getItem(index); | |
911 if (item.getData() !is null) { | |
912 removedPath = getTreePathFromItem(item); | |
913 disassociate(item); | |
914 } | |
915 item.dispose(); | |
916 } | |
917 } | |
918 } | |
919 if (removedPath !is null) { | |
920 bool removed = false; | |
921 int delIdx = 0; | |
922 foreach ( path; oldSelection.dup ) { | |
923 if (path.startsWith(removedPath, getComparer())) { | |
924 oldSelection.removeAt(delIdx); | |
925 removed = true; | |
926 } | |
927 delIdx++; | |
928 } | |
929 if (removed) { | |
930 setSelection(new TreeSelection( | |
931 oldSelection.toArray(), getComparer()), | |
932 false); | |
933 } | |
934 | |
935 } | |
936 } | |
937 }); | |
938 } | |
939 | |
940 /* (non-Javadoc) | |
941 * @see dwtx.jface.viewers.AbstractTreeViewer#handleTreeExpand(dwt.events.TreeEvent) | |
942 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
943 protected override void handleTreeExpand(TreeEvent event) { |
10 | 944 if (contentProviderIsLazy) { |
945 if (event.item.getData() !is null) { | |
946 Item[] children = getChildren(event.item); | |
947 if (children.length is 1 && children[0].getData() is null) { | |
948 // we have a dummy child node, ask for an updated child | |
949 // count | |
950 virtualLazyUpdateChildCount(event.item, children.length); | |
951 } | |
952 fireTreeExpanded(new TreeExpansionEvent(this, event.item | |
953 .getData())); | |
954 } | |
955 return; | |
956 } | |
957 super.handleTreeExpand(event); | |
958 } | |
959 | |
960 /* (non-Javadoc) | |
961 * @see dwtx.jface.viewers.AbstractTreeViewer#setContentProvider(dwtx.jface.viewers.IContentProvider) | |
962 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
963 public override void setContentProvider(IContentProvider provider) { |
10 | 964 contentProviderIsLazy = (cast(ILazyTreeContentProvider)provider ) |
965 || (cast(ILazyTreePathContentProvider)provider ); | |
966 contentProviderIsTreeBased = null !is cast(ILazyTreePathContentProvider)provider ; | |
967 super.setContentProvider(provider); | |
968 } | |
969 | |
970 /** | |
971 * For a TreeViewer with a tree with the VIRTUAL style bit set, inform the | |
972 * viewer about whether the given element or tree path has children. Avoid | |
973 * calling this method if the number of children has already been set. | |
974 * | |
975 * @param elementOrTreePath | |
976 * the element, or tree path | |
977 * @param hasChildren | |
978 * | |
979 * @since 3.3 | |
980 */ | |
981 public void setHasChildren(Object elementOrTreePath_, bool hasChildren_) { | |
982 if (isBusy()) | |
983 return; | |
39 | 984 preservingSelection(new class(elementOrTreePath_,hasChildren_) Runnable { |
10 | 985 Object elementOrTreePath; |
986 bool hasChildren; | |
39 | 987 this(Object a,bool b){ |
988 elementOrTreePath=a; | |
989 hasChildren=b; | |
10 | 990 } |
991 public void run() { | |
992 if (internalIsInputOrEmptyPath(elementOrTreePath)) { | |
993 if (hasChildren) { | |
994 virtualLazyUpdateChildCount(getTree(), | |
995 getChildren(getTree()).length); | |
996 } else { | |
997 setChildCount(elementOrTreePath, 0); | |
998 } | |
999 return; | |
1000 } | |
1001 Widget[] items = internalFindItems(elementOrTreePath); | |
1002 for (int i = 0; i < items.length; i++) { | |
1003 TreeItem item = cast(TreeItem) items[i]; | |
1004 if (!hasChildren) { | |
1005 item.setItemCount(0); | |
1006 } else { | |
1007 if (!item.getExpanded()) { | |
1008 item.setItemCount(1); | |
1009 TreeItem child = item.getItem(0); | |
1010 if (child.getData() !is null) { | |
1011 disassociate(child); | |
1012 } | |
1013 item.clear(0, true); | |
1014 } else { | |
1015 virtualLazyUpdateChildCount(item, item.getItemCount()); | |
1016 } | |
1017 } | |
1018 } | |
1019 } | |
1020 }); | |
1021 } | |
1022 | |
1023 /** | |
1024 * Update the widget at index. | |
1025 * @param widget | |
1026 * @param index | |
1027 */ | |
1028 private void virtualLazyUpdateWidget(Widget widget, int index) { | |
1029 bool oldBusy = busy; | |
1030 busy = false; | |
1031 try { | |
1032 if (contentProviderIsTreeBased) { | |
1033 TreePath treePath; | |
1034 if ( auto i = cast(Item)widget ) { | |
1035 if (widget.getData() is null) { | |
1036 // we need to materialize the parent first | |
1037 // see bug 167668 | |
1038 // however, that would be too risky | |
1039 // see bug 182782 and bug 182598 | |
1040 // so we just ignore this call altogether | |
1041 // and don't do this: virtualMaterializeItem((TreeItem) widget); | |
1042 return; | |
1043 } | |
1044 treePath = getTreePathFromItem(i); | |
1045 } else { | |
1046 treePath = TreePath.EMPTY; | |
1047 } | |
1048 (cast(ILazyTreePathContentProvider) getContentProvider()) | |
1049 .updateElement(treePath, index); | |
1050 } else { | |
1051 (cast(ILazyTreeContentProvider) getContentProvider()).updateElement( | |
1052 widget.getData(), index); | |
1053 } | |
1054 } finally { | |
1055 busy = oldBusy; | |
1056 } | |
1057 } | |
1058 | |
1059 /** | |
1060 * Update the child count | |
1061 * @param widget | |
1062 * @param currentChildCount | |
1063 */ | |
1064 private void virtualLazyUpdateChildCount(Widget widget, int currentChildCount) { | |
1065 bool oldBusy = busy; | |
1066 busy = false; | |
1067 try { | |
1068 if (contentProviderIsTreeBased) { | |
1069 TreePath treePath; | |
1070 if (cast(Item)widget ) { | |
1071 treePath = getTreePathFromItem(cast(Item) widget); | |
1072 } else { | |
1073 treePath = TreePath.EMPTY; | |
1074 } | |
1075 (cast(ILazyTreePathContentProvider) getContentProvider()) | |
1076 .updateChildCount(treePath, currentChildCount); | |
1077 } else { | |
1078 (cast(ILazyTreeContentProvider) getContentProvider()).updateChildCount(widget.getData(), currentChildCount); | |
1079 } | |
1080 } finally { | |
1081 busy = oldBusy; | |
1082 } | |
1083 } | |
1084 | |
1085 /** | |
1086 * Update the item with the current child count. | |
1087 * @param item | |
1088 * @param currentChildCount | |
1089 */ | |
1090 private void virtualLazyUpdateHasChildren(Item item, int currentChildCount) { | |
1091 bool oldBusy = busy; | |
1092 busy = false; | |
1093 try { | |
1094 if (contentProviderIsTreeBased) { | |
1095 TreePath treePath; | |
1096 treePath = getTreePathFromItem(item); | |
1097 if (currentChildCount is 0) { | |
1098 // item is not expanded (but may have a plus currently) | |
1099 (cast(ILazyTreePathContentProvider) getContentProvider()) | |
1100 .updateHasChildren(treePath); | |
1101 } else { | |
1102 (cast(ILazyTreePathContentProvider) getContentProvider()) | |
1103 .updateChildCount(treePath, currentChildCount); | |
1104 } | |
1105 } else { | |
1106 (cast(ILazyTreeContentProvider) getContentProvider()).updateChildCount(item.getData(), currentChildCount); | |
1107 } | |
1108 } finally { | |
1109 busy = oldBusy; | |
1110 } | |
1111 } | |
1112 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
1113 protected override void disassociate(Item item) { |
10 | 1114 if (contentProviderIsLazy) { |
1115 // avoid causing a callback: | |
1116 item.setText(" "); //$NON-NLS-1$ | |
1117 } | |
1118 super.disassociate(item); | |
1119 } | |
1120 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
1121 protected override int doGetColumnCount() { |
10 | 1122 return tree.getColumnCount(); |
1123 } | |
1124 | |
1125 /** | |
1126 * Sets a new selection for this viewer and optionally makes it visible. | |
1127 * <p> | |
1128 * <b>Currently the <code>reveal</code> parameter is not honored because | |
1129 * {@link Tree} does not provide an API to only select an item without | |
1130 * scrolling it into view</b> | |
1131 * </p> | |
1132 * | |
1133 * @param selection | |
1134 * the new selection | |
1135 * @param reveal | |
1136 * <code>true</code> if the selection is to be made visible, | |
1137 * and <code>false</code> otherwise | |
1138 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
1139 public override void setSelection(ISelection selection, bool reveal) { |
10 | 1140 super.setSelection(selection, reveal); |
1141 } | |
1142 | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
40
diff
changeset
|
1143 public override void editElement(Object element, int column) { |
10 | 1144 if( cast(TreePath)element ) { |
1145 setSelection(new TreeSelection(cast(TreePath) element)); | |
1146 TreeItem[] items = tree.getSelection(); | |
1147 | |
1148 if( items.length is 1 ) { | |
1149 ViewerRow row = getViewerRowFromItem(items[0]); | |
1150 | |
1151 if (row !is null) { | |
1152 ViewerCell cell = row.getCell(column); | |
1153 if (cell !is null) { | |
1154 getControl().setRedraw(false); | |
1155 try { | |
1156 triggerEditorActivationEvent(new ColumnViewerEditorActivationEvent(cell)); | |
1157 } finally { | |
1158 getControl().setRedraw(true); | |
1159 } | |
1160 } | |
1161 } | |
1162 } | |
1163 } else { | |
1164 super.editElement(element, column); | |
1165 } | |
1166 } | |
1167 } |