Mercurial > projects > dwt-addons
annotate dwtx/jface/viewers/TableTreeViewer.d @ 69:07b9d96fd764
Make nested class CellEditor.LayoutData a top level class to omit compiler errors "forward reference"
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Mon, 19 May 2008 13:41:06 +0200 |
parents | ea8ff534f622 |
children | 7ffeace6c47f |
rev | line source |
---|---|
10 | 1 /******************************************************************************* |
2 * Copyright (c) 2000, 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> - bug 153993 | |
11 * Port to the D programming language: | |
12 * Frank Benoit <benoit@tionex.de> | |
13 *******************************************************************************/ | |
14 | |
15 module dwtx.jface.viewers.TableTreeViewer; | |
16 | |
17 import dwtx.jface.viewers.AbstractTreeViewer; | |
18 import dwtx.jface.viewers.CellEditor; | |
19 import dwtx.jface.viewers.ICellEditorListener; | |
20 import dwtx.jface.viewers.ICellModifier; | |
21 import dwtx.jface.viewers.ColumnViewer; | |
22 import dwtx.jface.viewers.IBaseLabelProvider; | |
23 import dwtx.jface.viewers.StructuredSelection; | |
24 import dwtx.jface.viewers.Viewer; | |
25 import dwtx.jface.viewers.DoubleClickEvent; | |
26 import dwtx.jface.viewers.OpenEvent; | |
27 import dwtx.jface.viewers.ITableLabelProvider; | |
28 import dwtx.jface.viewers.ViewerLabel; | |
29 | |
30 import tango.util.collection.model.SeqView; | |
31 | |
32 import dwt.DWT; | |
33 import dwt.custom.TableTree; | |
34 import dwt.custom.TableTreeEditor; | |
35 import dwt.custom.TableTreeItem; | |
36 import dwt.events.FocusAdapter; | |
37 import dwt.events.FocusEvent; | |
38 import dwt.events.FocusListener; | |
39 import dwt.events.MouseAdapter; | |
40 import dwt.events.MouseEvent; | |
41 import dwt.events.MouseListener; | |
42 import dwt.events.TreeListener; | |
43 import dwt.graphics.Image; | |
44 import dwt.graphics.Point; | |
45 import dwt.graphics.Rectangle; | |
46 import dwt.widgets.Composite; | |
47 import dwt.widgets.Control; | |
48 import dwt.widgets.Display; | |
49 import dwt.widgets.Item; | |
50 import dwt.widgets.Widget; | |
51 | |
52 import dwt.dwthelper.utils; | |
53 | |
54 /** | |
55 * A concrete viewer based on a DWT <code>TableTree</code> control. | |
56 * <p> | |
57 * This class is not intended to be subclassed outside the viewer framework. It | |
58 * is designed to be instantiated with a pre-existing DWT table tree control and | |
59 * configured with a domain-specific content provider, label provider, element | |
60 * filter (optional), and element sorter (optional). | |
61 * </p> | |
62 * <p> | |
63 * Content providers for table tree viewers must implement the | |
64 * <code>ITreeContentProvider</code> interface. | |
65 * </p> | |
66 * <p> | |
67 * Label providers for table tree viewers must implement either the | |
68 * <code>ITableLabelProvider</code> or the <code>ILabelProvider</code> | |
69 * interface (see <code>TableTreeViewer.setLabelProvider</code> for more | |
70 * details). | |
71 * </p> | |
72 * | |
73 * @deprecated As of 3.1 use {@link TreeViewer} instead | |
74 */ | |
75 public class TableTreeViewer : AbstractTreeViewer { | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
76 alias AbstractTreeViewer.addTreeListener addTreeListener; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
77 alias AbstractTreeViewer.doUpdateItem doUpdateItem; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
78 alias AbstractTreeViewer.getLabelProvider getLabelProvider; |
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
79 alias AbstractTreeViewer.getSelection getSelection; |
10 | 80 alias AbstractTreeViewer.setSelection setSelection; |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
81 |
10 | 82 /** |
83 * Internal table viewer implementation. | |
84 */ | |
85 private TableTreeEditorImpl tableEditorImpl; | |
86 | |
87 /** | |
88 * This viewer's table tree control. | |
89 */ | |
90 private TableTree tableTree; | |
91 | |
92 /** | |
93 * This viewer's table tree editor. | |
94 */ | |
95 private TableTreeEditor tableTreeEditor; | |
96 | |
97 /** | |
98 * Copied from original TableEditorImpl and moved here since refactoring | |
99 * completely wiped out the original implementation in 3.3 | |
100 * | |
101 * @since 3.1 | |
102 */ | |
103 class TableTreeEditorImpl { | |
104 | |
105 private CellEditor cellEditor; | |
106 | |
107 private CellEditor[] cellEditors; | |
108 | |
109 private ICellModifier cellModifier; | |
110 | |
111 private String[] columnProperties; | |
112 | |
113 private Item tableItem; | |
114 | |
115 private int columnNumber; | |
116 | |
117 private ICellEditorListener cellEditorListener; | |
118 | |
119 private FocusListener focusListener; | |
120 | |
121 private MouseListener mouseListener; | |
122 | |
123 private int doubleClickExpirationTime; | |
124 | |
125 private ColumnViewer viewer; | |
126 | |
127 private this(ColumnViewer viewer) { | |
128 this.viewer = viewer; | |
129 initCellEditorListener(); | |
130 } | |
131 | |
132 /** | |
133 * Returns this <code>TableViewerImpl</code> viewer | |
134 * | |
135 * @return the viewer | |
136 */ | |
137 public ColumnViewer getViewer() { | |
138 return viewer; | |
139 } | |
140 | |
141 private void activateCellEditor() { | |
142 if( cellEditors !is null ) { | |
143 if( cellEditors[columnNumber] !is null && cellModifier !is null ) { | |
144 Object element = tableItem.getData(); | |
145 String property = columnProperties[columnNumber]; | |
146 | |
147 if( cellModifier.canModify(element, property) ) { | |
148 cellEditor = cellEditors[columnNumber]; | |
149 | |
150 cellEditor.addListener(cellEditorListener); | |
151 | |
152 Object value = cellModifier.getValue(element, property); | |
153 cellEditor.setValue(value); | |
154 // Tricky flow of control here: | |
155 // activate() can trigger callback to cellEditorListener | |
156 // which will clear cellEditor | |
157 // so must get control first, but must still call activate() | |
158 // even if there is no control. | |
159 final Control control = cellEditor.getControl(); | |
160 cellEditor.activate(); | |
161 if (control is null) { | |
162 return; | |
163 } | |
164 setLayoutData(cellEditor.getLayoutData()); | |
165 setEditor(control, tableItem, columnNumber); | |
166 cellEditor.setFocus(); | |
167 if (focusListener is null) { | |
168 focusListener = new class FocusAdapter { | |
169 public void focusLost(FocusEvent e) { | |
170 applyEditorValue(); | |
171 } | |
172 }; | |
173 } | |
174 control.addFocusListener(focusListener); | |
39 | 175 mouseListener = new class(control) MouseAdapter { |
10 | 176 Control control_; |
39 | 177 this(Control a){ |
178 control_=a; | |
10 | 179 } |
180 public void mouseDown(MouseEvent e) { | |
181 // time wrap? | |
182 // check for expiration of doubleClickTime | |
183 if (e.time <= doubleClickExpirationTime) { | |
184 control_.removeMouseListener(mouseListener); | |
185 cancelEditing(); | |
186 handleDoubleClickEvent(); | |
187 } else if (mouseListener !is null) { | |
188 control_.removeMouseListener(mouseListener); | |
189 } | |
190 } | |
191 }; | |
192 control.addMouseListener(mouseListener); | |
193 } | |
194 } | |
195 } | |
196 } | |
197 | |
198 /** | |
199 * Activate a cell editor for the given mouse position. | |
200 */ | |
201 private void activateCellEditor(MouseEvent event) { | |
202 if (tableItem is null || tableItem.isDisposed()) { | |
203 // item no longer exists | |
204 return; | |
205 } | |
206 int columnToEdit; | |
207 int columns = getColumnCount(); | |
208 if (columns is 0) { | |
209 // If no TableColumn, Table acts as if it has a single column | |
210 // which takes the whole width. | |
211 columnToEdit = 0; | |
212 } else { | |
213 columnToEdit = -1; | |
214 for (int i = 0; i < columns; i++) { | |
215 Rectangle bounds = getBounds(tableItem, i); | |
216 if (bounds.contains(event.x, event.y)) { | |
217 columnToEdit = i; | |
218 break; | |
219 } | |
220 } | |
221 if (columnToEdit is -1) { | |
222 return; | |
223 } | |
224 } | |
225 | |
226 columnNumber = columnToEdit; | |
227 activateCellEditor(); | |
228 } | |
229 | |
230 /** | |
231 * Deactivates the currently active cell editor. | |
232 */ | |
233 public void applyEditorValue() { | |
234 CellEditor c = this.cellEditor; | |
235 if (c !is null) { | |
236 // null out cell editor before calling save | |
237 // in case save results in applyEditorValue being re-entered | |
238 // see 1GAHI8Z: ITPUI:ALL - How to code event notification when | |
239 // using cell editor ? | |
240 this.cellEditor = null; | |
241 Item t = this.tableItem; | |
242 // don't null out table item -- same item is still selected | |
243 if (t !is null && !t.isDisposed()) { | |
244 saveEditorValue(c, t); | |
245 } | |
246 setEditor(null, null, 0); | |
247 c.removeListener(cellEditorListener); | |
248 Control control = c.getControl(); | |
249 if (control !is null) { | |
250 if (mouseListener !is null) { | |
251 control.removeMouseListener(mouseListener); | |
252 } | |
253 if (focusListener !is null) { | |
254 control.removeFocusListener(focusListener); | |
255 } | |
256 } | |
257 c.deactivate(); | |
258 } | |
259 } | |
260 | |
261 /** | |
262 * Cancels the active cell editor, without saving the value back to the | |
263 * domain model. | |
264 */ | |
265 public void cancelEditing() { | |
266 if (cellEditor !is null) { | |
267 setEditor(null, null, 0); | |
268 cellEditor.removeListener(cellEditorListener); | |
269 CellEditor oldEditor = cellEditor; | |
270 cellEditor = null; | |
271 oldEditor.deactivate(); | |
272 } | |
273 } | |
274 | |
275 /** | |
276 * Start editing the given element. | |
277 * | |
278 * @param element | |
279 * @param column | |
280 */ | |
281 public void editElement(Object element, int column) { | |
282 if (cellEditor !is null) { | |
283 applyEditorValue(); | |
284 } | |
285 | |
286 setSelection(new StructuredSelection(element), true); | |
287 Item[] selection = getSelection(); | |
288 if (selection.length !is 1) { | |
289 return; | |
290 } | |
291 | |
292 tableItem = selection[0]; | |
293 | |
294 // Make sure selection is visible | |
295 showSelection(); | |
296 columnNumber = column; | |
297 activateCellEditor(); | |
298 | |
299 } | |
300 | |
301 /** | |
302 * Return the array of CellEditors used in the viewer | |
303 * | |
304 * @return the cell editors | |
305 */ | |
306 public CellEditor[] getCellEditors() { | |
307 return cellEditors; | |
308 } | |
309 | |
310 /** | |
311 * Get the cell modifier | |
312 * | |
313 * @return the cell modifier | |
314 */ | |
315 public ICellModifier getCellModifier() { | |
316 return cellModifier; | |
317 } | |
318 | |
319 /** | |
320 * Return the properties for the column | |
321 * | |
322 * @return the array of column properties | |
323 */ | |
324 public Object[] getColumnProperties() { | |
325 Object[] res; | |
326 foreach( str; columnProperties ){ | |
327 res ~= new ArrayWrapperString( str ); | |
328 } | |
329 return res; | |
330 } | |
331 | |
332 /** | |
333 * Handles the mouse down event; activates the cell editor. | |
334 * | |
335 * @param event | |
336 * the mouse event that should be handled | |
337 */ | |
338 public void handleMouseDown(MouseEvent event) { | |
339 if (event.button !is 1) { | |
340 return; | |
341 } | |
342 | |
343 if (cellEditor !is null) { | |
344 applyEditorValue(); | |
345 } | |
346 | |
347 // activate the cell editor immediately. If a second mouseDown | |
348 // is received prior to the expiration of the doubleClick time then | |
349 // the cell editor will be deactivated and a doubleClick event will | |
350 // be processed. | |
351 // | |
352 doubleClickExpirationTime = event.time | |
353 + Display.getCurrent().getDoubleClickTime(); | |
354 | |
355 Item[] items = getSelection(); | |
356 // Do not edit if more than one row is selected. | |
357 if (items.length !is 1) { | |
358 tableItem = null; | |
359 return; | |
360 } | |
361 tableItem = items[0]; | |
362 | |
363 activateCellEditor(event); | |
364 } | |
365 | |
366 private void initCellEditorListener() { | |
367 cellEditorListener = new class ICellEditorListener { | |
368 public void editorValueChanged(bool oldValidState, | |
369 bool newValidState) { | |
370 // Ignore. | |
371 } | |
372 | |
373 public void cancelEditor() { | |
374 this.outer.cancelEditing(); | |
375 } | |
376 | |
377 public void applyEditorValue() { | |
378 this.outer.applyEditorValue(); | |
379 } | |
380 }; | |
381 } | |
382 | |
383 /** | |
384 * Return whether there is an active cell editor. | |
385 * | |
386 * @return <code>true</code> if there is an active cell editor; | |
387 * otherwise <code>false</code> is returned. | |
388 */ | |
389 public bool isCellEditorActive() { | |
390 return cellEditor !is null; | |
391 } | |
392 | |
393 /** | |
394 * Saves the value of the currently active cell editor, by delegating to | |
395 * the cell modifier. | |
396 */ | |
397 private void saveEditorValue(CellEditor cellEditor, Item tableItem) { | |
398 if( cellModifier !is null ) { | |
399 if( ! cellEditor.isValueValid() ) { | |
400 // Do what???? | |
401 } | |
402 } | |
403 String property = null; | |
404 | |
405 if( columnProperties !is null && columnNumber < columnProperties.length ) { | |
406 property = columnProperties[columnNumber]; | |
407 } | |
408 cellModifier.modify(tableItem, property, cellEditor.getValue()); | |
409 } | |
410 | |
411 /** | |
412 * Set the cell editors | |
413 * | |
414 * @param editors | |
415 */ | |
416 public void setCellEditors(CellEditor[] editors) { | |
417 this.cellEditors = editors; | |
418 } | |
419 | |
420 /** | |
421 * Set the cell modifier | |
422 * | |
423 * @param modifier | |
424 */ | |
425 public void setCellModifier(ICellModifier modifier) { | |
426 this.cellModifier = modifier; | |
427 } | |
428 | |
429 /** | |
430 * Set the column properties | |
431 * | |
432 * @param columnProperties | |
433 */ | |
434 public void setColumnProperties(String[] columnProperties) { | |
435 this.columnProperties = columnProperties; | |
436 } | |
437 | |
438 Rectangle getBounds(Item item, int columnNumber) { | |
439 return (cast(TableTreeItem) item).getBounds(columnNumber); | |
440 } | |
441 | |
442 int getColumnCount() { | |
443 // getColumnCount() should be a API in TableTree. | |
444 return getTableTree().getTable().getColumnCount(); | |
445 } | |
446 | |
447 Item[] getSelection() { | |
448 return getTableTree().getSelection(); | |
449 } | |
450 | |
451 void setEditor(Control w, Item item, int columnNumber) { | |
452 tableTreeEditor.setEditor(w, cast(TableTreeItem) item, columnNumber); | |
453 } | |
454 | |
455 void setSelection(StructuredSelection selection, bool b) { | |
456 this.outer.setSelection(selection, b); | |
457 } | |
458 | |
459 void showSelection() { | |
460 getTableTree().showSelection(); | |
461 } | |
462 | |
69
07b9d96fd764
Make nested class CellEditor.LayoutData a top level class to omit compiler errors "forward reference"
Frank Benoit <benoit@tionex.de>
parents:
43
diff
changeset
|
463 void setLayoutData(LayoutData layoutData) { |
10 | 464 tableTreeEditor.horizontalAlignment = layoutData.horizontalAlignment; |
465 tableTreeEditor.grabHorizontal = layoutData.grabHorizontal; | |
466 tableTreeEditor.minimumWidth = layoutData.minimumWidth; | |
467 } | |
468 | |
469 void handleDoubleClickEvent() { | |
470 Viewer viewer = getViewer(); | |
471 fireDoubleClick(new DoubleClickEvent(viewer, viewer.getSelection())); | |
472 fireOpen(new OpenEvent(viewer, viewer.getSelection())); | |
473 } | |
474 } | |
475 | |
476 /** | |
477 * Creates a table tree viewer on the given table tree control. The viewer | |
478 * has no input, no content provider, a default label provider, no sorter, | |
479 * and no filters. | |
480 * | |
481 * @param tree | |
482 * the table tree control | |
483 */ | |
484 public this(TableTree tree) { | |
485 super(); | |
486 tableTree = tree; | |
487 hookControl(tree); | |
488 tableTreeEditor = new TableTreeEditor(tableTree); | |
489 tableEditorImpl = new TableTreeEditorImpl(this); | |
490 } | |
491 | |
492 /** | |
493 * Creates a table tree viewer on a newly-created table tree control under | |
494 * the given parent. The table tree control is created using the DWT style | |
495 * bits <code>MULTI, H_SCROLL, V_SCROLL, and BORDER</code>. The viewer | |
496 * has no input, no content provider, a default label provider, no sorter, | |
497 * and no filters. | |
498 * | |
499 * @param parent | |
500 * the parent control | |
501 */ | |
502 public this(Composite parent) { | |
503 this(parent, DWT.MULTI | DWT.H_SCROLL | DWT.V_SCROLL | DWT.BORDER); | |
504 } | |
505 | |
506 /** | |
507 * Creates a table tree viewer on a newly-created table tree control under | |
508 * the given parent. The table tree control is created using the given DWT | |
509 * style bits. The viewer has no input, no content provider, a default label | |
510 * provider, no sorter, and no filters. | |
511 * | |
512 * @param parent | |
513 * the parent control | |
514 * @param style | |
515 * the DWT style bits | |
516 */ | |
517 public this(Composite parent, int style) { | |
518 this(new TableTree(parent, style)); | |
519 } | |
520 | |
521 /* | |
522 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
523 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
524 protected override void addTreeListener(Control c, TreeListener listener) { |
10 | 525 (cast(TableTree) c).addTreeListener(listener); |
526 } | |
527 | |
528 /** | |
529 * Cancels a currently active cell editor. All changes already done in the | |
530 * cell editor are lost. | |
531 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
532 public override void cancelEditing() { |
10 | 533 tableEditorImpl.cancelEditing(); |
534 } | |
535 | |
536 /* | |
537 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
538 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
539 protected override void doUpdateItem(Item item, Object element) { |
10 | 540 // update icon and label |
541 // Similar code in TableTreeViewer.doUpdateItem() | |
542 IBaseLabelProvider prov = getLabelProvider(); | |
543 ITableLabelProvider tprov = null; | |
544 | |
545 if ( auto t = cast(ITableLabelProvider) prov ) { | |
546 tprov = t; | |
547 } | |
548 | |
549 int columnCount = tableTree.getTable().getColumnCount(); | |
550 TableTreeItem ti = cast(TableTreeItem) item; | |
551 // Also enter loop if no columns added. See 1G9WWGZ: JFUIF:WINNT - | |
552 // TableViewer with 0 columns does not work | |
553 for (int column = 0; column < columnCount || column is 0; column++) { | |
554 String text = "";//$NON-NLS-1$ | |
555 Image image = null; | |
556 if (tprov !is null) { | |
557 text = tprov.getColumnText(element, column); | |
558 image = tprov.getColumnImage(element, column); | |
559 } else { | |
560 if (column is 0) { | |
561 ViewerLabel updateLabel = new ViewerLabel(item.getText(), | |
562 item.getImage()); | |
563 buildLabel(updateLabel, element); | |
564 | |
565 // As it is possible for user code to run the event | |
566 // loop check here. | |
567 if (item.isDisposed()) { | |
568 unmapElement(element, item); | |
569 return; | |
570 } | |
571 | |
572 text = updateLabel.getText(); | |
573 image = updateLabel.getImage(); | |
574 } | |
575 } | |
576 | |
577 // Avoid setting text to null | |
578 if (text is null) { | |
579 text = ""; //$NON-NLS-1$ | |
580 } | |
581 | |
582 ti.setText(column, text); | |
583 // Apparently a problem to setImage to null if already null | |
584 if (ti.getImage(column) !is image) { | |
585 ti.setImage(column, image); | |
586 } | |
587 | |
588 getColorAndFontCollector().setFontsAndColors(element); | |
589 getColorAndFontCollector().applyFontsAndColors(ti); | |
590 } | |
591 | |
592 } | |
593 | |
594 /** | |
595 * Starts editing the given element. | |
596 * | |
597 * @param element | |
598 * the element | |
599 * @param column | |
600 * the column number | |
601 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
602 public override void editElement(Object element, int column) { |
10 | 603 tableEditorImpl.editElement(element, column); |
604 } | |
605 | |
606 /** | |
607 * Returns the cell editors of this viewer. | |
608 * | |
609 * @return the list of cell editors | |
610 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
611 public override CellEditor[] getCellEditors() { |
10 | 612 return tableEditorImpl.getCellEditors(); |
613 } | |
614 | |
615 /** | |
616 * Returns the cell modifier of this viewer. | |
617 * | |
618 * @return the cell modifier | |
619 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
620 public override ICellModifier getCellModifier() { |
10 | 621 return tableEditorImpl.getCellModifier(); |
622 } | |
623 | |
624 /* | |
625 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
626 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
627 protected override Item[] getChildren(Widget o) { |
10 | 628 if (auto i = cast(TableTreeItem) o ) { |
629 return i.getItems(); | |
630 } | |
631 if (auto i = cast(TableTree) o ) { | |
632 return i.getItems(); | |
633 } | |
634 return null; | |
635 } | |
636 | |
637 /* | |
638 * (non-Javadoc) | |
639 * | |
640 * @see dwtx.jface.viewers.AbstractTreeViewer#getChild(dwt.widgets.Widget, | |
641 * int) | |
642 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
643 protected override Item getChild(Widget widget, int index) { |
10 | 644 if (auto w = cast(TableTreeItem) widget ) { |
645 return w.getItem(index); | |
646 } | |
647 if (auto w = cast(TableTree) widget ) { | |
648 return w.getItem(index); | |
649 } | |
650 return null; | |
651 } | |
652 | |
653 /** | |
654 * Returns the column properties of this viewer. The properties must | |
655 * correspond with the columns of the table control. They are used to | |
656 * identify the column in a cell modifier. | |
657 * | |
658 * @return the list of column properties | |
659 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
660 public override Object[] getColumnProperties() { |
10 | 661 return tableEditorImpl.getColumnProperties(); |
662 } | |
663 | |
664 /* | |
665 * (non-Javadoc) Method declared on Viewer. | |
666 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
667 public override Control getControl() { |
10 | 668 return tableTree; |
669 } | |
670 | |
671 /** | |
672 * Returns the element with the given index from this viewer. Returns | |
673 * <code>null</code> if the index is out of range. | |
674 * <p> | |
675 * This method is internal to the framework. | |
676 * </p> | |
677 * | |
678 * @param index | |
679 * the zero-based index | |
680 * @return the element at the given index, or <code>null</code> if the | |
681 * index is out of range | |
682 */ | |
683 public Object getElementAt(int index) { | |
684 // XXX: Workaround for 1GBCSB1: DWT:WIN2000 - TableTree should have | |
685 // getItem(int index) | |
686 TableTreeItem i = tableTree.getItems()[index]; | |
687 if (i !is null) { | |
688 return i.getData(); | |
689 } | |
690 return null; | |
691 } | |
692 | |
693 /* | |
694 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
695 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
696 protected override bool getExpanded(Item item) { |
10 | 697 return (cast(TableTreeItem) item).getExpanded(); |
698 } | |
699 | |
700 /* | |
701 * (non-Javadoc) | |
702 * | |
703 * @see dwtx.jface.viewers.ColumnViewer#getItemAt(dwt.graphics.Point) | |
704 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
705 protected override Item getItemAt(Point p) { |
10 | 706 return getTableTree().getTable().getItem(p); |
707 } | |
708 | |
709 /* | |
710 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
711 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
712 protected override int getItemCount(Control widget) { |
10 | 713 return (cast(TableTree) widget).getItemCount(); |
714 } | |
715 | |
716 /* | |
717 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
718 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
719 protected override int getItemCount(Item item) { |
10 | 720 return (cast(TableTreeItem) item).getItemCount(); |
721 } | |
722 | |
723 /* | |
724 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
725 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
726 protected override dwt.widgets.Item.Item[] getItems( |
10 | 727 dwt.widgets.Item.Item item) { |
728 return (cast(TableTreeItem) item).getItems(); | |
729 } | |
730 | |
731 /** | |
732 * The table tree viewer implementation of this <code>Viewer</code> | |
733 * framework method returns the label provider, which in the case of table | |
734 * tree viewers will be an instance of either | |
735 * <code>ITableLabelProvider</code> or <code>ILabelProvider</code>. If | |
736 * it is an <code>ITableLabelProvider</code>, then it provides a separate | |
737 * label text and image for each column. If it is an | |
738 * <code>ILabelProvider</code>, then it provides only the label text and | |
739 * image for the first column, and any remaining columns are blank. | |
740 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
741 public override IBaseLabelProvider getLabelProvider() { |
10 | 742 return super.getLabelProvider(); |
743 } | |
744 | |
745 /* | |
746 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
747 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
748 protected override Item getParentItem(Item item) { |
10 | 749 return (cast(TableTreeItem) item).getParentItem(); |
750 } | |
751 | |
752 /* | |
753 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
754 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
755 protected override Item[] getSelection(Control widget) { |
10 | 756 return (cast(TableTree) widget).getSelection(); |
757 } | |
758 | |
759 /** | |
760 * Returns this table tree viewer's table tree control. | |
761 * | |
762 * @return the table tree control | |
763 */ | |
764 public TableTree getTableTree() { | |
765 return tableTree; | |
766 } | |
767 | |
768 /* | |
769 * (non-Javadoc) Method declared on AbstractTreeViewer. | |
770 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
771 protected override void hookControl(Control control) { |
10 | 772 super.hookControl(control); |
773 tableTree.getTable().addMouseListener(new class MouseAdapter { | |
774 public void mouseDown(MouseEvent e) { | |
775 /* | |
776 * If user clicked on the [+] or [-], do not activate | |
777 * CellEditor. | |
778 */ | |
779 // XXX: This code should not be here. DWT should either have | |
780 // support to see | |
781 // if the user clicked on the [+]/[-] or manage the table editor | |
782 // activation | |
783 dwt.widgets.TableItem.TableItem[] items = tableTree | |
784 .getTable().getItems(); | |
785 for (int i = 0; i < items.length; i++) { | |
786 Rectangle rect = items[i].getImageBounds(0); | |
787 if (rect.contains(e.x, e.y)) { | |
788 return; | |
789 } | |
790 } | |
791 | |
792 tableEditorImpl.handleMouseDown(e); | |
793 } | |
794 }); | |
795 } | |
796 | |
797 /** | |
798 * Returns whether there is an active cell editor. | |
799 * | |
800 * @return <code>true</code> if there is an active cell editor, and | |
801 * <code>false</code> otherwise | |
802 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
803 public override bool isCellEditorActive() { |
10 | 804 return tableEditorImpl.isCellEditorActive(); |
805 } | |
806 | |
807 /* | |
808 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
809 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
810 protected override Item newItem(Widget parent, int flags, int ix) { |
10 | 811 TableTreeItem item; |
812 if (ix >= 0) { | |
813 if (cast(TableTreeItem) parent ) { | |
814 item = new TableTreeItem(cast(TableTreeItem) parent, flags, ix); | |
815 } else { | |
816 item = new TableTreeItem(cast(TableTree) parent, flags, ix); | |
817 } | |
818 } else { | |
819 if (cast(TableTreeItem)parent ) { | |
820 item = new TableTreeItem(cast(TableTreeItem) parent, flags); | |
821 } else { | |
822 item = new TableTreeItem(cast(TableTree) parent, flags); | |
823 } | |
824 } | |
825 return item; | |
826 } | |
827 | |
828 /* | |
829 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
830 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
831 protected override void removeAll(Control widget) { |
10 | 832 (cast(TableTree) widget).removeAll(); |
833 } | |
834 | |
835 /** | |
836 * Sets the cell editors of this table viewer. | |
837 * | |
838 * @param editors | |
839 * the list of cell editors | |
840 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
841 public override void setCellEditors(CellEditor[] editors) { |
10 | 842 tableEditorImpl.setCellEditors(editors); |
843 } | |
844 | |
845 /** | |
846 * Sets the cell modifier of this table viewer. | |
847 * | |
848 * @param modifier | |
849 * the cell modifier | |
850 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
851 public override void setCellModifier(ICellModifier modifier) { |
10 | 852 tableEditorImpl.setCellModifier(modifier); |
853 } | |
854 | |
855 /** | |
856 * Sets the column properties of this table viewer. The properties must | |
857 * correspond with the columns of the table control. They are used to | |
858 * identify the column in a cell modifier. | |
859 * | |
860 * @param columnProperties | |
861 * the list of column properties | |
862 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
863 public override void setColumnProperties(String[] columnProperties) { |
10 | 864 tableEditorImpl.setColumnProperties(columnProperties); |
865 } | |
866 | |
867 /* | |
868 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
869 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
870 protected override void setExpanded(Item node, bool expand) { |
10 | 871 (cast(TableTreeItem) node).setExpanded(expand); |
872 } | |
873 | |
874 /* | |
875 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
876 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
877 protected override void setSelection(SeqView!(Item) items) { |
10 | 878 getTableTree().setSelection(cast(TableTreeItem[]) items.toArray); |
879 } | |
880 | |
881 /* | |
882 * (non-Javadoc) Method declared in AbstractTreeViewer. | |
883 */ | |
43
ea8ff534f622
Fix override and super aliases
Frank Benoit <benoit@tionex.de>
parents:
39
diff
changeset
|
884 protected override void showItem(Item item) { |
10 | 885 getTableTree().showItem(cast(TableTreeItem) item); |
886 } | |
887 } |