Mercurial > projects > dwt-samples

comparison examples/controlexample/CoolBarTab.d @ 78:4a04b6759f98

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Clean up directory names
author John Reimer <terminal.node@gmail.com>
date Sat, 10 May 2008 13:32:45 -0700
parents
children eb84f9418bbf
comparison
equal deleted inserted replaced
76:04f122e90b0a 78:4a04b6759f98
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 * Port to the D programming language:
11 * Frank Benoit <benoit@tionex.de>
12 *******************************************************************************/
13 module examples.controlexample.CoolBarTab;
14
15
16
17 import dwt.DWT;
18 import dwt.events.MenuAdapter;
19 import dwt.events.MenuEvent;
20 import dwt.events.SelectionAdapter;
21 import dwt.events.SelectionEvent;
22 import dwt.graphics.Image;
23 import dwt.graphics.Point;
24 import dwt.graphics.Rectangle;
25 import dwt.layout.GridData;
26 import dwt.layout.GridLayout;
27 import dwt.widgets.Button;
28 import dwt.widgets.Control;
29 import dwt.widgets.CoolBar;
30 import dwt.widgets.CoolItem;
31 import dwt.widgets.Event;
32 import dwt.widgets.Group;
33 import dwt.widgets.Item;
34 import dwt.widgets.Listener;
35 import dwt.widgets.Menu;
36 import dwt.widgets.MenuItem;
37 import dwt.widgets.Text;
38 import dwt.widgets.ToolBar;
39 import dwt.widgets.ToolItem;
40 import dwt.widgets.Widget;
41
42 import examples.controlexample.Tab;
43 import examples.controlexample.ControlExample;
44 import tango.util.Convert;
45
46 class CoolBarTab : Tab {
47 /* Example widgets and group that contains them */
48 CoolBar coolBar;
49 CoolItem pushItem, dropDownItem, radioItem, checkItem, textItem;
50 Group coolBarGroup;
51
52 /* Style widgets added to the "Style" group */
53 Button horizontalButton, verticalButton;
54 Button dropDownButton, flatButton;
55
56 /* Other widgets added to the "Other" group */
57 Button lockedButton;
58
59 Point[] sizes;
60 int[] wrapIndices;
61 int[] order;
62
63 /**
64 * Creates the Tab within a given instance of ControlExample.
65 */
66 this(ControlExample instance) {
67 super(instance);
68 }
69
70 /**
71 * Creates the "Other" group.
72 */
73 void createOtherGroup () {
74 super.createOtherGroup ();
75
76 /* Create display controls specific to this example */
77 lockedButton = new Button (otherGroup, DWT.CHECK);
78 lockedButton.setText (ControlExample.getResourceString("Locked"));
79
80 /* Add the listeners */
81 lockedButton.addSelectionListener (new class() SelectionAdapter {
82 public void widgetSelected (SelectionEvent event) {
83 setWidgetLocked ();
84 }
85 });
86 }
87
88 /**
89 * Creates the "Example" group.
90 */
91 void createExampleGroup () {
92 super.createExampleGroup ();
93 coolBarGroup = new Group (exampleGroup, DWT.NONE);
94 coolBarGroup.setLayout (new GridLayout ());
95 coolBarGroup.setLayoutData (new GridData (DWT.FILL, DWT.FILL, true, true));
96 coolBarGroup.setText ("CoolBar");
97 }
98
99 /**
100 * Creates the "Example" widgets.
101 */
102 void createExampleWidgets () {
103 int style = getDefaultStyle(), itemStyle = 0;
104
105 /* Compute the widget, item, and item toolBar styles */
106 int toolBarStyle = DWT.FLAT;
107 bool vertical = false;
108 if (horizontalButton.getSelection ()) {
109 style |= DWT.HORIZONTAL;
110 toolBarStyle |= DWT.HORIZONTAL;
111 }
112 if (verticalButton.getSelection ()) {
113 style |= DWT.VERTICAL;
114 toolBarStyle |= DWT.VERTICAL;
115 vertical = true;
116 }
117 if (borderButton.getSelection()) style |= DWT.BORDER;
118 if (flatButton.getSelection()) style |= DWT.FLAT;
119 if (dropDownButton.getSelection()) itemStyle |= DWT.DROP_DOWN;
120
121 /*
122 * Create the example widgets.
123 */
124 coolBar = new CoolBar (coolBarGroup, style);
125
126 /* Create the push button toolbar cool item */
127 ToolBar toolBar = new ToolBar (coolBar, toolBarStyle);
128 ToolItem item = new ToolItem (toolBar, DWT.PUSH);
129 item.setImage (instance.images[ControlExample.ciClosedFolder]);
130 item.setToolTipText ("DWT.PUSH");
131 item = new ToolItem (toolBar, DWT.PUSH);
132 item.setImage (instance.images[ControlExample.ciOpenFolder]);
133 item.setToolTipText ("DWT.PUSH");
134 item = new ToolItem (toolBar, DWT.PUSH);
135 item.setImage (instance.images[ControlExample.ciTarget]);
136 item.setToolTipText ("DWT.PUSH");
137 item = new ToolItem (toolBar, DWT.SEPARATOR);
138 item = new ToolItem (toolBar, DWT.PUSH);
139 item.setImage (instance.images[ControlExample.ciClosedFolder]);
140 item.setToolTipText ("DWT.PUSH");
141 item = new ToolItem (toolBar, DWT.PUSH);
142 item.setImage (instance.images[ControlExample.ciOpenFolder]);
143 item.setToolTipText ("DWT.PUSH");
144 pushItem = new CoolItem (coolBar, itemStyle);
145 pushItem.setControl (toolBar);
146 pushItem.addSelectionListener (new CoolItemSelectionListener());
147
148 /* Create the dropdown toolbar cool item */
149 toolBar = new ToolBar (coolBar, toolBarStyle);
150 item = new ToolItem (toolBar, DWT.DROP_DOWN);
151 item.setImage (instance.images[ControlExample.ciOpenFolder]);
152 item.setToolTipText ("DWT.DROP_DOWN");
153 item.addSelectionListener (new DropDownSelectionListener());
154 item = new ToolItem (toolBar, DWT.DROP_DOWN);
155 item.setImage (instance.images[ControlExample.ciClosedFolder]);
156 item.setToolTipText ("DWT.DROP_DOWN");
157 item.addSelectionListener (new DropDownSelectionListener());
158 dropDownItem = new CoolItem (coolBar, itemStyle);
159 dropDownItem.setControl (toolBar);
160 dropDownItem.addSelectionListener (new CoolItemSelectionListener());
161
162 /* Create the radio button toolbar cool item */
163 toolBar = new ToolBar (coolBar, toolBarStyle);
164 item = new ToolItem (toolBar, DWT.RADIO);
165 item.setImage (instance.images[ControlExample.ciClosedFolder]);
166 item.setToolTipText ("DWT.RADIO");
167 item = new ToolItem (toolBar, DWT.RADIO);
168 item.setImage (instance.images[ControlExample.ciClosedFolder]);
169 item.setToolTipText ("DWT.RADIO");
170 item = new ToolItem (toolBar, DWT.RADIO);
171 item.setImage (instance.images[ControlExample.ciClosedFolder]);
172 item.setToolTipText ("DWT.RADIO");
173 radioItem = new CoolItem (coolBar, itemStyle);
174 radioItem.setControl (toolBar);
175 radioItem.addSelectionListener (new CoolItemSelectionListener());
176
177 /* Create the check button toolbar cool item */
178 toolBar = new ToolBar (coolBar, toolBarStyle);
179 item = new ToolItem (toolBar, DWT.CHECK);
180 item.setImage (instance.images[ControlExample.ciClosedFolder]);
181 item.setToolTipText ("DWT.CHECK");
182 item = new ToolItem (toolBar, DWT.CHECK);
183 item.setImage (instance.images[ControlExample.ciTarget]);
184 item.setToolTipText ("DWT.CHECK");
185 item = new ToolItem (toolBar, DWT.CHECK);
186 item.setImage (instance.images[ControlExample.ciOpenFolder]);
187 item.setToolTipText ("DWT.CHECK");
188 item = new ToolItem (toolBar, DWT.CHECK);
189 item.setImage (instance.images[ControlExample.ciTarget]);
190 item.setToolTipText ("DWT.CHECK");
191 checkItem = new CoolItem (coolBar, itemStyle);
192 checkItem.setControl (toolBar);
193 checkItem.addSelectionListener (new CoolItemSelectionListener());
194
195 /* Create the text cool item */
196 if (!vertical) {
197 Text text = new Text (coolBar, DWT.BORDER | DWT.SINGLE);
198 textItem = new CoolItem (coolBar, itemStyle);
199 textItem.setControl (text);
200 textItem.addSelectionListener (new CoolItemSelectionListener());
201 Point textSize = text.computeSize(DWT.DEFAULT, DWT.DEFAULT);
202 textSize = textItem.computeSize(textSize.x, textSize.y);
203 textItem.setMinimumSize(textSize);
204 textItem.setPreferredSize(textSize);
205 textItem.setSize(textSize);
206 }
207
208 /* Set the sizes after adding all cool items */
209 CoolItem[] coolItems = coolBar.getItems();
210 for (int i = 0; i < coolItems.length; i++) {
211 CoolItem coolItem = coolItems[i];
212 Control control = coolItem.getControl();
213 Point size = control.computeSize(DWT.DEFAULT, DWT.DEFAULT);
214 Point coolSize = coolItem.computeSize(size.x, size.y);
215 if ( auto bar = cast(ToolBar)control ) {
216 if (bar.getItemCount() > 0) {
217 if (vertical) {
218 size.y = bar.getItem(0).getBounds().height;
219 } else {
220 size.x = bar.getItem(0).getWidth();
221 }
222 }
223 }
224 coolItem.setMinimumSize(size);
225 coolItem.setPreferredSize(coolSize);
226 coolItem.setSize(coolSize);
227 }
228
229 /* If we have saved state, restore it */
230 if (order !is null && order.length is coolBar.getItemCount()) {
231 coolBar.setItemLayout(order, wrapIndices, sizes);
232 } else {
233 coolBar.setWrapIndices([1, 3]);
234 }
235
236 /* Add a listener to resize the group box to match the coolbar */
237 coolBar.addListener(DWT.Resize, new class() Listener {
238 public void handleEvent(Event event) {
239 exampleGroup.layout();
240 }
241 });
242 }
243
244 /**
245 * Creates the "Style" group.
246 */
247 void createStyleGroup() {
248 super.createStyleGroup();
249
250 /* Create the extra widgets */
251 horizontalButton = new Button (styleGroup, DWT.RADIO);
252 horizontalButton.setText ("DWT.HORIZONTAL");
253 verticalButton = new Button (styleGroup, DWT.RADIO);
254 verticalButton.setText ("DWT.VERTICAL");
255 borderButton = new Button (styleGroup, DWT.CHECK);
256 borderButton.setText ("DWT.BORDER");
257 flatButton = new Button (styleGroup, DWT.CHECK);
258 flatButton.setText ("DWT.FLAT");
259 Group itemGroup = new Group(styleGroup, DWT.NONE);
260 itemGroup.setLayout (new GridLayout ());
261 itemGroup.setLayoutData (new GridData (GridData.HORIZONTAL_ALIGN_FILL | GridData.VERTICAL_ALIGN_FILL));
262 itemGroup.setText(ControlExample.getResourceString("Item_Styles"));
263 dropDownButton = new Button (itemGroup, DWT.CHECK);
264 dropDownButton.setText ("DWT.DROP_DOWN");
265 }
266
267 /**
268 * Disposes the "Example" widgets.
269 */
270 void disposeExampleWidgets () {
271 /* store the state of the toolbar if applicable */
272 if (coolBar !is null) {
273 sizes = coolBar.getItemSizes();
274 wrapIndices = coolBar.getWrapIndices();
275 order = coolBar.getItemOrder();
276 }
277 super.disposeExampleWidgets();
278 }
279
280 /**
281 * Gets the "Example" widget children's items, if any.
282 *
283 * @return an array containing the example widget children's items
284 */
285 Item [] getExampleWidgetItems () {
286 return coolBar.getItems();
287 }
288
289 /**
290 * Gets the "Example" widget children.
291 */
292 Widget [] getExampleWidgets () {
293 return [ cast(Widget) coolBar];
294 }
295
296 /**
297 * Returns a list of set/get API method names (without the set/get prefix)
298 * that can be used to set/get values in the example control(s).
299 */
300 char[][] getMethodNames() {
301 return ["ToolTipText"];
302 }
303
304 /**
305 * Gets the short text for the tab folder item.
306 */
307 public char[] getShortTabText() {
308 return "CB";
309 }
310
311 /**
312 * Gets the text for the tab folder item.
313 */
314 char[] getTabText () {
315 return "CoolBar";
316 }
317
318 /**
319 * Sets the state of the "Example" widgets.
320 */
321 void setExampleWidgetState () {
322 super.setExampleWidgetState ();
323 horizontalButton.setSelection ((coolBar.getStyle () & DWT.HORIZONTAL) !is 0);
324 verticalButton.setSelection ((coolBar.getStyle () & DWT.VERTICAL) !is 0);
325 borderButton.setSelection ((coolBar.getStyle () & DWT.BORDER) !is 0);
326 flatButton.setSelection ((coolBar.getStyle () & DWT.FLAT) !is 0);
327 dropDownButton.setSelection ((coolBar.getItem(0).getStyle () & DWT.DROP_DOWN) !is 0);
328 lockedButton.setSelection(coolBar.getLocked());
329 if (!instance.startup) setWidgetLocked ();
330 }
331
332 /**
333 * Sets the header visible state of the "Example" widgets.
334 */
335 void setWidgetLocked () {
336 coolBar.setLocked (lockedButton.getSelection ());
337 }
338
339 /**
340 * Listens to widgetSelected() events on DWT.DROP_DOWN type ToolItems
341 * and opens/closes a menu when appropriate.
342 */
343 class DropDownSelectionListener : SelectionAdapter {
344 private Menu menu = null;
345 private bool visible = false;
346
347 public void widgetSelected(SelectionEvent event) {
348 // Create the menu if it has not already been created
349 if (menu is null) {
350 // Lazy create the menu.
351 menu = new Menu(shell);
352 menu.addMenuListener(new class() MenuAdapter {
353 public void menuHidden(MenuEvent e) {
354 visible = false;
355 }
356 });
357 for (int i = 0; i < 9; ++i) {
358 final char[] text = ControlExample.getResourceString("DropDownData_" ~ to!(char[])(i));
359 if (text.length !is 0) {
360 MenuItem menuItem = new MenuItem(menu, DWT.NONE);
361 menuItem.setText(text);
362 /*
363 * Add a menu selection listener so that the menu is hidden
364 * when the user selects an item from the drop down menu.
365 */
366 menuItem.addSelectionListener(new class() SelectionAdapter {
367 public void widgetSelected(SelectionEvent e) {
368 setMenuVisible(false);
369 }
370 });
371 } else {
372 new MenuItem(menu, DWT.SEPARATOR);
373 }
374 }
375 }
376
377 /**
378 * A selection event will be fired when a drop down tool
379 * item is selected in the main area and in the drop
380 * down arrow. Examine the event detail to determine
381 * where the widget was selected.
382 */
383 if (event.detail is DWT.ARROW) {
384 /*
385 * The drop down arrow was selected.
386 */
387 if (visible) {
388 // Hide the menu to give the Arrow the appearance of being a toggle button.
389 setMenuVisible(false);
390 } else {
391 // Position the menu below and vertically aligned with the the drop down tool button.
392 ToolItem toolItem = cast(ToolItem) event.widget;
393 ToolBar toolBar = toolItem.getParent();
394
395 Rectangle toolItemBounds = toolItem.getBounds();
396 Point point = toolBar.toDisplay(new Point(toolItemBounds.x, toolItemBounds.y));
397 menu.setLocation(point.x, point.y + toolItemBounds.height);
398 setMenuVisible(true);
399 }
400 } else {
401 /*
402 * Main area of drop down tool item selected.
403 * An application would invoke the code to perform the action for the tool item.
404 */
405 }
406 }
407 private void setMenuVisible(bool visible) {
408 menu.setVisible(visible);
409 this.visible = visible;
410 }
411 }
412
413 /**
414 * Listens to widgetSelected() events on DWT.DROP_DOWN type CoolItems
415 * and opens/closes a menu when appropriate.
416 */
417 class CoolItemSelectionListener : SelectionAdapter {
418 private Menu menu = null;
419
420 public void widgetSelected(SelectionEvent event) {
421 /**
422 * A selection event will be fired when the cool item
423 * is selected by its gripper or if the drop down arrow
424 * (or 'chevron') is selected. Examine the event detail
425 * to determine where the widget was selected.
426 */
427 if (event.detail is DWT.ARROW) {
428 /* If the popup menu is already up (i.e. user pressed arrow twice),
429 * then dispose it.
430 */
431 if (menu !is null) {
432 menu.dispose();
433 menu = null;
434 return;
435 }
436
437 /* Get the cool item and convert its bounds to display coordinates. */
438 CoolItem coolItem = cast(CoolItem) event.widget;
439 Rectangle itemBounds = coolItem.getBounds ();
440 itemBounds.width = event.x - itemBounds.x;
441 Point pt = coolBar.toDisplay(new Point (itemBounds.x, itemBounds.y));
442 itemBounds.x = pt.x;
443 itemBounds.y = pt.y;
444
445 /* Get the toolbar from the cool item. */
446 ToolBar toolBar = cast(ToolBar) coolItem.getControl ();
447 ToolItem[] tools = toolBar.getItems ();
448 int toolCount = tools.length;
449
450 /* Convert the bounds of each tool item to display coordinates,
451 * and determine which ones are past the bounds of the cool item.
452 */
453 int i = 0;
454 while (i < toolCount) {
455 Rectangle toolBounds = tools[i].getBounds ();
456 pt = toolBar.toDisplay(new Point(toolBounds.x, toolBounds.y));
457 toolBounds.x = pt.x;
458 toolBounds.y = pt.y;
459 Rectangle intersection = itemBounds.intersection (toolBounds);
460 if (intersection!=toolBounds) break;
461 i++;
462 }
463
464 /* Create a pop-up menu with items for each of the hidden buttons. */
465 menu = new Menu (coolBar);
466 for (int j = i; j < toolCount; j++) {
467 ToolItem tool = tools[j];
468 Image image = tool.getImage();
469 if (image is null) {
470 new MenuItem (menu, DWT.SEPARATOR);
471 } else {
472 if ((tool.getStyle() & DWT.DROP_DOWN) !is 0) {
473 MenuItem menuItem = new MenuItem (menu, DWT.CASCADE);
474 menuItem.setImage(image);
475 char[] text = tool.getToolTipText();
476 if (text !is null) menuItem.setText(text);
477 Menu m = new Menu(menu);
478 menuItem.setMenu(m);
479 for (int k = 0; k < 9; ++k) {
480 text = ControlExample.getResourceString("DropDownData_" ~ to!(char[])(k));
481 if (text.length !is 0) {
482 MenuItem mi = new MenuItem(m, DWT.NONE);
483 mi.setText(text);
484 /* Application code to perform the action for the submenu item would go here. */
485 } else {
486 new MenuItem(m, DWT.SEPARATOR);
487 }
488 }
489 } else {
490 MenuItem menuItem = new MenuItem (menu, DWT.NONE);
491 menuItem.setImage(image);
492 char[] text = tool.getToolTipText();
493 if (text !is null) menuItem.setText(text);
494 }
495 /* Application code to perform the action for the menu item would go here. */
496 }
497 }
498
499 /* Display the pop-up menu at the lower left corner of the arrow button.
500 * Dispose the menu when the user is done with it.
501 */
502 pt = coolBar.toDisplay(new Point(event.x, event.y));
503 menu.setLocation (pt.x, pt.y);
504 menu.setVisible (true);
505 while (menu !is null && !menu.isDisposed() && menu.isVisible ()) {
506 if (!display.readAndDispatch ()) display.sleep ();
507 }
508 if (menu !is null) {
509 menu.dispose ();
510 menu = null;
511 }
512 }
513 }
514 }
515 }