8
|
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 dwtx.jface.dialogs.Dialog;
|
|
14
|
|
15 import dwtx.jface.dialogs.IDialogBlockedHandler;
|
|
16 import dwtx.jface.dialogs.IDialogSettings;
|
|
17 import dwtx.jface.dialogs.IDialogConstants;
|
|
18 // import tango.util.Arrays;
|
|
19
|
|
20 import dwt.DWT;
|
|
21 import dwt.events.SelectionAdapter;
|
|
22 import dwt.events.SelectionEvent;
|
|
23 import dwt.graphics.Font;
|
|
24 import dwt.graphics.FontData;
|
|
25 import dwt.graphics.FontMetrics;
|
|
26 import dwt.graphics.GC;
|
|
27 import dwt.graphics.Image;
|
|
28 import dwt.graphics.Point;
|
|
29 import dwt.layout.FormData;
|
|
30 import dwt.layout.GridData;
|
|
31 import dwt.layout.GridLayout;
|
|
32 import dwt.widgets.Button;
|
|
33 import dwt.widgets.Composite;
|
|
34 import dwt.widgets.Control;
|
|
35 import dwt.widgets.Display;
|
|
36 import dwt.widgets.Shell;
|
|
37 import dwtx.core.runtime.IProgressMonitor;
|
|
38 import dwtx.core.runtime.IStatus;
|
|
39 import dwtx.core.runtime.Status;
|
|
40 import dwtx.jface.resource.JFaceResources;
|
|
41 import dwtx.jface.util.Policy;
|
|
42 import dwtx.jface.window.IShellProvider;
|
|
43 import dwtx.jface.window.SameShellProvider;
|
|
44 import dwtx.jface.window.Window;
|
|
45
|
|
46 import dwt.dwthelper.utils;
|
|
47
|
|
48 /**
|
|
49 * A dialog is a specialized window used for narrow-focused communication with
|
|
50 * the user.
|
|
51 * <p>
|
|
52 * Dialogs are usually modal. Consequently, it is generally bad practice to open
|
|
53 * a dialog without a parent. A modal dialog without a parent is not prevented
|
|
54 * from disappearing behind the application's other windows, making it very
|
|
55 * confusing for the user.
|
|
56 * </p>
|
|
57 * <p>
|
|
58 * If there is more than one modal dialog is open the second one should be
|
|
59 * parented off of the shell of the first one otherwise it is possible that the
|
|
60 * OS will give focus to the first dialog potentially blocking the UI.
|
|
61 * </p>
|
|
62 */
|
|
63 public abstract class Dialog : Window {
|
|
64 /**
|
|
65 * Image registry key for error image (value
|
|
66 * <code>"dialog_error_image"</code>).
|
|
67 *
|
|
68 * @deprecated use
|
|
69 * dwt.widgets.Display.getSystemImage(DWT.ICON_ERROR)
|
|
70 */
|
|
71 public static const String DLG_IMG_ERROR = "dialog_error_image"; //$NON-NLS-1$
|
|
72
|
|
73 /**
|
|
74 * Image registry key for info image (value <code>"dialog_info_image"</code>).
|
|
75 *
|
|
76 * @deprecated use
|
|
77 * dwt.widgets.Display.getSystemImage(DWT.ICON_INFORMATION)
|
|
78 */
|
|
79 public static const String DLG_IMG_INFO = "dialog_info_imageg"; //$NON-NLS-1$
|
|
80
|
|
81 /**
|
|
82 * Image registry key for question image (value
|
|
83 * <code>"dialog_question_image"</code>).
|
|
84 *
|
|
85 * @deprecated dwt.widgets.Display.getSystemImage(DWT.ICON_QUESTION)
|
|
86 */
|
|
87 public static const String DLG_IMG_QUESTION = "dialog_question_image"; //$NON-NLS-1$
|
|
88
|
|
89 /**
|
|
90 * Image registry key for warning image (value
|
|
91 * <code>"dialog_warning_image"</code>).
|
|
92 *
|
|
93 * @deprecated use
|
|
94 * dwt.widgets.Display.getSystemImage(DWT.ICON_WARNING)
|
|
95 */
|
|
96 public static const String DLG_IMG_WARNING = "dialog_warning_image"; //$NON-NLS-1$
|
|
97
|
|
98 /**
|
|
99 * Image registry key for info message image (value
|
|
100 * <code>"dialog_messasge_info_image"</code>).
|
|
101 *
|
|
102 * @since 2.0
|
|
103 */
|
|
104 public static const String DLG_IMG_MESSAGE_INFO = "dialog_messasge_info_image"; //$NON-NLS-1$
|
|
105
|
|
106 /**
|
|
107 * Image registry key for info message image (value
|
|
108 * <code>"dialog_messasge_warning_image"</code>).
|
|
109 *
|
|
110 * @since 2.0
|
|
111 */
|
|
112 public static const String DLG_IMG_MESSAGE_WARNING = "dialog_messasge_warning_image"; //$NON-NLS-1$
|
|
113
|
|
114 /**
|
|
115 * Image registry key for info message image (value
|
|
116 * <code>"dialog_message_error_image"</code>).
|
|
117 *
|
|
118 * @since 2.0
|
|
119 */
|
|
120 public static const String DLG_IMG_MESSAGE_ERROR = "dialog_message_error_image"; //$NON-NLS-1$
|
|
121
|
|
122 /**
|
|
123 * Image registry key for help image (value
|
|
124 * <code>"dialog_help_image"</code>).
|
|
125 *
|
|
126 * @since 3.2
|
|
127 */
|
|
128 public static const String DLG_IMG_HELP = "dialog_help_image"; //$NON-NLS-1$
|
|
129
|
|
130 /**
|
|
131 * The ellipsis is the string that is used to represent shortened text.
|
|
132 *
|
|
133 * @since 3.0
|
|
134 */
|
|
135 public static const String ELLIPSIS = "..."; //$NON-NLS-1$
|
|
136
|
|
137 /**
|
|
138 * The dialog settings key name for stored dialog x location.
|
|
139 *
|
|
140 * @since 3.2
|
|
141 */
|
|
142 private static const String DIALOG_ORIGIN_X = "DIALOG_X_ORIGIN"; //$NON-NLS-1$
|
|
143
|
|
144 /**
|
|
145 * The dialog settings key name for stored dialog y location.
|
|
146 *
|
|
147 * @since 3.2
|
|
148 */
|
|
149 private static const String DIALOG_ORIGIN_Y = "DIALOG_Y_ORIGIN"; //$NON-NLS-1$
|
|
150
|
|
151 /**
|
|
152 * The dialog settings key name for stored dialog width.
|
|
153 *
|
|
154 * @since 3.2
|
|
155 */
|
|
156 private static const String DIALOG_WIDTH = "DIALOG_WIDTH"; //$NON-NLS-1$
|
|
157
|
|
158 /**
|
|
159 * The dialog settings key name for stored dialog height.
|
|
160 *
|
|
161 * @since 3.2
|
|
162 */
|
|
163 private static const String DIALOG_HEIGHT = "DIALOG_HEIGHT"; //$NON-NLS-1$
|
|
164
|
|
165 /**
|
|
166 * The dialog settings key name for the font used when the dialog
|
|
167 * height and width was stored.
|
|
168 *
|
|
169 *@since 3.2
|
|
170 */
|
|
171 private static const String DIALOG_FONT_DATA = "DIALOG_FONT_NAME"; //$NON-NLS-1$
|
|
172
|
|
173 /**
|
|
174 * A value that can be used for stored dialog width or height that
|
|
175 * indicates that the default bounds should be used.
|
|
176 *
|
|
177 * @since 3.2
|
|
178 */
|
|
179 public static const int DIALOG_DEFAULT_BOUNDS = -1;
|
|
180
|
|
181 /**
|
|
182 * Constants that can be used for specifying the strategy for persisting
|
|
183 * dialog bounds. These constants represent bit masks that can be used
|
|
184 * together.
|
|
185 *
|
|
186 *@since 3.2
|
|
187 */
|
|
188
|
|
189 /**
|
|
190 * Persist the last location of the dialog.
|
|
191 * @since 3.2
|
|
192 */
|
|
193 public static const int DIALOG_PERSISTLOCATION = 0x0001;
|
|
194 /**
|
|
195 * Persist the last known size of the dialog.
|
|
196 * @since 3.2
|
|
197 */
|
|
198 public static const int DIALOG_PERSISTSIZE = 0x0002;
|
|
199
|
|
200 /**
|
|
201 * The dialog area; <code>null</code> until dialog is layed out.
|
|
202 */
|
|
203 protected Control dialogArea;
|
|
204
|
|
205 /**
|
|
206 * The button bar; <code>null</code> until dialog is layed out.
|
|
207 */
|
|
208 public Control buttonBar;
|
|
209
|
|
210 /**
|
|
211 * Collection of buttons created by the <code>createButton</code> method.
|
|
212 */
|
|
213 private Button[int] buttons;
|
|
214
|
|
215 /**
|
|
216 * Font metrics to use for determining pixel sizes.
|
|
217 */
|
|
218 private FontMetrics fontMetrics;
|
|
219
|
|
220 /**
|
|
221 * Number of horizontal dialog units per character, value <code>4</code>.
|
|
222 */
|
|
223 private static const int HORIZONTAL_DIALOG_UNIT_PER_CHAR = 4;
|
|
224
|
|
225 /**
|
|
226 * Number of vertical dialog units per character, value <code>8</code>.
|
|
227 */
|
|
228 private static const int VERTICAL_DIALOG_UNITS_PER_CHAR = 8;
|
|
229
|
|
230 /**
|
|
231 * Returns the number of pixels corresponding to the height of the given
|
|
232 * number of characters.
|
|
233 * <p>
|
|
234 * The required <code>FontMetrics</code> parameter may be created in the
|
|
235 * following way: <code>
|
|
236 * GC gc = new GC(control);
|
|
237 * gc.setFont(control.getFont());
|
|
238 * fontMetrics = gc.getFontMetrics();
|
|
239 * gc.dispose();
|
|
240 * </code>
|
|
241 * </p>
|
|
242 *
|
|
243 * @param fontMetrics
|
|
244 * used in performing the conversion
|
|
245 * @param chars
|
|
246 * the number of characters
|
|
247 * @return the number of pixels
|
|
248 * @since 2.0
|
|
249 */
|
|
250 public static int convertHeightInCharsToPixels(FontMetrics fontMetrics,
|
|
251 int chars) {
|
|
252 return fontMetrics.getHeight() * chars;
|
|
253 }
|
|
254
|
|
255 /**
|
|
256 * Returns the number of pixels corresponding to the given number of
|
|
257 * horizontal dialog units.
|
|
258 * <p>
|
|
259 * The required <code>FontMetrics</code> parameter may be created in the
|
|
260 * following way: <code>
|
|
261 * GC gc = new GC(control);
|
|
262 * gc.setFont(control.getFont());
|
|
263 * fontMetrics = gc.getFontMetrics();
|
|
264 * gc.dispose();
|
|
265 * </code>
|
|
266 * </p>
|
|
267 *
|
|
268 * @param fontMetrics
|
|
269 * used in performing the conversion
|
|
270 * @param dlus
|
|
271 * the number of horizontal dialog units
|
|
272 * @return the number of pixels
|
|
273 * @since 2.0
|
|
274 */
|
|
275 public static int convertHorizontalDLUsToPixels(FontMetrics fontMetrics,
|
|
276 int dlus) {
|
|
277 // round to the nearest pixel
|
|
278 return (fontMetrics.getAverageCharWidth() * dlus + HORIZONTAL_DIALOG_UNIT_PER_CHAR / 2)
|
|
279 / HORIZONTAL_DIALOG_UNIT_PER_CHAR;
|
|
280 }
|
|
281
|
|
282 /**
|
|
283 * Returns the number of pixels corresponding to the given number of
|
|
284 * vertical dialog units.
|
|
285 * <p>
|
|
286 * The required <code>FontMetrics</code> parameter may be created in the
|
|
287 * following way: <code>
|
|
288 * GC gc = new GC(control);
|
|
289 * gc.setFont(control.getFont());
|
|
290 * fontMetrics = gc.getFontMetrics();
|
|
291 * gc.dispose();
|
|
292 * </code>
|
|
293 * </p>
|
|
294 *
|
|
295 * @param fontMetrics
|
|
296 * used in performing the conversion
|
|
297 * @param dlus
|
|
298 * the number of vertical dialog units
|
|
299 * @return the number of pixels
|
|
300 * @since 2.0
|
|
301 */
|
|
302 public static int convertVerticalDLUsToPixels(FontMetrics fontMetrics,
|
|
303 int dlus) {
|
|
304 // round to the nearest pixel
|
|
305 return (fontMetrics.getHeight() * dlus + VERTICAL_DIALOG_UNITS_PER_CHAR / 2)
|
|
306 / VERTICAL_DIALOG_UNITS_PER_CHAR;
|
|
307 }
|
|
308
|
|
309 /**
|
|
310 * Returns the number of pixels corresponding to the width of the given
|
|
311 * number of characters.
|
|
312 * <p>
|
|
313 * The required <code>FontMetrics</code> parameter may be created in the
|
|
314 * following way: <code>
|
|
315 * GC gc = new GC(control);
|
|
316 * gc.setFont(control.getFont());
|
|
317 * fontMetrics = gc.getFontMetrics();
|
|
318 * gc.dispose();
|
|
319 * </code>
|
|
320 * </p>
|
|
321 *
|
|
322 * @param fontMetrics
|
|
323 * used in performing the conversion
|
|
324 * @param chars
|
|
325 * the number of characters
|
|
326 * @return the number of pixels
|
|
327 * @since 2.0
|
|
328 */
|
|
329 public static int convertWidthInCharsToPixels(FontMetrics fontMetrics,
|
|
330 int chars) {
|
|
331 return fontMetrics.getAverageCharWidth() * chars;
|
|
332 }
|
|
333
|
|
334 /**
|
|
335 * Shortens the given text <code>textValue</code> so that its width in
|
|
336 * pixels does not exceed the width of the given control. Overrides
|
|
337 * characters in the center of the original string with an ellipsis ("...")
|
|
338 * if necessary. If a <code>null</code> value is given, <code>null</code>
|
|
339 * is returned.
|
|
340 *
|
|
341 * @param textValue
|
|
342 * the original string or <code>null</code>
|
|
343 * @param control
|
|
344 * the control the string will be displayed on
|
|
345 * @return the string to display, or <code>null</code> if null was passed
|
|
346 * in
|
|
347 *
|
|
348 * @since 3.0
|
|
349 */
|
|
350 public static String shortenText(String textValue, Control control) {
|
|
351 if (textValue is null) {
|
|
352 return null;
|
|
353 }
|
|
354 GC gc = new GC(control);
|
|
355 int maxWidth = control.getBounds().width - 5;
|
|
356 int maxExtent = gc.textExtent(textValue).x;
|
|
357 if (maxExtent < maxWidth) {
|
|
358 gc.dispose();
|
|
359 return textValue;
|
|
360 }
|
|
361 int length = textValue.length;
|
|
362 int charsToClip = cast(int) Math.round(0.95f*length * (1 - (cast(float)maxWidth/maxExtent)));
|
|
363 int pivot = length / 2;
|
|
364 int start = pivot - (charsToClip/2);
|
|
365 int end = pivot + (charsToClip/2) + 1;
|
|
366 while (start >= 0 && end < length) {
|
|
367 String s1 = textValue.substring(0, start);
|
|
368 String s2 = textValue.substring(end, length);
|
|
369 String s = s1 ~ ELLIPSIS ~ s2;
|
|
370 int l = gc.textExtent(s).x;
|
|
371 if (l < maxWidth) {
|
|
372 gc.dispose();
|
|
373 return s;
|
|
374 }
|
|
375 start--;
|
|
376 end++;
|
|
377 }
|
|
378 gc.dispose();
|
|
379 return textValue;
|
|
380 }
|
|
381
|
|
382 /**
|
|
383 * Create a default instance of the blocked handler which does not do
|
|
384 * anything.
|
|
385 */
|
|
386 public static IDialogBlockedHandler blockedHandler;
|
|
387 static this(){
|
|
388 blockedHandler = new class IDialogBlockedHandler {
|
|
389 /*
|
|
390 * (non-Javadoc)
|
|
391 *
|
|
392 * @see dwtx.jface.dialogs.IDialogBlockedHandler#clearBlocked()
|
|
393 */
|
|
394 public void clearBlocked() {
|
|
395 // No default behaviour
|
|
396 }
|
|
397
|
|
398 /*
|
|
399 * (non-Javadoc)
|
|
400 *
|
|
401 * @see dwtx.jface.dialogs.IDialogBlockedHandler#showBlocked(dwtx.core.runtime.IProgressMonitor,
|
|
402 * dwtx.core.runtime.IStatus, java.lang.String)
|
|
403 */
|
|
404 public void showBlocked(IProgressMonitor blocking,
|
|
405 IStatus blockingStatus, String blockedName) {
|
|
406 // No default behaviour
|
|
407 }
|
|
408
|
|
409 /*
|
|
410 * (non-Javadoc)
|
|
411 *
|
|
412 * @see dwtx.jface.dialogs.IDialogBlockedHandler#showBlocked(dwt.widgets.Shell,
|
|
413 * dwtx.core.runtime.IProgressMonitor,
|
|
414 * dwtx.core.runtime.IStatus, java.lang.String)
|
|
415 */
|
|
416 public void showBlocked(Shell parentShell, IProgressMonitor blocking,
|
|
417 IStatus blockingStatus, String blockedName) {
|
|
418 // No default behaviour
|
|
419 }
|
|
420 };
|
|
421 }
|
|
422
|
|
423 /**
|
|
424 * Creates a dialog instance. Note that the window will have no visual
|
|
425 * representation (no widgets) until it is told to open. By default,
|
|
426 * <code>open</code> blocks for dialogs.
|
|
427 *
|
|
428 * @param parentShell
|
|
429 * the parent shell, or <code>null</code> to create a top-level
|
|
430 * shell
|
|
431 */
|
|
432 protected this(Shell parentShell) {
|
|
433 this(new SameShellProvider(parentShell));
|
|
434 if (parentShell is null && Policy.DEBUG_DIALOG_NO_PARENT) {
|
|
435 Policy.getLog().log(
|
|
436 new Status(IStatus.INFO, Policy.JFACE, IStatus.INFO, this
|
|
437 .classinfo.name
|
|
438 ~ " created with no shell",//$NON-NLS-1$
|
|
439 new Exception( null, null )));
|
|
440 }
|
|
441 }
|
|
442
|
|
443 /**
|
|
444 * Creates a dialog with the given parent.
|
|
445 *
|
|
446 * @param parentShell
|
|
447 * object that returns the current parent shell
|
|
448 *
|
|
449 * @since 3.1
|
|
450 */
|
|
451 protected this(IShellProvider parentShell) {
|
|
452 super(parentShell);
|
|
453 setShellStyle(DWT.DIALOG_TRIM | DWT.APPLICATION_MODAL
|
|
454 | getDefaultOrientation());
|
|
455 setBlockOnOpen(true);
|
|
456 }
|
|
457
|
|
458 /**
|
|
459 * Notifies that this dialog's button with the given id has been pressed.
|
|
460 * <p>
|
|
461 * The <code>Dialog</code> implementation of this framework method calls
|
|
462 * <code>okPressed</code> if the ok button is the pressed, and
|
|
463 * <code>cancelPressed</code> if the cancel button is the pressed. All
|
|
464 * other button presses are ignored. Subclasses may override to handle other
|
|
465 * buttons, but should call <code>super.buttonPressed</code> if the
|
|
466 * default handling of the ok and cancel buttons is desired.
|
|
467 * </p>
|
|
468 *
|
|
469 * @param buttonId
|
|
470 * the id of the button that was pressed (see
|
|
471 * <code>IDialogConstants.*_ID</code> constants)
|
|
472 */
|
|
473 protected void buttonPressed(int buttonId) {
|
|
474 if (IDialogConstants.OK_ID is buttonId) {
|
|
475 okPressed();
|
|
476 } else if (IDialogConstants.CANCEL_ID is buttonId) {
|
|
477 cancelPressed();
|
|
478 }
|
|
479 }
|
|
480
|
|
481 /**
|
|
482 * Notifies that the cancel button of this dialog has been pressed.
|
|
483 * <p>
|
|
484 * The <code>Dialog</code> implementation of this framework method sets
|
|
485 * this dialog's return code to <code>Window.CANCEL</code> and closes the
|
|
486 * dialog. Subclasses may override if desired.
|
|
487 * </p>
|
|
488 */
|
|
489 protected void cancelPressed() {
|
|
490 setReturnCode(CANCEL);
|
|
491 close();
|
|
492 }
|
|
493
|
|
494 /**
|
|
495 * Returns the number of pixels corresponding to the height of the given
|
|
496 * number of characters.
|
|
497 * <p>
|
|
498 * This method may only be called after <code>initializeDialogUnits</code>
|
|
499 * has been called.
|
|
500 * </p>
|
|
501 * <p>
|
|
502 * Clients may call this framework method, but should not override it.
|
|
503 * </p>
|
|
504 *
|
|
505 * @param chars
|
|
506 * the number of characters
|
|
507 * @return the number of pixels
|
|
508 */
|
|
509 protected int convertHeightInCharsToPixels(int chars) {
|
|
510 // test for failure to initialize for backward compatibility
|
|
511 if (fontMetrics is null) {
|
|
512 return 0;
|
|
513 }
|
|
514 return convertHeightInCharsToPixels(fontMetrics, chars);
|
|
515 }
|
|
516
|
|
517 /**
|
|
518 * Returns the number of pixels corresponding to the given number of
|
|
519 * horizontal dialog units.
|
|
520 * <p>
|
|
521 * This method may only be called after <code>initializeDialogUnits</code>
|
|
522 * has been called.
|
|
523 * </p>
|
|
524 * <p>
|
|
525 * Clients may call this framework method, but should not override it.
|
|
526 * </p>
|
|
527 *
|
|
528 * @param dlus
|
|
529 * the number of horizontal dialog units
|
|
530 * @return the number of pixels
|
|
531 */
|
|
532 protected int convertHorizontalDLUsToPixels(int dlus) {
|
|
533 // test for failure to initialize for backward compatibility
|
|
534 if (fontMetrics is null) {
|
|
535 return 0;
|
|
536 }
|
|
537 return convertHorizontalDLUsToPixels(fontMetrics, dlus);
|
|
538 }
|
|
539
|
|
540 /**
|
|
541 * Returns the number of pixels corresponding to the given number of
|
|
542 * vertical dialog units.
|
|
543 * <p>
|
|
544 * This method may only be called after <code>initializeDialogUnits</code>
|
|
545 * has been called.
|
|
546 * </p>
|
|
547 * <p>
|
|
548 * Clients may call this framework method, but should not override it.
|
|
549 * </p>
|
|
550 *
|
|
551 * @param dlus
|
|
552 * the number of vertical dialog units
|
|
553 * @return the number of pixels
|
|
554 */
|
|
555 protected int convertVerticalDLUsToPixels(int dlus) {
|
|
556 // test for failure to initialize for backward compatibility
|
|
557 if (fontMetrics is null) {
|
|
558 return 0;
|
|
559 }
|
|
560 return convertVerticalDLUsToPixels(fontMetrics, dlus);
|
|
561 }
|
|
562
|
|
563 /**
|
|
564 * Returns the number of pixels corresponding to the width of the given
|
|
565 * number of characters.
|
|
566 * <p>
|
|
567 * This method may only be called after <code>initializeDialogUnits</code>
|
|
568 * has been called.
|
|
569 * </p>
|
|
570 * <p>
|
|
571 * Clients may call this framework method, but should not override it.
|
|
572 * </p>
|
|
573 *
|
|
574 * @param chars
|
|
575 * the number of characters
|
|
576 * @return the number of pixels
|
|
577 */
|
|
578 protected int convertWidthInCharsToPixels(int chars) {
|
|
579 // test for failure to initialize for backward compatibility
|
|
580 if (fontMetrics is null) {
|
|
581 return 0;
|
|
582 }
|
|
583 return convertWidthInCharsToPixels(fontMetrics, chars);
|
|
584 }
|
|
585
|
|
586 /**
|
|
587 * Creates a new button with the given id.
|
|
588 * <p>
|
|
589 * The <code>Dialog</code> implementation of this framework method creates
|
|
590 * a standard push button, registers it for selection events including
|
|
591 * button presses, and registers default buttons with its shell. The button
|
|
592 * id is stored as the button's client data. If the button id is
|
|
593 * <code>IDialogConstants.CANCEL_ID</code>, the new button will be
|
|
594 * accessible from <code>getCancelButton()</code>. If the button id is
|
|
595 * <code>IDialogConstants.OK_ID</code>, the new button will be accesible
|
|
596 * from <code>getOKButton()</code>. Note that the parent's layout is
|
|
597 * assumed to be a <code>GridLayout</code> and the number of columns in
|
|
598 * this layout is incremented. Subclasses may override.
|
|
599 * </p>
|
|
600 *
|
|
601 * @param parent
|
|
602 * the parent composite
|
|
603 * @param id
|
|
604 * the id of the button (see <code>IDialogConstants.*_ID</code>
|
|
605 * constants for standard dialog button ids)
|
|
606 * @param label
|
|
607 * the label from the button
|
|
608 * @param defaultButton
|
|
609 * <code>true</code> if the button is to be the default button,
|
|
610 * and <code>false</code> otherwise
|
|
611 *
|
|
612 * @return the new button
|
|
613 *
|
|
614 * @see #getCancelButton
|
|
615 * @see #getOKButton()
|
|
616 */
|
|
617 protected Button createButton(Composite parent, int id, String label,
|
|
618 bool defaultButton) {
|
|
619 // increment the number of columns in the button bar
|
|
620 (cast(GridLayout) parent.getLayout()).numColumns++;
|
|
621 Button button = new Button(parent, DWT.PUSH);
|
|
622 button.setText(label);
|
|
623 button.setFont(JFaceResources.getDialogFont());
|
|
624 button.setData(new ValueWrapperInt(id));
|
|
625 button.addSelectionListener(new class SelectionAdapter {
|
|
626 public void widgetSelected(SelectionEvent event) {
|
|
627 buttonPressed((cast(ValueWrapperInt) event.widget.getData()).value);
|
|
628 }
|
|
629 });
|
|
630 if (defaultButton) {
|
|
631 Shell shell = parent.getShell();
|
|
632 if (shell !is null) {
|
|
633 shell.setDefaultButton(button);
|
|
634 }
|
|
635 }
|
|
636 buttons[id] = button;
|
|
637 setButtonLayoutData(button);
|
|
638 return button;
|
|
639 }
|
|
640
|
|
641 /**
|
|
642 * Creates and returns the contents of this dialog's button bar.
|
|
643 * <p>
|
|
644 * The <code>Dialog</code> implementation of this framework method lays
|
|
645 * out a button bar and calls the <code>createButtonsForButtonBar</code>
|
|
646 * framework method to populate it. Subclasses may override.
|
|
647 * </p>
|
|
648 * <p>
|
|
649 * The returned control's layout data must be an instance of
|
|
650 * <code>GridData</code>.
|
|
651 * </p>
|
|
652 *
|
|
653 * @param parent
|
|
654 * the parent composite to contain the button bar
|
|
655 * @return the button bar control
|
|
656 */
|
|
657 protected Control createButtonBar(Composite parent) {
|
|
658 Composite composite = new Composite(parent, DWT.NONE);
|
|
659 // create a layout with spacing and margins appropriate for the font
|
|
660 // size.
|
|
661 GridLayout layout = new GridLayout();
|
|
662 layout.numColumns = 0; // this is incremented by createButton
|
|
663 layout.makeColumnsEqualWidth = true;
|
|
664 layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
|
|
665 layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
|
|
666 layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
|
|
667 layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
|
|
668 composite.setLayout(layout);
|
|
669 GridData data = new GridData(GridData.HORIZONTAL_ALIGN_END
|
|
670 | GridData.VERTICAL_ALIGN_CENTER);
|
|
671 composite.setLayoutData(data);
|
|
672 composite.setFont(parent.getFont());
|
|
673
|
|
674 // Add the buttons to the button bar.
|
|
675 createButtonsForButtonBar(composite);
|
|
676 return composite;
|
|
677 }
|
|
678
|
|
679 /**
|
|
680 * Adds buttons to this dialog's button bar.
|
|
681 * <p>
|
|
682 * The <code>Dialog</code> implementation of this framework method adds
|
|
683 * standard ok and cancel buttons using the <code>createButton</code>
|
|
684 * framework method. These standard buttons will be accessible from
|
|
685 * <code>getCancelButton</code>, and <code>getOKButton</code>.
|
|
686 * Subclasses may override.
|
|
687 * </p>
|
|
688 *
|
|
689 * @param parent
|
|
690 * the button bar composite
|
|
691 */
|
|
692 protected void createButtonsForButtonBar(Composite parent) {
|
|
693 // create OK and Cancel buttons by default
|
|
694 createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL,
|
|
695 true);
|
|
696 createButton(parent, IDialogConstants.CANCEL_ID,
|
|
697 IDialogConstants.CANCEL_LABEL, false);
|
|
698 }
|
|
699
|
|
700 /*
|
|
701 * @see Window.initializeBounds()
|
|
702 */
|
|
703 protected void initializeBounds() {
|
|
704 String platform = DWT.getPlatform();
|
|
705 if ("carbon".equals(platform)) { //$NON-NLS-1$
|
|
706 // On Mac OS X the default button must be the right-most button
|
|
707 Shell shell = getShell();
|
|
708 if (shell !is null) {
|
|
709 Button defaultButton = shell.getDefaultButton();
|
|
710 if (defaultButton !is null
|
|
711 && isContained(buttonBar, defaultButton)) {
|
|
712 defaultButton.moveBelow(null);
|
|
713 }
|
|
714 }
|
|
715 }
|
|
716
|
|
717 super.initializeBounds();
|
|
718 }
|
|
719
|
|
720 /**
|
|
721 * Returns true if the given Control is a direct or indirect child of
|
|
722 * container.
|
|
723 *
|
|
724 * @param container
|
|
725 * the potential parent
|
|
726 * @param control
|
|
727 * @return bool <code>true</code> if control is a child of container
|
|
728 */
|
|
729 private bool isContained(Control container, Control control) {
|
|
730 Composite parent;
|
|
731 while ((parent = control.getParent()) !is null) {
|
|
732 if (parent is container) {
|
|
733 return true;
|
|
734 }
|
|
735 control = parent;
|
|
736 }
|
|
737 return false;
|
|
738 }
|
|
739
|
|
740 /**
|
|
741 * The <code>Dialog</code> implementation of this <code>Window</code>
|
|
742 * method creates and lays out the top level composite for the dialog, and
|
|
743 * determines the appropriate horizontal and vertical dialog units based on
|
|
744 * the font size. It then calls the <code>createDialogArea</code> and
|
|
745 * <code>createButtonBar</code> methods to create the dialog area and
|
|
746 * button bar, respectively. Overriding <code>createDialogArea</code> and
|
|
747 * <code>createButtonBar</code> are recommended rather than overriding
|
|
748 * this method.
|
|
749 */
|
|
750 protected Control createContents(Composite parent) {
|
|
751 // create the top level composite for the dialog
|
|
752 Composite composite = new Composite(parent, 0);
|
|
753 GridLayout layout = new GridLayout();
|
|
754 layout.marginHeight = 0;
|
|
755 layout.marginWidth = 0;
|
|
756 layout.verticalSpacing = 0;
|
|
757 composite.setLayout(layout);
|
|
758 composite.setLayoutData(new GridData(GridData.FILL_BOTH));
|
|
759 applyDialogFont(composite);
|
|
760 // initialize the dialog units
|
|
761 initializeDialogUnits(composite);
|
|
762 // create the dialog area and button bar
|
|
763 dialogArea = createDialogArea(composite);
|
|
764 buttonBar = createButtonBar(composite);
|
|
765
|
|
766 return composite;
|
|
767 }
|
|
768
|
|
769 /**
|
|
770 * Creates and returns the contents of the upper part of this dialog (above
|
|
771 * the button bar).
|
|
772 * <p>
|
|
773 * The <code>Dialog</code> implementation of this framework method creates
|
|
774 * and returns a new <code>Composite</code> with standard margins and
|
|
775 * spacing.
|
|
776 * </p>
|
|
777 * <p>
|
|
778 * The returned control's layout data must be an instance of
|
|
779 * <code>GridData</code>. This method must not modify the parent's
|
|
780 * layout.
|
|
781 * </p>
|
|
782 * <p>
|
|
783 * Subclasses must override this method but may call <code>super</code> as
|
|
784 * in the following example:
|
|
785 * </p>
|
|
786 *
|
|
787 * <pre>
|
|
788 * Composite composite = (Composite) super.createDialogArea(parent);
|
|
789 * //add controls to composite as necessary
|
|
790 * return composite;
|
|
791 * </pre>
|
|
792 *
|
|
793 * @param parent
|
|
794 * the parent composite to contain the dialog area
|
|
795 * @return the dialog area control
|
|
796 */
|
|
797 protected Control createDialogArea(Composite parent) {
|
|
798 // create a composite with standard margins and spacing
|
|
799 Composite composite = new Composite(parent, DWT.NONE);
|
|
800 GridLayout layout = new GridLayout();
|
|
801 layout.marginHeight = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_MARGIN);
|
|
802 layout.marginWidth = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_MARGIN);
|
|
803 layout.verticalSpacing = convertVerticalDLUsToPixels(IDialogConstants.VERTICAL_SPACING);
|
|
804 layout.horizontalSpacing = convertHorizontalDLUsToPixels(IDialogConstants.HORIZONTAL_SPACING);
|
|
805 composite.setLayout(layout);
|
|
806 composite.setLayoutData(new GridData(GridData.FILL_BOTH));
|
|
807 applyDialogFont(composite);
|
|
808 return composite;
|
|
809 }
|
|
810
|
|
811 /**
|
|
812 * Returns the button created by the method <code>createButton</code> for
|
|
813 * the specified ID as defined on <code>IDialogConstants</code>. If
|
|
814 * <code>createButton</code> was never called with this ID, or if
|
|
815 * <code>createButton</code> is overridden, this method will return
|
|
816 * <code>null</code>.
|
|
817 *
|
|
818 * @param id
|
|
819 * the id of the button to look for
|
|
820 *
|
|
821 * @return the button for the ID or <code>null</code>
|
|
822 *
|
|
823 * @see #createButton(Composite, int, String, bool)
|
|
824 * @since 2.0
|
|
825 */
|
|
826 protected Button getButton(int id) {
|
|
827 return buttons[id];
|
|
828 }
|
|
829
|
|
830 /**
|
|
831 * Returns the button bar control.
|
|
832 * <p>
|
|
833 * Clients may call this framework method, but should not override it.
|
|
834 * </p>
|
|
835 *
|
|
836 * @return the button bar, or <code>null</code> if the button bar has not
|
|
837 * been created yet
|
|
838 */
|
|
839 protected Control getButtonBar() {
|
|
840 return buttonBar;
|
|
841 }
|
|
842
|
|
843 /**
|
|
844 * Returns the button created when <code>createButton</code> is called
|
|
845 * with an ID of <code>IDialogConstants.CANCEL_ID</code>. If
|
|
846 * <code>createButton</code> was never called with this parameter, or if
|
|
847 * <code>createButton</code> is overridden, <code>getCancelButton</code>
|
|
848 * will return <code>null</code>.
|
|
849 *
|
|
850 * @return the cancel button or <code>null</code>
|
|
851 *
|
|
852 * @see #createButton(Composite, int, String, bool)
|
|
853 * @since 2.0
|
|
854 * @deprecated Use <code>getButton(IDialogConstants.CANCEL_ID)</code>
|
|
855 * instead. This method will be removed soon.
|
|
856 */
|
|
857 protected Button getCancelButton() {
|
|
858 return getButton(IDialogConstants.CANCEL_ID);
|
|
859 }
|
|
860
|
|
861 /**
|
|
862 * Returns the dialog area control.
|
|
863 * <p>
|
|
864 * Clients may call this framework method, but should not override it.
|
|
865 * </p>
|
|
866 *
|
|
867 * @return the dialog area, or <code>null</code> if the dialog area has
|
|
868 * not been created yet
|
|
869 */
|
|
870 protected Control getDialogArea() {
|
|
871 return dialogArea;
|
|
872 }
|
|
873
|
|
874 /**
|
|
875 * Returns the standard dialog image with the given key. Note that these
|
|
876 * images are managed by the dialog framework, and must not be disposed by
|
|
877 * another party.
|
|
878 *
|
|
879 * @param key
|
|
880 * one of the <code>Dialog.DLG_IMG_* </code> constants
|
|
881 * @return the standard dialog image
|
|
882 *
|
|
883 * NOTE: Dialog does not use the following images in the registry
|
|
884 * DLG_IMG_ERROR DLG_IMG_INFO DLG_IMG_QUESTION DLG_IMG_WARNING
|
|
885 *
|
|
886 * They are now coming directly from DWT, see ImageRegistry. For backwards
|
|
887 * compatibility they are still supported, however new code should use DWT
|
|
888 * for these.
|
|
889 *
|
|
890 * @see Display#getSystemImage(int)
|
|
891 */
|
|
892 public static Image getImage(String key) {
|
|
893 return JFaceResources.getImageRegistry().get(key);
|
|
894 }
|
|
895
|
|
896 /**
|
|
897 * Returns the button created when <code>createButton</code> is called
|
|
898 * with an ID of <code>IDialogConstants.OK_ID</code>. If
|
|
899 * <code>createButton</code> was never called with this parameter, or if
|
|
900 * <code>createButton</code> is overridden, <code>getOKButton</code>
|
|
901 * will return <code>null</code>.
|
|
902 *
|
|
903 * @return the OK button or <code>null</code>
|
|
904 *
|
|
905 * @see #createButton(Composite, int, String, bool)
|
|
906 * @since 2.0
|
|
907 * @deprecated Use <code>getButton(IDialogConstants.OK_ID)</code> instead.
|
|
908 * This method will be removed soon.
|
|
909 */
|
|
910 protected Button getOKButton() {
|
|
911 return getButton(IDialogConstants.OK_ID);
|
|
912 }
|
|
913
|
|
914 /**
|
|
915 * Initializes the computation of horizontal and vertical dialog units based
|
|
916 * on the size of current font.
|
|
917 * <p>
|
|
918 * This method must be called before any of the dialog unit based conversion
|
|
919 * methods are called.
|
|
920 * </p>
|
|
921 *
|
|
922 * @param control
|
|
923 * a control from which to obtain the current font
|
|
924 */
|
|
925 protected void initializeDialogUnits(Control control) {
|
|
926 // Compute and store a font metric
|
|
927 GC gc = new GC(control);
|
|
928 gc.setFont(JFaceResources.getDialogFont());
|
|
929 fontMetrics = gc.getFontMetrics();
|
|
930 gc.dispose();
|
|
931 }
|
|
932
|
|
933 /**
|
|
934 * Notifies that the ok button of this dialog has been pressed.
|
|
935 * <p>
|
|
936 * The <code>Dialog</code> implementation of this framework method sets
|
|
937 * this dialog's return code to <code>Window.OK</code> and closes the
|
|
938 * dialog. Subclasses may override.
|
|
939 * </p>
|
|
940 */
|
|
941 protected void okPressed() {
|
|
942 setReturnCode(OK);
|
|
943 close();
|
|
944 }
|
|
945
|
|
946 /**
|
|
947 * Set the layout data of the button to a GridData with appropriate heights
|
|
948 * and widths.
|
|
949 *
|
|
950 * @param button
|
|
951 */
|
|
952 protected void setButtonLayoutData(Button button) {
|
|
953 GridData data = new GridData(GridData.HORIZONTAL_ALIGN_FILL);
|
|
954 int widthHint = convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
|
|
955 Point minSize = button.computeSize(DWT.DEFAULT, DWT.DEFAULT, true);
|
|
956 data.widthHint = Math.max(widthHint, minSize.x);
|
|
957 button.setLayoutData(data);
|
|
958 }
|
|
959
|
|
960 /**
|
|
961 * Set the layout data of the button to a FormData with appropriate heights
|
|
962 * and widths.
|
|
963 *
|
|
964 * @param button
|
|
965 */
|
|
966 protected void setButtonLayoutFormData(Button button) {
|
|
967 FormData data = new FormData();
|
|
968 int widthHint = convertHorizontalDLUsToPixels(IDialogConstants.BUTTON_WIDTH);
|
|
969 Point minSize = button.computeSize(DWT.DEFAULT, DWT.DEFAULT, true);
|
|
970 data.width = Math.max(widthHint, minSize.x);
|
|
971 button.setLayoutData(data);
|
|
972 }
|
|
973
|
|
974 /**
|
|
975 * @see dwtx.jface.window.Window#close()
|
|
976 */
|
|
977 public bool close() {
|
|
978 if (getShell() !is null && !getShell().isDisposed()) {
|
|
979 saveDialogBounds(getShell());
|
|
980 }
|
|
981
|
|
982 bool returnValue = super.close();
|
|
983 if (returnValue) {
|
|
984 buttons = null;
|
|
985 buttonBar = null;
|
|
986 dialogArea = null;
|
|
987 }
|
|
988 return returnValue;
|
|
989 }
|
|
990
|
|
991 /**
|
|
992 * Applies the dialog font to all controls that currently have the default
|
|
993 * font.
|
|
994 *
|
|
995 * @param control
|
|
996 * the control to apply the font to. Font will also be applied to
|
|
997 * its children. If the control is <code>null</code> nothing
|
|
998 * happens.
|
|
999 */
|
|
1000 public static void applyDialogFont(Control control) {
|
|
1001 if (control is null || dialogFontIsDefault()) {
|
|
1002 return;
|
|
1003 }
|
|
1004 Font dialogFont = JFaceResources.getDialogFont();
|
|
1005 applyDialogFont(control, dialogFont);
|
|
1006 }
|
|
1007
|
|
1008 /**
|
|
1009 * Sets the dialog font on the control and any of its children if thier font
|
|
1010 * is not otherwise set.
|
|
1011 *
|
|
1012 * @param control
|
|
1013 * the control to apply the font to. Font will also be applied to
|
|
1014 * its children.
|
|
1015 * @param dialogFont
|
|
1016 * the dialog font to set
|
|
1017 */
|
|
1018 private static void applyDialogFont(Control control, Font dialogFont) {
|
|
1019 if (hasDefaultFont(control)) {
|
|
1020 control.setFont(dialogFont);
|
|
1021 }
|
|
1022 if ( auto comp = cast(Composite)control ) {
|
|
1023 Control[] children = comp.getChildren();
|
|
1024 for (int i = 0; i < children.length; i++) {
|
|
1025 applyDialogFont(children[i], dialogFont);
|
|
1026 }
|
|
1027 }
|
|
1028 }
|
|
1029
|
|
1030 /**
|
|
1031 * Return whether or not this control has the same font as it's default.
|
|
1032 *
|
|
1033 * @param control
|
|
1034 * Control
|
|
1035 * @return bool
|
|
1036 */
|
|
1037 private static bool hasDefaultFont(Control control) {
|
|
1038 FontData[] controlFontData = control.getFont().getFontData();
|
|
1039 FontData[] defaultFontData = getDefaultFont(control).getFontData();
|
|
1040 if (controlFontData.length is defaultFontData.length) {
|
|
1041 for (int i = 0; i < controlFontData.length; i++) {
|
|
1042 if (controlFontData[i].opEquals(defaultFontData[i])) {
|
|
1043 continue;
|
|
1044 }
|
|
1045 return false;
|
|
1046 }
|
|
1047 return true;
|
|
1048 }
|
|
1049 return false;
|
|
1050 }
|
|
1051
|
|
1052 /**
|
|
1053 * Get the default font for this type of control.
|
|
1054 *
|
|
1055 * @param control
|
|
1056 * @return the default font
|
|
1057 */
|
|
1058 private static Font getDefaultFont(Control control) {
|
|
1059 String fontName = "DEFAULT_FONT_" ~ control.classinfo.name; //$NON-NLS-1$
|
|
1060 if (JFaceResources.getFontRegistry().hasValueFor(fontName)) {
|
|
1061 return JFaceResources.getFontRegistry().get(fontName);
|
|
1062 }
|
|
1063 Font cached = control.getFont();
|
|
1064 control.setFont(null);
|
|
1065 Font defaultFont = control.getFont();
|
|
1066 control.setFont(cached);
|
|
1067 JFaceResources.getFontRegistry().put(fontName,
|
|
1068 defaultFont.getFontData());
|
|
1069 return defaultFont;
|
|
1070 }
|
|
1071
|
|
1072 /**
|
|
1073 * Return whether or not the dialog font is currently the same as the
|
|
1074 * default font.
|
|
1075 *
|
|
1076 * @return bool if the two are the same
|
|
1077 */
|
|
1078 protected static bool dialogFontIsDefault() {
|
|
1079 FontData[] dialogFontData = JFaceResources.getFontRegistry()
|
|
1080 .getFontData(JFaceResources.DIALOG_FONT);
|
|
1081 FontData[] defaultFontData = JFaceResources.getFontRegistry()
|
|
1082 .getFontData(JFaceResources.DEFAULT_FONT);
|
|
1083 return ArrayEquals(dialogFontData, defaultFontData);
|
|
1084 }
|
|
1085
|
|
1086 /*
|
|
1087 * (non-Javadoc)
|
|
1088 *
|
|
1089 * @see dwtx.jface.window.Window#create()
|
|
1090 */
|
|
1091 public void create() {
|
|
1092 super.create();
|
|
1093 applyDialogFont(buttonBar);
|
|
1094 }
|
|
1095
|
|
1096 /**
|
|
1097 * Get the IDialogBlockedHandler to be used by WizardDialogs and
|
|
1098 * ModalContexts.
|
|
1099 *
|
|
1100 * @return Returns the blockedHandler.
|
|
1101 */
|
|
1102 public static IDialogBlockedHandler getBlockedHandler() {
|
|
1103 return blockedHandler;
|
|
1104 }
|
|
1105
|
|
1106 /**
|
|
1107 * Set the IDialogBlockedHandler to be used by WizardDialogs and
|
|
1108 * ModalContexts.
|
|
1109 *
|
|
1110 * @param blockedHandler
|
|
1111 * The blockedHandler for the dialogs.
|
|
1112 */
|
|
1113 public static void setBlockedHandler(IDialogBlockedHandler blockedHandler) {
|
|
1114 Dialog.blockedHandler = blockedHandler;
|
|
1115 }
|
|
1116
|
|
1117 /**
|
|
1118 * Gets the dialog settings that should be used for remembering the bounds of
|
|
1119 * of the dialog, according to the dialog bounds strategy.
|
|
1120 *
|
|
1121 * @return settings the dialog settings used to store the dialog's location
|
|
1122 * and/or size, or <code>null</code> if the dialog's bounds should
|
|
1123 * never be stored.
|
|
1124 *
|
|
1125 * @since 3.2
|
|
1126 * @see Dialog#getDialogBoundsStrategy()
|
|
1127 */
|
|
1128 protected IDialogSettings getDialogBoundsSettings() {
|
|
1129 return null;
|
|
1130 }
|
|
1131
|
|
1132 /**
|
|
1133 * Get the integer constant that describes the strategy for persisting the
|
|
1134 * dialog bounds. This strategy is ignored if the implementer does not also
|
|
1135 * specify the dialog settings for storing the bounds in
|
|
1136 * Dialog.getDialogBoundsSettings().
|
|
1137 *
|
|
1138 * @return the constant describing the strategy for persisting the dialog
|
|
1139 * bounds.
|
|
1140 *
|
|
1141 * @since 3.2
|
|
1142 * @see Dialog#DIALOG_PERSISTLOCATION
|
|
1143 * @see Dialog#DIALOG_PERSISTSIZE
|
|
1144 * @see Dialog#getDialogBoundsSettings()
|
|
1145 */
|
|
1146 protected int getDialogBoundsStrategy() {
|
|
1147 return DIALOG_PERSISTLOCATION | DIALOG_PERSISTSIZE;
|
|
1148 }
|
|
1149
|
|
1150 /**
|
|
1151 * Saves the bounds of the shell in the appropriate dialog settings. The
|
|
1152 * bounds are recorded relative to the parent shell, if there is one, or
|
|
1153 * display coordinates if there is no parent shell.
|
|
1154 *
|
|
1155 * @param shell
|
|
1156 * The shell whose bounds are to be stored
|
|
1157 *
|
|
1158 * @since 3.2
|
|
1159 */
|
|
1160 private void saveDialogBounds(Shell shell) {
|
|
1161 IDialogSettings settings = getDialogBoundsSettings();
|
|
1162 if (settings !is null) {
|
|
1163 Point shellLocation = shell.getLocation();
|
|
1164 Point shellSize = shell.getSize();
|
|
1165 Shell parent = getParentShell();
|
|
1166 if (parent !is null) {
|
|
1167 Point parentLocation = parent.getLocation();
|
|
1168 shellLocation.x -= parentLocation.x;
|
|
1169 shellLocation.y -= parentLocation.y;
|
|
1170 }
|
|
1171 int strategy = getDialogBoundsStrategy();
|
|
1172 if ((strategy & DIALOG_PERSISTLOCATION) !is 0) {
|
|
1173 settings.put(DIALOG_ORIGIN_X, shellLocation.x);
|
|
1174 settings.put(DIALOG_ORIGIN_Y, shellLocation.y);
|
|
1175 }
|
|
1176 if ((strategy & DIALOG_PERSISTSIZE) !is 0) {
|
|
1177 settings.put(DIALOG_WIDTH, shellSize.x);
|
|
1178 settings.put(DIALOG_HEIGHT, shellSize.y);
|
|
1179 FontData [] fontDatas = JFaceResources.getDialogFont().getFontData();
|
|
1180 if (fontDatas.length > 0) {
|
|
1181 settings.put(DIALOG_FONT_DATA, fontDatas[0].toString());
|
|
1182 }
|
|
1183 }
|
|
1184 }
|
|
1185 }
|
|
1186
|
|
1187 /**
|
|
1188 * Returns the initial size to use for the shell. Overridden
|
|
1189 * to check whether a size has been stored in dialog settings.
|
|
1190 * If a size has been stored, it is returned.
|
|
1191 *
|
|
1192 * @return the initial size of the shell
|
|
1193 *
|
|
1194 * @since 3.2
|
|
1195 * @see #getDialogBoundsSettings()
|
|
1196 * @see #getDialogBoundsStrategy()
|
|
1197 */
|
|
1198 protected Point getInitialSize() {
|
|
1199 Point result = super.getInitialSize();
|
|
1200
|
|
1201 // Check the dialog settings for a stored size.
|
|
1202 if ((getDialogBoundsStrategy() & DIALOG_PERSISTSIZE)!is 0) {
|
|
1203 IDialogSettings settings = getDialogBoundsSettings();
|
|
1204 if (settings !is null) {
|
|
1205 // Check that the dialog font matches the font used
|
|
1206 // when the bounds was stored. If the font has changed,
|
|
1207 // we do not honor the stored settings.
|
|
1208 // See https://bugs.eclipse.org/bugs/show_bug.cgi?id=132821
|
|
1209 bool useStoredBounds = true;
|
|
1210 String previousDialogFontData = settings.get(DIALOG_FONT_DATA);
|
|
1211 // There is a previously stored font, so we will check it.
|
|
1212 // Note that if we haven't stored the font before, then we will
|
|
1213 // use the stored bounds. This allows restoring of dialog bounds
|
|
1214 // that were stored before we started storing the fontdata.
|
|
1215 if (previousDialogFontData !is null && previousDialogFontData.length > 0) {
|
|
1216 FontData [] fontDatas = JFaceResources.getDialogFont().getFontData();
|
|
1217 if (fontDatas.length > 0) {
|
|
1218 String currentDialogFontData = fontDatas[0].toString();
|
|
1219 useStoredBounds = currentDialogFontData.equalsIgnoreCase(previousDialogFontData);
|
|
1220 }
|
|
1221 }
|
|
1222 if (useStoredBounds) {
|
|
1223 try {
|
|
1224 // Get the stored width and height.
|
|
1225 int width = settings.getInt(DIALOG_WIDTH);
|
|
1226 if (width !is DIALOG_DEFAULT_BOUNDS) {
|
|
1227 result.x = width;
|
|
1228 }
|
|
1229 int height = settings.getInt(DIALOG_HEIGHT);
|
|
1230 if (height !is DIALOG_DEFAULT_BOUNDS) {
|
|
1231 result.y = height;
|
|
1232 }
|
|
1233
|
|
1234 } catch (NumberFormatException e) {
|
|
1235 }
|
|
1236 }
|
|
1237 }
|
|
1238 }
|
|
1239 // No attempt is made to constrain the bounds. The default
|
|
1240 // constraining behavior in Window will be used.
|
|
1241 return result;
|
|
1242 }
|
|
1243
|
|
1244 /**
|
|
1245 * Returns the initial location to use for the shell. Overridden
|
|
1246 * to check whether the bounds of the dialog have been stored in
|
|
1247 * dialog settings. If a location has been stored, it is returned.
|
|
1248 *
|
|
1249 * @param initialSize
|
|
1250 * the initial size of the shell, as returned by
|
|
1251 * <code>getInitialSize</code>.
|
|
1252 * @return the initial location of the shell
|
|
1253 *
|
|
1254 * @since 3.2
|
|
1255 * @see #getDialogBoundsSettings()
|
|
1256 * @see #getDialogBoundsStrategy()
|
|
1257 */
|
|
1258 protected Point getInitialLocation(Point initialSize) {
|
|
1259 Point result = super.getInitialLocation(initialSize);
|
|
1260 if ((getDialogBoundsStrategy() & DIALOG_PERSISTLOCATION)!is 0) {
|
|
1261 IDialogSettings settings = getDialogBoundsSettings();
|
|
1262 if (settings !is null) {
|
|
1263 try {
|
|
1264 int x = settings.getInt(DIALOG_ORIGIN_X);
|
|
1265 int y = settings.getInt(DIALOG_ORIGIN_Y);
|
|
1266 result = new Point(x, y);
|
|
1267 // The coordinates were stored relative to the parent shell.
|
|
1268 // Convert to display coordinates.
|
|
1269 Shell parent = getParentShell();
|
|
1270 if (parent !is null) {
|
|
1271 Point parentLocation = parent.getLocation();
|
|
1272 result.x += parentLocation.x;
|
|
1273 result.y += parentLocation.y;
|
|
1274 }
|
|
1275 } catch (NumberFormatException e) {
|
|
1276 }
|
|
1277 }
|
|
1278 }
|
|
1279 // No attempt is made to constrain the bounds. The default
|
|
1280 // constraining behavior in Window will be used.
|
|
1281 return result;
|
|
1282 }
|
|
1283
|
|
1284 }
|