Mercurial > projects > dwt2
annotate org.eclipse.swt.gtk.linux.x86/src/org/eclipse/swt/custom/TableCursor.d @ 108:b397a43d66d1
Updated swt linux for DMD 1.063 and latest Tango trunk.
author | Jacob Carlborg <doob@me.com> |
---|---|
date | Wed, 25 Aug 2010 23:08:27 +0200 |
parents | 7a2dd761a8b2 |
children |
rev | line source |
---|---|
25 | 1 /******************************************************************************* |
2 * Copyright (c) 2000, 2008 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 * Port to the D programming language: | |
11 * Frank Benoit <benoit@tionex.de> | |
12 *******************************************************************************/ | |
13 module org.eclipse.swt.custom.TableCursor; | |
14 | |
15 import java.lang.all; | |
16 | |
17 | |
18 import org.eclipse.swt.SWT; | |
19 import org.eclipse.swt.SWTException; | |
20 import org.eclipse.swt.events.SelectionEvent; | |
21 import org.eclipse.swt.events.SelectionListener; | |
22 import org.eclipse.swt.graphics.Color; | |
23 import org.eclipse.swt.graphics.GC; | |
24 import org.eclipse.swt.graphics.Image; | |
25 import org.eclipse.swt.graphics.Point; | |
26 import org.eclipse.swt.graphics.Rectangle; | |
27 import org.eclipse.swt.widgets.Canvas; | |
28 import org.eclipse.swt.widgets.Display; | |
29 import org.eclipse.swt.widgets.Event; | |
30 import org.eclipse.swt.widgets.Listener; | |
31 import org.eclipse.swt.widgets.ScrollBar; | |
32 import org.eclipse.swt.widgets.Table; | |
33 import org.eclipse.swt.widgets.TableColumn; | |
34 import org.eclipse.swt.widgets.TableItem; | |
35 import org.eclipse.swt.widgets.TypedListener; | |
36 import org.eclipse.swt.widgets.Widget; | |
37 | |
38 /** | |
39 * A TableCursor provides a way for the user to navigate around a Table | |
40 * using the keyboard. It also provides a mechanism for selecting an | |
41 * individual cell in a table. | |
42 * | |
43 * <p> Here is an example of using a TableCursor to navigate to a cell and then edit it. | |
44 * | |
45 * <code><pre> | |
46 * public static void main(String[] args) { | |
47 * Display display = new Display(); | |
48 * Shell shell = new Shell(display); | |
49 * shell.setLayout(new GridLayout()); | |
50 * | |
51 * // create a a table with 3 columns and fill with data | |
52 * final Table table = new Table(shell, SWT.BORDER | SWT.MULTI | SWT.FULL_SELECTION); | |
53 * table.setLayoutData(new GridData(GridData.FILL_BOTH)); | |
54 * TableColumn column1 = new TableColumn(table, SWT.NONE); | |
55 * TableColumn column2 = new TableColumn(table, SWT.NONE); | |
56 * TableColumn column3 = new TableColumn(table, SWT.NONE); | |
57 * for (int i = 0; i < 100; i++) { | |
58 * TableItem item = new TableItem(table, SWT.NONE); | |
59 * item.setText(new String[] { "cell "+i+" 0", "cell "+i+" 1", "cell "+i+" 2"}); | |
60 * } | |
61 * column1.pack(); | |
62 * column2.pack(); | |
63 * column3.pack(); | |
64 * | |
65 * // create a TableCursor to navigate around the table | |
66 * final TableCursor cursor = new TableCursor(table, SWT.NONE); | |
67 * // create an editor to edit the cell when the user hits "ENTER" | |
68 * // while over a cell in the table | |
69 * final ControlEditor editor = new ControlEditor(cursor); | |
70 * editor.grabHorizontal = true; | |
71 * editor.grabVertical = true; | |
72 * | |
73 * cursor.addSelectionListener(new SelectionAdapter() { | |
74 * // when the TableEditor is over a cell, select the corresponding row in | |
75 * // the table | |
76 * public void widgetSelected(SelectionEvent e) { | |
77 * table.setSelection(new TableItem[] {cursor.getRow()}); | |
78 * } | |
79 * // when the user hits "ENTER" in the TableCursor, pop up a text editor so that | |
80 * // they can change the text of the cell | |
81 * public void widgetDefaultSelected(SelectionEvent e){ | |
82 * final Text text = new Text(cursor, SWT.NONE); | |
83 * TableItem row = cursor.getRow(); | |
84 * int column = cursor.getColumn(); | |
85 * text.setText(row.getText(column)); | |
86 * text.addKeyListener(new KeyAdapter() { | |
87 * public void keyPressed(KeyEvent e) { | |
88 * // close the text editor and copy the data over | |
89 * // when the user hits "ENTER" | |
90 * if (e.character is SWT.CR) { | |
91 * TableItem row = cursor.getRow(); | |
92 * int column = cursor.getColumn(); | |
93 * row.setText(column, text.getText()); | |
94 * text.dispose(); | |
95 * } | |
96 * // close the text editor when the user hits "ESC" | |
97 * if (e.character is SWT.ESC) { | |
98 * text.dispose(); | |
99 * } | |
100 * } | |
101 * }); | |
102 * editor.setEditor(text); | |
103 * text.setFocus(); | |
104 * } | |
105 * }); | |
106 * // Hide the TableCursor when the user hits the "MOD1" or "MOD2" key. | |
107 * // This allows the user to select multiple items in the table. | |
108 * cursor.addKeyListener(new KeyAdapter() { | |
109 * public void keyPressed(KeyEvent e) { | |
110 * if (e.keyCode is SWT.MOD1 || | |
111 * e.keyCode is SWT.MOD2 || | |
112 * (e.stateMask & SWT.MOD1) !is 0 || | |
113 * (e.stateMask & SWT.MOD2) !is 0) { | |
114 * cursor.setVisible(false); | |
115 * } | |
116 * } | |
117 * }); | |
118 * // Show the TableCursor when the user releases the "MOD2" or "MOD1" key. | |
119 * // This signals the end of the multiple selection task. | |
120 * table.addKeyListener(new KeyAdapter() { | |
121 * public void keyReleased(KeyEvent e) { | |
122 * if (e.keyCode is SWT.MOD1 && (e.stateMask & SWT.MOD2) !is 0) return; | |
123 * if (e.keyCode is SWT.MOD2 && (e.stateMask & SWT.MOD1) !is 0) return; | |
124 * if (e.keyCode !is SWT.MOD1 && (e.stateMask & SWT.MOD1) !is 0) return; | |
125 * if (e.keyCode !is SWT.MOD2 && (e.stateMask & SWT.MOD2) !is 0) return; | |
126 * | |
127 * TableItem[] selection = table.getSelection(); | |
128 * TableItem row = (selection.length is 0) ? table.getItem(table.getTopIndex()) : selection[0]; | |
129 * table.showItem(row); | |
130 * cursor.setSelection(row, 0); | |
131 * cursor.setVisible(true); | |
132 * cursor.setFocus(); | |
133 * } | |
134 * }); | |
135 * | |
136 * shell.open(); | |
137 * while (!shell.isDisposed()) { | |
138 * if (!display.readAndDispatch()) | |
139 * display.sleep(); | |
140 * } | |
141 * display.dispose(); | |
142 * } | |
143 * </pre></code> | |
144 * | |
145 * <dl> | |
146 * <dt><b>Styles:</b></dt> | |
147 * <dd>BORDER</dd> | |
148 * <dt><b>Events:</b></dt> | |
149 * <dd>Selection, DefaultSelection</dd> | |
150 * </dl> | |
151 * | |
152 * @since 2.0 | |
153 * | |
154 * @see <a href="http://www.eclipse.org/swt/snippets/#tablecursor">TableCursor snippets</a> | |
155 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> | |
156 */ | |
157 public class TableCursor : Canvas { | |
158 | |
159 alias Canvas.dispose dispose; | |
160 | |
161 Table table; | |
162 TableItem row = null; | |
163 TableColumn column = null; | |
164 Listener tableListener, resizeListener, disposeItemListener, disposeColumnListener; | |
165 | |
166 Color background = null; | |
167 Color foreground = null; | |
168 | |
169 // By default, invert the list selection colors | |
49
7a2dd761a8b2
more work until dmd 2.026 linux segfaults.
Frank Benoit <benoit@tionex.de>
parents:
25
diff
changeset
|
170 static const int BACKGROUND = SWT.COLOR_LIST_SELECTION_TEXT; |
7a2dd761a8b2
more work until dmd 2.026 linux segfaults.
Frank Benoit <benoit@tionex.de>
parents:
25
diff
changeset
|
171 static const int FOREGROUND = SWT.COLOR_LIST_SELECTION; |
25 | 172 |
173 /** | |
174 * Constructs a new instance of this class given its parent | |
175 * table and a style value describing its behavior and appearance. | |
176 * <p> | |
177 * The style value is either one of the style constants defined in | |
178 * class <code>SWT</code> which is applicable to instances of this | |
179 * class, or must be built by <em>bitwise OR</em>'ing together | |
180 * (that is, using the <code>int</code> "|" operator) two or more | |
181 * of those <code>SWT</code> style constants. The class description | |
182 * lists the style constants that are applicable to the class. | |
183 * Style bits are also inherited from superclasses. | |
184 * </p> | |
185 * | |
186 * @param parent a Table control which will be the parent of the new instance (cannot be null) | |
187 * @param style the style of control to construct | |
188 * | |
189 * @exception IllegalArgumentException <ul> | |
190 * <li>ERROR_NULL_ARGUMENT - if the parent is null</li> | |
191 * </ul> | |
192 * @exception SWTException <ul> | |
193 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the parent</li> | |
194 * <li>ERROR_INVALID_SUBCLASS - if this class is not an allowed subclass</li> | |
195 * </ul> | |
196 * | |
197 * @see SWT#BORDER | |
198 * @see Widget#checkSubclass() | |
199 * @see Widget#getStyle() | |
200 */ | |
201 public this(Table parent, int style) { | |
202 super(parent, style); | |
203 table = parent; | |
204 setBackground(null); | |
205 setForeground(null); | |
206 | |
207 Listener listener = new class() Listener { | |
208 public void handleEvent(Event event) { | |
209 switch (event.type) { | |
210 case SWT.Dispose : | |
108
b397a43d66d1
Updated swt linux for DMD 1.063 and latest Tango trunk.
Jacob Carlborg <doob@me.com>
parents:
49
diff
changeset
|
211 TableCursor.dispose(event); |
25 | 212 break; |
213 case SWT.FocusIn : | |
214 case SWT.FocusOut : | |
215 redraw(); | |
216 break; | |
217 case SWT.KeyDown : | |
218 keyDown(event); | |
219 break; | |
220 case SWT.Paint : | |
221 paint(event); | |
222 break; | |
223 case SWT.Traverse : { | |
224 event.doit = true; | |
225 switch (event.detail) { | |
226 case SWT.TRAVERSE_ARROW_NEXT : | |
227 case SWT.TRAVERSE_ARROW_PREVIOUS : | |
228 case SWT.TRAVERSE_RETURN : | |
229 event.doit = false; | |
230 break; | |
231 default: | |
232 } | |
233 break; | |
234 } | |
235 default: | |
236 } | |
237 } | |
238 }; | |
239 int[] events = [SWT.Dispose, SWT.FocusIn, SWT.FocusOut, SWT.KeyDown, SWT.Paint, SWT.Traverse]; | |
240 for (int i = 0; i < events.length; i++) { | |
241 addListener(events[i], listener); | |
242 } | |
243 | |
244 tableListener = new class() Listener { | |
245 public void handleEvent(Event event) { | |
246 switch (event.type) { | |
247 case SWT.MouseDown : | |
248 tableMouseDown(event); | |
249 break; | |
250 case SWT.FocusIn : | |
251 tableFocusIn(event); | |
252 break; | |
253 default: | |
254 } | |
255 } | |
256 }; | |
257 table.addListener(SWT.FocusIn, tableListener); | |
258 table.addListener(SWT.MouseDown, tableListener); | |
259 | |
260 disposeItemListener = new class() Listener { | |
261 public void handleEvent(Event event) { | |
262 unhookRowColumnListeners(); | |
263 row = null; | |
264 column = null; | |
265 _resize(); | |
266 } | |
267 }; | |
268 disposeColumnListener = new class() Listener { | |
269 public void handleEvent(Event event) { | |
270 unhookRowColumnListeners(); | |
271 row = null; | |
272 column = null; | |
273 _resize(); | |
274 } | |
275 }; | |
276 resizeListener = new class() Listener { | |
277 public void handleEvent(Event event) { | |
278 _resize(); | |
279 } | |
280 }; | |
281 ScrollBar hBar = table.getHorizontalBar(); | |
282 if (hBar !is null) { | |
283 hBar.addListener(SWT.Selection, resizeListener); | |
284 } | |
285 ScrollBar vBar = table.getVerticalBar(); | |
286 if (vBar !is null) { | |
287 vBar.addListener(SWT.Selection, resizeListener); | |
288 } | |
289 } | |
290 | |
291 /** | |
292 * Adds the listener to the collection of listeners who will | |
293 * be notified when the user changes the receiver's selection, by sending | |
294 * it one of the messages defined in the <code>SelectionListener</code> | |
295 * interface. | |
296 * <p> | |
297 * When <code>widgetSelected</code> is called, the item field of the event object is valid. | |
298 * If the receiver has <code>SWT.CHECK</code> style set and the check selection changes, | |
299 * the event object detail field contains the value <code>SWT.CHECK</code>. | |
300 * <code>widgetDefaultSelected</code> is typically called when an item is double-clicked. | |
301 * </p> | |
302 * | |
303 * @param listener the listener which should be notified when the user changes the receiver's selection | |
304 * | |
305 * @exception IllegalArgumentException <ul> | |
306 * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> | |
307 * </ul> | |
308 * @exception SWTException <ul> | |
309 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
310 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
311 * </ul> | |
312 * | |
313 * @see SelectionListener | |
314 * @see SelectionEvent | |
315 * @see #removeSelectionListener(SelectionListener) | |
316 * | |
317 */ | |
318 public void addSelectionListener(SelectionListener listener) { | |
319 checkWidget(); | |
320 if (listener is null) | |
321 SWT.error(SWT.ERROR_NULL_ARGUMENT); | |
322 TypedListener typedListener = new TypedListener(listener); | |
323 addListener(SWT.Selection, typedListener); | |
324 addListener(SWT.DefaultSelection, typedListener); | |
325 } | |
326 | |
327 void dispose(Event event) { | |
328 table.removeListener(SWT.FocusIn, tableListener); | |
329 table.removeListener(SWT.MouseDown, tableListener); | |
330 unhookRowColumnListeners(); | |
331 ScrollBar hBar = table.getHorizontalBar(); | |
332 if (hBar !is null) { | |
333 hBar.removeListener(SWT.Selection, resizeListener); | |
334 } | |
335 ScrollBar vBar = table.getVerticalBar(); | |
336 if (vBar !is null) { | |
337 vBar.removeListener(SWT.Selection, resizeListener); | |
338 } | |
339 } | |
340 | |
341 void keyDown(Event event) { | |
342 if (row is null) return; | |
343 switch (event.character) { | |
344 case SWT.CR : | |
345 notifyListeners(SWT.DefaultSelection, new Event()); | |
346 return; | |
347 default: | |
348 } | |
349 int rowIndex = table.indexOf(row); | |
350 int columnIndex = column is null ? 0 : table.indexOf(column); | |
351 switch (event.keyCode) { | |
352 case SWT.ARROW_UP : | |
353 setRowColumn(Math.max(0, rowIndex - 1), columnIndex, true); | |
354 break; | |
355 case SWT.ARROW_DOWN : | |
356 setRowColumn(Math.min(rowIndex + 1, table.getItemCount() - 1), columnIndex, true); | |
357 break; | |
358 case SWT.ARROW_LEFT : | |
359 case SWT.ARROW_RIGHT : | |
360 { | |
361 int columnCount = table.getColumnCount(); | |
362 if (columnCount is 0) break; | |
363 int[] order = table.getColumnOrder(); | |
364 int index = 0; | |
365 while (index < order.length) { | |
366 if (order[index] is columnIndex) break; | |
367 index++; | |
368 } | |
369 if (index is order.length) index = 0; | |
370 int leadKey = (getStyle() & SWT.RIGHT_TO_LEFT) !is 0 ? SWT.ARROW_RIGHT : SWT.ARROW_LEFT; | |
371 if (event.keyCode is leadKey) { | |
372 setRowColumn(rowIndex, order[Math.max(0, index - 1)], true); | |
373 } else { | |
374 setRowColumn(rowIndex, order[Math.min(columnCount - 1, index + 1)], true); | |
375 } | |
376 break; | |
377 } | |
378 case SWT.HOME : | |
379 setRowColumn(0, columnIndex, true); | |
380 break; | |
381 case SWT.END : | |
382 { | |
383 int i = table.getItemCount() - 1; | |
384 setRowColumn(i, columnIndex, true); | |
385 break; | |
386 } | |
387 case SWT.PAGE_UP : | |
388 { | |
389 int index = table.getTopIndex(); | |
390 if (index is rowIndex) { | |
391 Rectangle rect = table.getClientArea(); | |
392 TableItem item = table.getItem(index); | |
393 Rectangle itemRect = item.getBounds(0); | |
394 rect.height -= itemRect.y; | |
395 int height = table.getItemHeight(); | |
396 int page = Math.max(1, rect.height / height); | |
397 index = Math.max(0, index - page + 1); | |
398 } | |
399 setRowColumn(index, columnIndex, true); | |
400 break; | |
401 } | |
402 case SWT.PAGE_DOWN : | |
403 { | |
404 int index = table.getTopIndex(); | |
405 Rectangle rect = table.getClientArea(); | |
406 TableItem item = table.getItem(index); | |
407 Rectangle itemRect = item.getBounds(0); | |
408 rect.height -= itemRect.y; | |
409 int height = table.getItemHeight(); | |
410 int page = Math.max(1, rect.height / height); | |
411 int end = table.getItemCount() - 1; | |
412 index = Math.min(end, index + page - 1); | |
413 if (index is rowIndex) { | |
414 index = Math.min(end, index + page - 1); | |
415 } | |
416 setRowColumn(index, columnIndex, true); | |
417 break; | |
418 } | |
419 default: | |
420 } | |
421 } | |
422 | |
423 void paint(Event event) { | |
424 if (row is null) return; | |
425 int columnIndex = column is null ? 0 : table.indexOf(column); | |
426 GC gc = event.gc; | |
427 Display display = getDisplay(); | |
428 gc.setBackground(getBackground()); | |
429 gc.setForeground(getForeground()); | |
430 gc.fillRectangle(event.x, event.y, event.width, event.height); | |
431 int x = 0; | |
432 Point size = getSize(); | |
433 Image image = row.getImage(columnIndex); | |
434 if (image !is null) { | |
435 Rectangle imageSize = image.getBounds(); | |
436 int imageY = (size.y - imageSize.height) / 2; | |
437 gc.drawImage(image, x, imageY); | |
438 x += imageSize.width; | |
439 } | |
440 String text = row.getText(columnIndex); | |
441 if (text.length > 0) { | |
442 Rectangle bounds = row.getBounds(columnIndex); | |
443 Point extent = gc.stringExtent(text); | |
444 // Temporary code - need a better way to determine table trim | |
445 String platform = SWT.getPlatform(); | |
446 if ("win32"==platform) { //$NON-NLS-1$ | |
447 if (table.getColumnCount() is 0 || columnIndex is 0) { | |
448 x += 2; | |
449 } else { | |
450 int alignmnent = column.getAlignment(); | |
451 switch (alignmnent) { | |
452 case SWT.LEFT: | |
453 x += 6; | |
454 break; | |
455 case SWT.RIGHT: | |
456 x = bounds.width - extent.x - 6; | |
457 break; | |
458 case SWT.CENTER: | |
459 x += (bounds.width - x - extent.x) / 2; | |
460 break; | |
461 default: | |
462 } | |
463 } | |
464 } else { | |
465 if (table.getColumnCount() is 0) { | |
466 x += 5; | |
467 } else { | |
468 int alignmnent = column.getAlignment(); | |
469 switch (alignmnent) { | |
470 case SWT.LEFT: | |
471 x += 5; | |
472 break; | |
473 case SWT.RIGHT: | |
474 x = bounds.width- extent.x - 2; | |
475 break; | |
476 case SWT.CENTER: | |
477 x += (bounds.width - x - extent.x) / 2 + 2; | |
478 break; | |
479 default: | |
480 } | |
481 } | |
482 } | |
483 int textY = (size.y - extent.y) / 2; | |
484 gc.drawString(text, x, textY); | |
485 } | |
486 if (isFocusControl()) { | |
487 gc.setBackground(display.getSystemColor(SWT.COLOR_BLACK)); | |
488 gc.setForeground(display.getSystemColor(SWT.COLOR_WHITE)); | |
489 gc.drawFocus(0, 0, size.x, size.y); | |
490 } | |
491 } | |
492 | |
493 void tableFocusIn(Event event) { | |
494 if (isDisposed()) return; | |
495 if (isVisible()) { | |
496 if (row is null && column is null) return; | |
497 setFocus(); | |
498 } | |
499 } | |
500 | |
501 void tableMouseDown(Event event) { | |
502 if (isDisposed() || !isVisible()) return; | |
503 Point pt = new Point(event.x, event.y); | |
504 int lineWidth = table.getLinesVisible() ? table.getGridLineWidth() : 0; | |
505 TableItem item = table.getItem(pt); | |
506 if ((table.getStyle() & SWT.FULL_SELECTION) !is 0) { | |
507 if (item is null) return; | |
508 } else { | |
509 int start = item !is null ? table.indexOf(item) : table.getTopIndex(); | |
510 int end = table.getItemCount(); | |
511 Rectangle clientRect = table.getClientArea(); | |
512 for (int i = start; i < end; i++) { | |
513 TableItem nextItem = table.getItem(i); | |
514 Rectangle rect = nextItem.getBounds(0); | |
515 if (pt.y >= rect.y && pt.y < rect.y + rect.height + lineWidth) { | |
516 item = nextItem; | |
517 break; | |
518 } | |
519 if (rect.y > clientRect.y + clientRect.height) return; | |
520 } | |
521 if (item is null) return; | |
522 } | |
523 TableColumn newColumn = null; | |
524 int columnCount = table.getColumnCount(); | |
525 if (columnCount is 0) { | |
526 if ((table.getStyle() & SWT.FULL_SELECTION) is 0) { | |
527 Rectangle rect = item.getBounds(0); | |
528 rect.width += lineWidth; | |
529 rect.height += lineWidth; | |
530 if (!rect.contains(pt)) return; | |
531 } | |
532 } else { | |
533 for (int i = 0; i < columnCount; i++) { | |
534 Rectangle rect = item.getBounds(i); | |
535 rect.width += lineWidth; | |
536 rect.height += lineWidth; | |
537 if (rect.contains(pt)) { | |
538 newColumn = table.getColumn(i); | |
539 break; | |
540 } | |
541 } | |
542 if (newColumn is null) { | |
543 if ((table.getStyle() & SWT.FULL_SELECTION) is 0) return; | |
544 newColumn = table.getColumn(0); | |
545 } | |
546 } | |
547 setRowColumn(item, newColumn, true); | |
548 setFocus(); | |
549 return; | |
550 } | |
551 void setRowColumn(int row, int column, bool notify) { | |
552 TableItem item = row is -1 ? null : table.getItem(row); | |
553 TableColumn col = column is -1 || table.getColumnCount() is 0 ? null : table.getColumn(column); | |
554 setRowColumn(item, col, notify); | |
555 } | |
556 void setRowColumn(TableItem row, TableColumn column, bool notify) { | |
557 if (this.row is row && this.column is column) { | |
558 return; | |
559 } | |
560 if (this.row !is null && this.row !is row) { | |
561 this.row.removeListener(SWT.Dispose, disposeItemListener); | |
562 this.row = null; | |
563 } | |
564 if (this.column !is null && this.column !is column) { | |
565 this.column.removeListener(SWT.Dispose, disposeColumnListener); | |
566 this.column.removeListener(SWT.Move, resizeListener); | |
567 this.column.removeListener(SWT.Resize, resizeListener); | |
568 this.column = null; | |
569 } | |
570 if (row !is null) { | |
571 if (this.row !is row) { | |
572 this.row = row; | |
573 row.addListener(SWT.Dispose, disposeItemListener); | |
574 table.showItem(row); | |
575 } | |
576 if (this.column !is column && column !is null) { | |
577 this.column = column; | |
578 column.addListener(SWT.Dispose, disposeColumnListener); | |
579 column.addListener(SWT.Move, resizeListener); | |
580 column.addListener(SWT.Resize, resizeListener); | |
581 table.showColumn(column); | |
582 } | |
583 int columnIndex = column is null ? 0 : table.indexOf(column); | |
584 setBounds(row.getBounds(columnIndex)); | |
585 redraw(); | |
586 if (notify) { | |
587 notifyListeners(SWT.Selection, new Event()); | |
588 } | |
589 } | |
590 } | |
591 | |
592 public override void setVisible(bool visible) { | |
593 checkWidget(); | |
594 if (visible) _resize(); | |
595 super.setVisible(visible); | |
596 } | |
597 | |
598 /** | |
599 * Removes the listener from the collection of listeners who will | |
600 * be notified when the user changes the receiver's selection. | |
601 * | |
602 * @param listener the listener which should no longer be notified | |
603 * | |
604 * @exception IllegalArgumentException <ul> | |
605 * <li>ERROR_NULL_ARGUMENT - if the listener is null</li> | |
606 * </ul> | |
607 * @exception SWTException <ul> | |
608 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
609 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
610 * </ul> | |
611 * | |
612 * @see SelectionListener | |
613 * @see #addSelectionListener(SelectionListener) | |
614 * | |
615 * @since 3.0 | |
616 */ | |
617 public void removeSelectionListener(SelectionListener listener) { | |
618 checkWidget(); | |
619 if (listener is null) { | |
620 SWT.error(SWT.ERROR_NULL_ARGUMENT); | |
621 } | |
622 removeListener(SWT.Selection, listener); | |
623 removeListener(SWT.DefaultSelection, listener); | |
624 } | |
625 | |
626 void _resize() { | |
627 if (row is null) { | |
628 setBounds(-200, -200, 0, 0); | |
629 } else { | |
630 int columnIndex = column is null ? 0 : table.indexOf(column); | |
631 setBounds(row.getBounds(columnIndex)); | |
632 } | |
633 } | |
634 /** | |
635 * Returns the column over which the TableCursor is positioned. | |
636 * | |
637 * @return the column for the current position | |
638 * | |
639 * @exception SWTException <ul> | |
640 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
641 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
642 * </ul> | |
643 */ | |
644 public int getColumn() { | |
645 checkWidget(); | |
646 return column is null ? 0 : table.indexOf(column); | |
647 } | |
648 /** | |
649 * Returns the background color that the receiver will use to draw. | |
650 * | |
651 * @return the receiver's background color | |
652 */ | |
653 public Color getBackground() { | |
654 checkWidget(); | |
655 if (background is null) { | |
656 return getDisplay().getSystemColor(BACKGROUND); | |
657 } | |
658 return background; | |
659 } | |
660 /** | |
661 * Returns the foreground color that the receiver will use to draw. | |
662 * | |
663 * @return the receiver's foreground color | |
664 */ | |
665 public Color getForeground() { | |
666 checkWidget(); | |
667 if (foreground is null) { | |
668 return getDisplay().getSystemColor(FOREGROUND); | |
669 } | |
670 return foreground; | |
671 } | |
672 /** | |
673 * Returns the row over which the TableCursor is positioned. | |
674 * | |
675 * @return the item for the current position | |
676 * | |
677 * @exception SWTException <ul> | |
678 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
679 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
680 * </ul> | |
681 */ | |
682 public TableItem getRow() { | |
683 checkWidget(); | |
684 return row; | |
685 } | |
686 /** | |
687 * Sets the receiver's background color to the color specified | |
688 * by the argument, or to the default system color for the control | |
689 * if the argument is null. | |
690 * <p> | |
691 * Note: This operation is a hint and may be overridden by the platform. | |
692 * For example, on Windows the background of a Button cannot be changed. | |
693 * </p> | |
694 * @param color the new color (or null) | |
695 * | |
696 * @exception IllegalArgumentException <ul> | |
697 * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> | |
698 * </ul> | |
699 * @exception SWTException <ul> | |
700 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
701 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
702 * </ul> | |
703 */ | |
704 public override void setBackground (Color color) { | |
705 background = color; | |
706 super.setBackground(getBackground()); | |
707 redraw(); | |
708 } | |
709 /** | |
710 * Sets the receiver's foreground color to the color specified | |
711 * by the argument, or to the default system color for the control | |
712 * if the argument is null. | |
713 * <p> | |
714 * Note: This operation is a hint and may be overridden by the platform. | |
715 * </p> | |
716 * @param color the new color (or null) | |
717 * | |
718 * @exception IllegalArgumentException <ul> | |
719 * <li>ERROR_INVALID_ARGUMENT - if the argument has been disposed</li> | |
720 * </ul> | |
721 * @exception SWTException <ul> | |
722 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
723 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
724 * </ul> | |
725 */ | |
726 public override void setForeground (Color color) { | |
727 foreground = color; | |
728 super.setForeground(getForeground()); | |
729 redraw(); | |
730 } | |
731 /** | |
732 * Positions the TableCursor over the cell at the given row and column in the parent table. | |
733 * | |
734 * @param row the index of the row for the cell to select | |
735 * @param column the index of column for the cell to select | |
736 * | |
737 * @exception SWTException <ul> | |
738 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
739 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
740 * </ul> | |
741 * | |
742 */ | |
743 public void setSelection(int row, int column) { | |
744 checkWidget(); | |
745 int columnCount = table.getColumnCount(); | |
746 int maxColumnIndex = columnCount is 0 ? 0 : columnCount - 1; | |
747 if (row < 0 | |
748 || row >= table.getItemCount() | |
749 || column < 0 | |
750 || column > maxColumnIndex) | |
751 SWT.error(SWT.ERROR_INVALID_ARGUMENT); | |
752 setRowColumn(row, column, false); | |
753 } | |
754 /** | |
755 * Positions the TableCursor over the cell at the given row and column in the parent table. | |
756 * | |
757 * @param row the TableItem of the row for the cell to select | |
758 * @param column the index of column for the cell to select | |
759 * | |
760 * @exception SWTException <ul> | |
761 * <li>ERROR_WIDGET_DISPOSED - if the receiver has been disposed</li> | |
762 * <li>ERROR_THREAD_INVALID_ACCESS - if not called from the thread that created the receiver</li> | |
763 * </ul> | |
764 * | |
765 */ | |
766 public void setSelection(TableItem row, int column) { | |
767 checkWidget(); | |
768 int columnCount = table.getColumnCount(); | |
769 int maxColumnIndex = columnCount is 0 ? 0 : columnCount - 1; | |
770 if (row is null | |
771 || row.isDisposed() | |
772 || column < 0 | |
773 || column > maxColumnIndex) | |
774 SWT.error(SWT.ERROR_INVALID_ARGUMENT); | |
775 setRowColumn(table.indexOf(row), column, false); | |
776 } | |
777 void unhookRowColumnListeners() { | |
778 if (column !is null) { | |
779 column.removeListener(SWT.Dispose, disposeColumnListener); | |
780 column.removeListener(SWT.Move, resizeListener); | |
781 column.removeListener(SWT.Resize, resizeListener); | |
782 column = null; | |
783 } | |
784 if (row !is null) { | |
785 row.removeListener(SWT.Dispose, disposeItemListener); | |
786 row = null; | |
787 } | |
788 } | |
789 } |