Mercurial > projects > dwt-addons

comparison dwtx/jface/viewers/TreeViewerRow.d @ 10:b6c35faf97c8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Viewers
author Frank Benoit <benoit@tionex.de>
date Mon, 31 Mar 2008 00:47:19 +0200
parents
children ea8ff534f622
comparison
equal deleted inserted replaced
9:6c14e54dfc11 10:b6c35faf97c8
1 /*******************************************************************************
2 * Copyright (c) 2006, 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> - initial API and implementation
11 * - Fix for bug 174355, 171126
12 * Port to the D programming language:
13 * Frank Benoit <benoit@tionex.de>
14 *******************************************************************************/
15
16 module dwtx.jface.viewers.TreeViewerRow;
17
18 import dwtx.jface.viewers.ViewerRow;
19 import dwtx.jface.viewers.TreePath;
20
21 import tango.util.collection.LinkSeq;
22
23 import dwt.graphics.Color;
24 import dwt.graphics.Font;
25 import dwt.graphics.Image;
26 import dwt.graphics.Rectangle;
27 import dwt.widgets.Control;
28 import dwt.widgets.Tree;
29 import dwt.widgets.TreeItem;
30 import dwt.widgets.Widget;
31 import dwtx.core.runtime.Assert;
32
33 import dwt.dwthelper.utils;
34
35 /**
36 * TreeViewerRow is the Tree implementation of ViewerRow.
37 * @since 3.3
38 *
39 */
40 public class TreeViewerRow : ViewerRow {
41 private TreeItem item;
42
43 /**
44 * Create a new instance of the receiver.
45 * @param item
46 */
47 this(TreeItem item) {
48 this.item = item;
49 }
50
51 /* (non-Javadoc)
52 * @see dwtx.jface.viewers.ViewerRow#getBounds(int)
53 */
54 public Rectangle getBounds(int columnIndex) {
55 return item.getBounds(columnIndex);
56 }
57
58 /* (non-Javadoc)
59 * @see dwtx.jface.viewers.ViewerRow#getBounds()
60 */
61 public Rectangle getBounds() {
62 return item.getBounds();
63 }
64
65 /* (non-Javadoc)
66 * @see dwtx.jface.viewers.ViewerRow#getColumnCount()
67 */
68 public int getColumnCount() {
69 return item.getParent().getColumnCount();
70 }
71
72 /* (non-Javadoc)
73 * @see dwtx.jface.viewers.ViewerRow#getItem()
74 */
75 public Widget getItem() {
76 return item;
77 }
78
79 /* (non-Javadoc)
80 * @see dwtx.jface.viewers.ViewerRow#getBackground(int)
81 */
82 public Color getBackground(int columnIndex) {
83 return item.getBackground(columnIndex);
84 }
85
86 /* (non-Javadoc)
87 * @see dwtx.jface.viewers.ViewerRow#getFont(int)
88 */
89 public Font getFont(int columnIndex) {
90 return item.getFont(columnIndex);
91 }
92
93 /* (non-Javadoc)
94 * @see dwtx.jface.viewers.ViewerRow#getForeground(int)
95 */
96 public Color getForeground(int columnIndex) {
97 return item.getForeground(columnIndex);
98 }
99
100 /* (non-Javadoc)
101 * @see dwtx.jface.viewers.ViewerRow#getImage(int)
102 */
103 public Image getImage(int columnIndex) {
104 return item.getImage(columnIndex);
105 }
106
107 /* (non-Javadoc)
108 * @see dwtx.jface.viewers.ViewerRow#getText(int)
109 */
110 public String getText(int columnIndex) {
111 return item.getText(columnIndex);
112 }
113
114 /* (non-Javadoc)
115 * @see dwtx.jface.viewers.ViewerRow#setBackground(int, dwt.graphics.Color)
116 */
117 public void setBackground(int columnIndex, Color color) {
118 item.setBackground(columnIndex, color);
119 }
120
121 /* (non-Javadoc)
122 * @see dwtx.jface.viewers.ViewerRow#setFont(int, dwt.graphics.Font)
123 */
124 public void setFont(int columnIndex, Font font) {
125 item.setFont(columnIndex, font);
126 }
127
128 /* (non-Javadoc)
129 * @see dwtx.jface.viewers.ViewerRow#setForeground(int, dwt.graphics.Color)
130 */
131 public void setForeground(int columnIndex, Color color) {
132 item.setForeground(columnIndex, color);
133 }
134
135 /* (non-Javadoc)
136 * @see dwtx.jface.viewers.ViewerRow#setImage(int, dwt.graphics.Image)
137 */
138 public void setImage(int columnIndex, Image image) {
139 Image oldImage = item.getImage(columnIndex);
140 if (image !is oldImage) {
141 item.setImage(columnIndex, image);
142 }
143 }
144
145 /* (non-Javadoc)
146 * @see dwtx.jface.viewers.ViewerRow#setText(int, java.lang.String)
147 */
148 public void setText(int columnIndex, String text) {
149 item.setText(columnIndex, text is null ? "" : text); //$NON-NLS-1$
150 }
151
152 /* (non-Javadoc)
153 * @see dwtx.jface.viewers.ViewerRow#getControl()
154 */
155 public Control getControl() {
156 return item.getParent();
157 }
158
159
160 public ViewerRow getNeighbor(int direction, bool sameLevel) {
161 if( direction is ViewerRow.ABOVE ) {
162 return getRowAbove(sameLevel);
163 } else if( direction is ViewerRow.BELOW ) {
164 return getRowBelow(sameLevel);
165 } else {
166 throw new IllegalArgumentException("Illegal value of direction argument."); //$NON-NLS-1$
167 }
168 }
169
170 private ViewerRow getRowBelow(bool sameLevel) {
171 Tree tree = item.getParent();
172
173 // This means we have top-level item
174 if( item.getParentItem() is null ) {
175 if( sameLevel || ! item.getExpanded() ) {
176 int index = tree.indexOf(item) + 1;
177
178 if( index < tree.getItemCount() ) {
179 return new TreeViewerRow(tree.getItem(index));
180 }
181 } else if( item.getExpanded() && item.getItemCount() > 0 ) {
182 return new TreeViewerRow(item.getItem(0));
183 }
184 } else {
185 if( sameLevel || ! item.getExpanded() ) {
186 TreeItem parentItem = item.getParentItem();
187
188 int nextIndex = parentItem.indexOf(item) + 1;
189 int totalIndex = parentItem.getItemCount();
190
191 TreeItem itemAfter;
192
193 // This would mean that it was the last item
194 if( nextIndex is totalIndex ) {
195 itemAfter = findNextItem( parentItem );
196 } else {
197 itemAfter = parentItem.getItem(nextIndex);
198 }
199
200 if( itemAfter !is null ) {
201 return new TreeViewerRow(itemAfter);
202 }
203
204 } else if( item.getExpanded() && item.getItemCount() > 0 ) {
205 return new TreeViewerRow(item.getItem(0));
206 }
207 }
208
209 return null;
210 }
211
212 private ViewerRow getRowAbove(bool sameLevel) {
213 Tree tree = item.getParent();
214
215 // This means we have top-level item
216 if( item.getParentItem() is null ) {
217 int index = tree.indexOf(item) - 1;
218 TreeItem nextTopItem = null;
219
220 if( index >= 0 ) {
221 nextTopItem = tree.getItem(index);
222 }
223
224 if( nextTopItem !is null ) {
225 if( sameLevel ) {
226 return new TreeViewerRow(nextTopItem);
227 }
228
229 return new TreeViewerRow(findLastVisibleItem(nextTopItem));
230 }
231 } else {
232 TreeItem parentItem = item.getParentItem();
233 int previousIndex = parentItem.indexOf(item) - 1;
234
235 TreeItem itemBefore;
236 if( previousIndex >= 0 ) {
237 if( sameLevel ) {
238 itemBefore = parentItem.getItem(previousIndex);
239 } else {
240 itemBefore = findLastVisibleItem(parentItem.getItem(previousIndex));
241 }
242 } else {
243 itemBefore = parentItem;
244 }
245
246 if( itemBefore !is null ) {
247 return new TreeViewerRow(itemBefore);
248 }
249 }
250
251 return null;
252 }
253
254 private TreeItem findLastVisibleItem(TreeItem parentItem) {
255 TreeItem rv = parentItem;
256
257 while( rv.getExpanded() && rv.getItemCount() > 0 ) {
258 rv = rv.getItem(rv.getItemCount()-1);
259 }
260
261 return rv;
262 }
263
264 private TreeItem findNextItem(TreeItem item) {
265 TreeItem rv = null;
266 Tree tree = item.getParent();
267 TreeItem parentItem = item.getParentItem();
268
269 int nextIndex;
270 int totalItems;
271
272 if( parentItem is null ) {
273 nextIndex = tree.indexOf(item) + 1;
274 totalItems = tree.getItemCount();
275 } else {
276 nextIndex = parentItem.indexOf(item) + 1;
277 totalItems = parentItem.getItemCount();
278 }
279
280 // This is once more the last item in the tree
281 // Search on
282 if( nextIndex is totalItems ) {
283 if( item.getParentItem() !is null ) {
284 rv = findNextItem(item.getParentItem());
285 }
286 } else {
287 if( parentItem is null ) {
288 rv = tree.getItem(nextIndex);
289 } else {
290 rv = parentItem.getItem(nextIndex);
291 }
292 }
293
294 return rv;
295 }
296
297 public TreePath getTreePath() {
298 TreeItem tItem = item;
299 auto segments = new LinkSeq!(Object);
300 while (tItem !is null) {
301 Object segment = tItem.getData();
302 Assert.isNotNull(segment);
303 segments.prepend(segment);
304 tItem = tItem.getParentItem();
305 }
306
307 return new TreePath(segments.toArray());
308 }
309
310 void setItem(TreeItem item) {
311 this.item = item;
312 }
313
314 public Object clone() {
315 return new TreeViewerRow(item);
316 }
317
318 public Object getElement() {
319 return item.getData();
320 }
321 }