Mercurial > projects > dwt-mac

comparison dwt/custom/TableTreeEditor.d @ 41:6337764516f1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Sync dwt/custom with dwt-linux (took copy of complete folder)
author Frank Benoit <benoit@tionex.de>
date Tue, 07 Oct 2008 16:29:55 +0200
parents e831403a80a9
children 63a09873578e
comparison
equal deleted inserted replaced
40:fbe68c33eeee 41:6337764516f1
5 * which accompanies this distribution, and is available at 5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html 6 * http://www.eclipse.org/legal/epl-v10.html
7 * 7 *
8 * Contributors: 8 * Contributors:
9 * IBM Corporation - initial API and implementation 9 * IBM Corporation - initial API and implementation
10 * Port to the D programming language:
11 * Frank Benoit <benoit@tionex.de>
10 *******************************************************************************/ 12 *******************************************************************************/
11 module dwt.custom; 13 module dwt.custom.TableTreeEditor;
12 14
13 15 import dwt.dwthelper.utils;
14 import dwt.*; 16
15 import dwt.graphics.*; 17
16 import dwt.widgets.*; 18 import dwt.DWT;
17 import dwt.events.*; 19 import dwt.events.ControlEvent;
20 import dwt.events.ControlListener;
21 import dwt.events.TreeEvent;
22 import dwt.events.TreeListener;
23 import dwt.graphics.Rectangle;
24 import dwt.widgets.Control;
25 import dwt.widgets.Table;
26 import dwt.widgets.TableColumn;
27 import dwt.custom.ControlEditor;
28 import dwt.custom.TableTree;
29 import dwt.custom.TableTreeItem;
30
31 import dwt.dwthelper.Runnable;
32
18 /** 33 /**
19 * 34 *
20 * A TableTreeEditor is a manager for a Control that appears above a cell in a TableTree 35 * A TableTreeEditor is a manager for a Control that appears above a cell in a TableTree
21 * and tracks with the moving and resizing of that cell. It can be used to display a 36 * and tracks with the moving and resizing of that cell. It can be used to display a
22 * text widget above a cell in a TableTree so that the user can edit the contents of 37 * text widget above a cell in a TableTree so that the user can edit the contents of
23 * that cell. It can also be used to display a button that can launch a dialog for 38 * that cell. It can also be used to display a button that can launch a dialog for
24 * modifying the contents of the associated cell. 39 * modifying the contents of the associated cell.
25 * 40 *
26 * <p> Here is an example of using a TableTreeEditor: 41 * <p> Here is an example of using a TableTreeEditor:
27 * <code><pre> 42 * <code><pre>
28 * final TableTree tableTree = new TableTree(shell, DWT.FULL_SELECTION | DWT.HIDE_SELECTION); 43 * final TableTree tableTree = new TableTree(shell, DWT.FULL_SELECTION | DWT.HIDE_SELECTION);
39 * subitem.setText(1, "edit this value"); 54 * subitem.setText(1, "edit this value");
40 * } 55 * }
41 * } 56 * }
42 * column1.setWidth(100); 57 * column1.setWidth(100);
43 * column2.pack(); 58 * column2.pack();
44 * 59 *
45 * final TableTreeEditor editor = new TableTreeEditor(tableTree); 60 * final TableTreeEditor editor = new TableTreeEditor(tableTree);
46 * //The editor must have the same size as the cell and must 61 * //The editor must have the same size as the cell and must
47 * //not be any smaller than 50 pixels. 62 * //not be any smaller than 50 pixels.
48 * editor.horizontalAlignment = DWT.LEFT; 63 * editor.horizontalAlignment = DWT.LEFT;
49 * editor.grabHorizontal = true; 64 * editor.grabHorizontal = true;
50 * editor.minimumWidth = 50; 65 * editor.minimumWidth = 50;
51 * // editing the second column 66 * // editing the second column
52 * final int EDITABLECOLUMN = 1; 67 * final int EDITABLECOLUMN = 1;
53 * 68 *
54 * tableTree.addSelectionListener(new SelectionAdapter() { 69 * tableTree.addSelectionListener(new SelectionAdapter() {
55 * public void widgetSelected(SelectionEvent e) { 70 * public void widgetSelected(SelectionEvent e) {
56 * // Clean up any previous editor control 71 * // Clean up any previous editor control
57 * Control oldEditor = editor.getEditor(); 72 * Control oldEditor = editor.getEditor();
58 * if (oldEditor !is null) oldEditor.dispose(); 73 * if (oldEditor !is null) oldEditor.dispose();
59 * 74 *
60 * // Identify the selected row 75 * // Identify the selected row
61 * TableTreeItem item = cast(TableTreeItem)e.item; 76 * TableTreeItem item = (TableTreeItem)e.item;
62 * if (item is null) return; 77 * if (item is null) return;
63 * 78 *
64 * // The control that will be the editor must be a child of the Table 79 * // The control that will be the editor must be a child of the Table
65 * Text newEditor = new Text(table, DWT.NONE); 80 * Text newEditor = new Text(table, DWT.NONE);
66 * newEditor.setText(item.getText(EDITABLECOLUMN)); 81 * newEditor.setText(item.getText(EDITABLECOLUMN));
67 * newEditor.addModifyListener(new ModifyListener() { 82 * newEditor.addModifyListener(new ModifyListener() {
68 * public void modifyText(ModifyEvent e) { 83 * public void modifyText(ModifyEvent e) {
69 * Text text = cast(Text)editor.getEditor(); 84 * Text text = (Text)editor.getEditor();
70 * editor.getItem().setText(EDITABLECOLUMN, text.getText()); 85 * editor.getItem().setText(EDITABLECOLUMN, text.getText());
71 * } 86 * }
72 * }); 87 * });
73 * newEditor.selectAll(); 88 * newEditor.selectAll();
74 * newEditor.setFocus(); 89 * newEditor.setFocus();
75 * editor.setEditor(newEditor, item, EDITABLECOLUMN); 90 * editor.setEditor(newEditor, item, EDITABLECOLUMN);
76 * } 91 * }
77 * }); 92 * });
78 * </pre></code> 93 * </pre></code>
79 * 94 *
80 * @deprecated As of 3.1 use TreeEditor with Tree, TreeItem and TreeColumn 95 * @deprecated As of 3.1 use TreeEditor with Tree, TreeItem and TreeColumn
81 */ 96 */
82 public class TableTreeEditor : ControlEditor { 97 public class TableTreeEditor : ControlEditor {
98
99 alias ControlEditor.setEditor setEditor;
83 100
84 TableTree tableTree; 101 TableTree tableTree;
85 TableTreeItem item; 102 TableTreeItem item;
86 int column = -1; 103 int column = -1;
87 ControlListener columnListener; 104 ControlListener columnListener;
94 */ 111 */
95 public this (TableTree tableTree) { 112 public this (TableTree tableTree) {
96 super(tableTree.getTable()); 113 super(tableTree.getTable());
97 this.tableTree = tableTree; 114 this.tableTree = tableTree;
98 115
99 treeListener = new TreeListener () { 116 treeListener = new class() TreeListener {
100 final Runnable runnable = new Runnable() { 117 Runnable runnable;
101 public void run() { 118 this() {
102 if (editor is null || editor.isDisposed()) return; 119 runnable = new class() Runnable {
103 if (TableTreeEditor.this.tableTree.isDisposed()) return; 120 public void run() {
104 layout(); 121 if (editor is null || editor.isDisposed()) return;
105 editor.setVisible(true); 122 if (this.outer.outer.tableTree.isDisposed()) return;
106 } 123 layout();
107 }; 124 editor.setVisible(true);
125 }
126 };
127 }
108 public void treeCollapsed(TreeEvent e) { 128 public void treeCollapsed(TreeEvent e) {
109 if (editor is null || editor.isDisposed ()) return; 129 if (editor is null || editor.isDisposed ()) return;
110 editor.setVisible(false); 130 editor.setVisible(false);
111 e.display.asyncExec(runnable); 131 e.display.asyncExec(runnable);
112 } 132 }
115 editor.setVisible(false); 135 editor.setVisible(false);
116 e.display.asyncExec(runnable); 136 e.display.asyncExec(runnable);
117 } 137 }
118 }; 138 };
119 tableTree.addTreeListener(treeListener); 139 tableTree.addTreeListener(treeListener);
120 140
121 columnListener = new ControlListener() { 141 columnListener = new class() ControlListener {
122 public void controlMoved(ControlEvent e){ 142 public void controlMoved(ControlEvent e){
123 layout (); 143 layout ();
124 } 144 }
125 public void controlResized(ControlEvent e){ 145 public void controlResized(ControlEvent e){
126 layout (); 146 layout ();
127 } 147 }
128 }; 148 };
129 149
130 // To be consistent with older versions of DWT, grabVertical defaults to true 150 // To be consistent with older versions of DWT, grabVertical defaults to true
131 grabVertical = true; 151 grabVertical = true;
132 } 152 }
133 Rectangle computeBounds () { 153
154 override Rectangle computeBounds () {
134 if (item is null || column is -1 || item.isDisposed() || item.tableItem is null) return new Rectangle(0, 0, 0, 0); 155 if (item is null || column is -1 || item.isDisposed() || item.tableItem is null) return new Rectangle(0, 0, 0, 0);
135 Rectangle cell = item.getBounds(column); 156 Rectangle cell = item.getBounds(column);
136 Rectangle area = tableTree.getClientArea(); 157 Rectangle area = tableTree.getClientArea();
137 if (cell.x < area.x + area.width) { 158 if (cell.x < area.x + area.width) {
138 if (cell.x + cell.width > area.x + area.width) { 159 if (cell.x + cell.width > area.x + area.width) {
142 Rectangle editorRect = new Rectangle(cell.x, cell.y, minimumWidth, minimumHeight); 163 Rectangle editorRect = new Rectangle(cell.x, cell.y, minimumWidth, minimumHeight);
143 164
144 if (grabHorizontal) { 165 if (grabHorizontal) {
145 editorRect.width = Math.max(cell.width, minimumWidth); 166 editorRect.width = Math.max(cell.width, minimumWidth);
146 } 167 }
147 168
148 if (grabVertical) { 169 if (grabVertical) {
149 editorRect.height = Math.max(cell.height, minimumHeight); 170 editorRect.height = Math.max(cell.height, minimumHeight);
150 } 171 }
151 172
152 if (horizontalAlignment is DWT.RIGHT) { 173 if (horizontalAlignment is DWT.RIGHT) {
153 editorRect.x += cell.width - editorRect.width; 174 editorRect.x += cell.width - editorRect.width;
154 } else if (horizontalAlignment is DWT.LEFT) { 175 } else if (horizontalAlignment is DWT.LEFT) {
155 // do nothing - cell.x is the right answer 176 // do nothing - cell.x is the right answer
156 } else { // default is CENTER 177 } else { // default is CENTER
157 editorRect.x += (cell.width - editorRect.width)/2; 178 editorRect.x += (cell.width - editorRect.width)/2;
158 } 179 }
159 180
160 if (verticalAlignment is DWT.BOTTOM) { 181 if (verticalAlignment is DWT.BOTTOM) {
161 editorRect.y += cell.height - editorRect.height; 182 editorRect.y += cell.height - editorRect.height;
162 } else if (verticalAlignment is DWT.TOP) { 183 } else if (verticalAlignment is DWT.TOP) {
163 // do nothing - cell.y is the right answer 184 // do nothing - cell.y is the right answer
164 } else { // default is CENTER 185 } else { // default is CENTER
168 } 189 }
169 /** 190 /**
170 * Removes all associations between the TableTreeEditor and the cell in the table tree. The 191 * Removes all associations between the TableTreeEditor and the cell in the table tree. The
171 * TableTree and the editor Control are <b>not</b> disposed. 192 * TableTree and the editor Control are <b>not</b> disposed.
172 */ 193 */
173 public void dispose () { 194 public override void dispose () {
174 if (tableTree !is null && !tableTree.isDisposed()) { 195 if (tableTree !is null && !tableTree.isDisposed()) {
175 Table table = tableTree.getTable(); 196 Table table = tableTree.getTable();
176 if (table !is null && !table.isDisposed()) { 197 if (table !is null && !table.isDisposed()) {
177 if (this.column > -1 && this.column < table.getColumnCount()){ 198 if (this.column > -1 && this.column < table.getColumnCount()){
178 TableColumn tableColumn = table.getColumn(this.column); 199 TableColumn tableColumn = table.getColumn(this.column);
218 TableColumn tableColumn = table.getColumn(this.column); 239 TableColumn tableColumn = table.getColumn(this.column);
219 tableColumn.removeControlListener(columnListener); 240 tableColumn.removeControlListener(columnListener);
220 this.column = -1; 241 this.column = -1;
221 } 242 }
222 243
223 if (column < 0 || column >= table.getColumnCount()) return; 244 if (column < 0 || column >= table.getColumnCount()) return;
224 245
225 this.column = column; 246 this.column = column;
226 TableColumn tableColumn = table.getColumn(this.column); 247 TableColumn tableColumn = table.getColumn(this.column);
227 tableColumn.addControlListener(columnListener); 248 tableColumn.addControlListener(columnListener);
228 layout(); 249 layout();
229 } 250 }
230 public void setItem (TableTreeItem item) { 251 public void setItem (TableTreeItem item) {
231 this.item = item; 252 this.item = item;
232 layout(); 253 layout();
233 } 254 }
234 255
235 /** 256 /**
236 * Specify the Control that is to be displayed and the cell in the table that it is to be positioned above. 257 * Specify the Control that is to be displayed and the cell in the table that it is to be positioned above.
237 * 258 *
238 * <p>Note: The Control provided as the editor <b>must</b> be created with its parent being the Table control 259 * <p>Note: The Control provided as the editor <b>must</b> be created with its parent being the Table control
239 * specified in the TableEditor constructor. 260 * specified in the TableEditor constructor.
240 * 261 *
241 * @param editor the Control that is displayed above the cell being edited 262 * @param editor the Control that is displayed above the cell being edited
242 * @param item the TableItem for the row of the cell being tracked by this editor 263 * @param item the TableItem for the row of the cell being tracked by this editor
243 * @param column the zero based index of the column of the cell being tracked by this editor 264 * @param column the zero based index of the column of the cell being tracked by this editor
244 */ 265 */
266 alias ControlEditor.setEditor setEditor;
245 public void setEditor (Control editor, TableTreeItem item, int column) { 267 public void setEditor (Control editor, TableTreeItem item, int column) {
246 setItem(item); 268 setItem(item);
247 setColumn(column); 269 setColumn(column);
248 setEditor(editor); 270 setEditor(editor);
249 } 271 }
250 public void layout () { 272 public override void layout () {
251 if (tableTree is null || tableTree.isDisposed()) return; 273 if (tableTree is null || tableTree.isDisposed()) return;
252 if (item is null || item.isDisposed()) return; 274 if (item is null || item.isDisposed()) return;
253 Table table = tableTree.getTable(); 275 Table table = tableTree.getTable();
254 int columnCount = table.getColumnCount(); 276 int columnCount = table.getColumnCount();
255 if (columnCount is 0 && column !is 0) return; 277 if (columnCount is 0 && column !is 0) return;
256 if (columnCount > 0 && (column < 0 || column >= columnCount)) return; 278 if (columnCount > 0 && (column < 0 || column >= columnCount)) return;
257 super.layout(); 279 super.layout();
258 } 280 }
259 } 281
282 }