|
9
|
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 * Teddy Walker <teddy.walker@googlemail.com>
|
|
|
11 * - Bug 188056 [Preferences] PreferencePages have to less indent in PreferenceDialog
|
|
|
12 * Port to the D programming language:
|
|
|
13 * Frank Benoit <benoit@tionex.de>
|
|
|
14 *******************************************************************************/
|
|
|
15 module dwtx.jface.preference.PreferenceDialog;
|
|
|
16
|
|
|
17 import dwt.dwthelper.utils;
|
|
|
18
|
|
|
19 pragma( msg, "FIXME dwtx.jface.preference.PreferenceDialog" );
|
|
|
20 class PreferenceDialog{
|
|
|
21 public static const String PREF_DLG_TITLE_IMG = "preference_dialog_title_image"; //$NON-NLS-1$
|
|
|
22 }
|
|
|
23
|
|
|
24 /++
|
|
|
25 import java.io.IOException;
|
|
|
26 import java.util.Iterator;
|
|
|
27 import java.util.List;
|
|
|
28
|
|
|
29 import dwt.DWT;
|
|
|
30 import dwt.custom.BusyIndicator;
|
|
|
31 import dwt.custom.ScrolledComposite;
|
|
|
32 import dwt.events.ControlAdapter;
|
|
|
33 import dwt.events.ControlEvent;
|
|
|
34 import dwt.events.DisposeEvent;
|
|
|
35 import dwt.events.DisposeListener;
|
|
|
36 import dwt.events.HelpEvent;
|
|
|
37 import dwt.events.HelpListener;
|
|
|
38 import dwt.events.SelectionAdapter;
|
|
|
39 import dwt.events.SelectionEvent;
|
|
|
40 import dwt.events.ShellAdapter;
|
|
|
41 import dwt.events.ShellEvent;
|
|
|
42 import dwt.graphics.Font;
|
|
|
43 import dwt.graphics.Point;
|
|
|
44 import dwt.graphics.Rectangle;
|
|
|
45 import dwt.layout.FormAttachment;
|
|
|
46 import dwt.layout.FormData;
|
|
|
47 import dwt.layout.FormLayout;
|
|
|
48 import dwt.layout.GridData;
|
|
|
49 import dwt.layout.GridLayout;
|
|
|
50 import dwt.widgets.Button;
|
|
|
51 import dwt.widgets.Composite;
|
|
|
52 import dwt.widgets.Control;
|
|
|
53 import dwt.widgets.Event;
|
|
|
54 import dwt.widgets.Label;
|
|
|
55 import dwt.widgets.Layout;
|
|
|
56 import dwt.widgets.Listener;
|
|
|
57 import dwt.widgets.Sash;
|
|
|
58 import dwt.widgets.Shell;
|
|
|
59 import dwt.widgets.Tree;
|
|
|
60 import dwtx.core.runtime.Assert;
|
|
|
61 import dwtx.core.runtime.ISafeRunnable;
|
|
|
62 import dwtx.core.runtime.IStatus;
|
|
|
63 import dwtx.core.runtime.ListenerList;
|
|
|
64 import dwtx.core.runtime.SafeRunner;
|
|
|
65 import dwtx.core.runtime.Status;
|
|
|
66 import dwtx.jface.dialogs.DialogMessageArea;
|
|
|
67 import dwtx.jface.dialogs.IDialogConstants;
|
|
|
68 import dwtx.jface.dialogs.IMessageProvider;
|
|
|
69 import dwtx.jface.dialogs.IPageChangeProvider;
|
|
|
70 import dwtx.jface.dialogs.IPageChangedListener;
|
|
|
71 import dwtx.jface.dialogs.MessageDialog;
|
|
|
72 import dwtx.jface.dialogs.PageChangedEvent;
|
|
|
73 import dwtx.jface.dialogs.TrayDialog;
|
|
|
74 import dwtx.jface.resource.JFaceResources;
|
|
|
75 import dwtx.jface.util.IPropertyChangeListener;
|
|
|
76 import dwtx.jface.util.Policy;
|
|
|
77 import dwtx.jface.util.PropertyChangeEvent;
|
|
|
78 import dwtx.jface.util.SafeRunnable;
|
|
|
79 import dwtx.jface.viewers.ISelection;
|
|
|
80 import dwtx.jface.viewers.ISelectionChangedListener;
|
|
|
81 import dwtx.jface.viewers.IStructuredSelection;
|
|
|
82 import dwtx.jface.viewers.SelectionChangedEvent;
|
|
|
83 import dwtx.jface.viewers.StructuredSelection;
|
|
|
84 import dwtx.jface.viewers.TreeViewer;
|
|
|
85 import dwtx.jface.viewers.ViewerFilter;
|
|
|
86
|
|
|
87 /**
|
|
|
88 * A preference dialog is a hierarchical presentation of preference pages. Each
|
|
|
89 * page is represented by a node in the tree shown on the left hand side of the
|
|
|
90 * dialog; when a node is selected, the corresponding page is shown on the right
|
|
|
91 * hand side.
|
|
|
92 */
|
|
|
93 public class PreferenceDialog extends TrayDialog implements IPreferencePageContainer, IPageChangeProvider {
|
|
|
94 /**
|
|
|
95 * Layout for the page container.
|
|
|
96 *
|
|
|
97 */
|
|
|
98 private class PageLayout extends Layout {
|
|
|
99 public Point computeSize(Composite composite, int wHint, int hHint, bool force) {
|
|
|
100 if (wHint !is DWT.DEFAULT && hHint !is DWT.DEFAULT) {
|
|
|
101 return new Point(wHint, hHint);
|
|
|
102 }
|
|
|
103 int x = minimumPageSize.x;
|
|
|
104 int y = minimumPageSize.y;
|
|
|
105 Control[] children = composite.getChildren();
|
|
|
106 for (int i = 0; i < children.length; i++) {
|
|
|
107 Point size = children[i].computeSize(DWT.DEFAULT, DWT.DEFAULT, force);
|
|
|
108 x = Math.max(x, size.x);
|
|
|
109 y = Math.max(y, size.y);
|
|
|
110 }
|
|
|
111
|
|
|
112 //As pages can implement thier own computeSize
|
|
|
113 //take it into account
|
|
|
114 if(currentPage !is null){
|
|
|
115 Point size = currentPage.computeSize();
|
|
|
116 x = Math.max(x, size.x);
|
|
|
117 y = Math.max(y, size.y);
|
|
|
118 }
|
|
|
119
|
|
|
120 if (wHint !is DWT.DEFAULT) {
|
|
|
121 x = wHint;
|
|
|
122 }
|
|
|
123 if (hHint !is DWT.DEFAULT) {
|
|
|
124 y = hHint;
|
|
|
125 }
|
|
|
126 return new Point(x, y);
|
|
|
127 }
|
|
|
128
|
|
|
129 public void layout(Composite composite, bool force) {
|
|
|
130 Rectangle rect = composite.getClientArea();
|
|
|
131 Control[] children = composite.getChildren();
|
|
|
132 for (int i = 0; i < children.length; i++) {
|
|
|
133 children[i].setSize(rect.width, rect.height);
|
|
|
134 }
|
|
|
135 }
|
|
|
136 }
|
|
|
137
|
|
|
138 //The id of the last page that was selected
|
|
|
139 private static String lastPreferenceId = null;
|
|
|
140
|
|
|
141 //The last known tree width
|
|
|
142 private static int lastTreeWidth = 180;
|
|
|
143
|
|
|
144 /**
|
|
|
145 * Indentifier for the error image
|
|
|
146 */
|
|
|
147 public static final String PREF_DLG_IMG_TITLE_ERROR = DLG_IMG_MESSAGE_ERROR;
|
|
|
148
|
|
|
149 /**
|
|
|
150 * Title area fields
|
|
|
151 */
|
|
|
152 public static final String PREF_DLG_TITLE_IMG = "preference_dialog_title_image"; //$NON-NLS-1$
|
|
|
153
|
|
|
154 /**
|
|
|
155 * Return code used when dialog failed
|
|
|
156 */
|
|
|
157 protected static final int FAILED = 2;
|
|
|
158
|
|
|
159 /**
|
|
|
160 * The current preference page, or <code>null</code> if there is none.
|
|
|
161 */
|
|
|
162 private IPreferencePage currentPage;
|
|
|
163
|
|
|
164 private DialogMessageArea messageArea;
|
|
|
165
|
|
|
166 private Point lastShellSize;
|
|
|
167
|
|
|
168 private IPreferenceNode lastSuccessfulNode;
|
|
|
169
|
|
|
170 /**
|
|
|
171 * The minimum page size; 400 by 400 by default.
|
|
|
172 *
|
|
|
173 * @see #setMinimumPageSize(Point)
|
|
|
174 */
|
|
|
175 private Point minimumPageSize = new Point(400, 400);
|
|
|
176
|
|
|
177 /**
|
|
|
178 * The OK button.
|
|
|
179 */
|
|
|
180 private Button okButton;
|
|
|
181
|
|
|
182 /**
|
|
|
183 * The Composite in which a page is shown.
|
|
|
184 */
|
|
|
185 private Composite pageContainer;
|
|
|
186
|
|
|
187 /**
|
|
|
188 * The preference manager.
|
|
|
189 */
|
|
|
190 private PreferenceManager preferenceManager;
|
|
|
191
|
|
|
192 /**
|
|
|
193 * Flag for the presence of the error message.
|
|
|
194 */
|
|
|
195 private bool showingError = false;
|
|
|
196
|
|
|
197 /**
|
|
|
198 * Preference store, initially <code>null</code> meaning none.
|
|
|
199 *
|
|
|
200 * @see #setPreferenceStore
|
|
|
201 */
|
|
|
202 private IPreferenceStore preferenceStore;
|
|
|
203
|
|
|
204 private Composite titleArea;
|
|
|
205
|
|
|
206 /**
|
|
|
207 * The tree viewer.
|
|
|
208 */
|
|
|
209 private TreeViewer treeViewer;
|
|
|
210
|
|
|
211 private ListenerList pageChangedListeners = new ListenerList();
|
|
|
212
|
|
|
213 /**
|
|
|
214 * Composite with a FormLayout to contain the title area
|
|
|
215 */
|
|
|
216 Composite formTitleComposite;
|
|
|
217
|
|
|
218 private ScrolledComposite scrolled;
|
|
|
219
|
|
|
220 /**
|
|
|
221 * Creates a new preference dialog under the control of the given preference
|
|
|
222 * manager.
|
|
|
223 *
|
|
|
224 * @param parentShell
|
|
|
225 * the parent shell
|
|
|
226 * @param manager
|
|
|
227 * the preference manager
|
|
|
228 */
|
|
|
229 public PreferenceDialog(Shell parentShell, PreferenceManager manager) {
|
|
|
230 super(parentShell);
|
|
|
231 setShellStyle(getShellStyle() | DWT.RESIZE | DWT.MAX);
|
|
|
232 preferenceManager = manager;
|
|
|
233 }
|
|
|
234
|
|
|
235 /*
|
|
|
236 * (non-Javadoc)
|
|
|
237 *
|
|
|
238 * @see dwtx.jface.dialogs.Dialog#buttonPressed(int)
|
|
|
239 */
|
|
|
240 protected void buttonPressed(int buttonId) {
|
|
|
241 switch (buttonId) {
|
|
|
242 case IDialogConstants.OK_ID: {
|
|
|
243 okPressed();
|
|
|
244 return;
|
|
|
245 }
|
|
|
246 case IDialogConstants.CANCEL_ID: {
|
|
|
247 cancelPressed();
|
|
|
248 return;
|
|
|
249 }
|
|
|
250 case IDialogConstants.HELP_ID: {
|
|
|
251 helpPressed();
|
|
|
252 return;
|
|
|
253 }
|
|
|
254 }
|
|
|
255 }
|
|
|
256
|
|
|
257 /*
|
|
|
258 * (non-Javadoc)
|
|
|
259 *
|
|
|
260 * @see dwtx.jface.dialogs.Dialog#cancelPressed()
|
|
|
261 */
|
|
|
262 protected void cancelPressed() {
|
|
|
263 // Inform all pages that we are cancelling
|
|
|
264 Iterator nodes = preferenceManager.getElements(PreferenceManager.PRE_ORDER).iterator();
|
|
|
265 while (nodes.hasNext()) {
|
|
|
266 final IPreferenceNode node = (IPreferenceNode) nodes.next();
|
|
|
267 if (getPage(node) !is null) {
|
|
|
268 SafeRunnable.run(new SafeRunnable() {
|
|
|
269 public void run() {
|
|
|
270 if (!getPage(node).performCancel()) {
|
|
|
271 return;
|
|
|
272 }
|
|
|
273 }
|
|
|
274 });
|
|
|
275 }
|
|
|
276 }
|
|
|
277 setReturnCode(CANCEL);
|
|
|
278 close();
|
|
|
279 }
|
|
|
280
|
|
|
281 /**
|
|
|
282 * Clear the last selected node. This is so that we not chache the last
|
|
|
283 * selection in case of an error.
|
|
|
284 */
|
|
|
285 void clearSelectedNode() {
|
|
|
286 setSelectedNodePreference(null);
|
|
|
287 }
|
|
|
288
|
|
|
289 /*
|
|
|
290 * (non-Javadoc)
|
|
|
291 *
|
|
|
292 * @see dwtx.jface.window.Window#close()
|
|
|
293 */
|
|
|
294 public bool close() {
|
|
|
295
|
|
|
296 //Do this is in a SafeRunnable as it may run client code
|
|
|
297 SafeRunnable runnable = new SafeRunnable(){
|
|
|
298 /* (non-Javadoc)
|
|
|
299 * @see dwtx.core.runtime.ISafeRunnable#run()
|
|
|
300 */
|
|
|
301 public void run() throws Exception {
|
|
|
302 List nodes = preferenceManager.getElements(PreferenceManager.PRE_ORDER);
|
|
|
303 for (int i = 0; i < nodes.size(); i++) {
|
|
|
304 IPreferenceNode node = (IPreferenceNode) nodes.get(i);
|
|
|
305 node.disposeResources();
|
|
|
306 }
|
|
|
307
|
|
|
308 }
|
|
|
309
|
|
|
310 /* (non-Javadoc)
|
|
|
311 * @see dwtx.jface.util.SafeRunnable#handleException(java.lang.Throwable)
|
|
|
312 */
|
|
|
313 public void handleException(Throwable e) {
|
|
|
314 super.handleException(e);
|
|
|
315 clearSelectedNode();//Do not cache a node with problems
|
|
|
316 }
|
|
|
317 };
|
|
|
318
|
|
|
319 SafeRunner.run(runnable);
|
|
|
320
|
|
|
321 return super.close();
|
|
|
322 }
|
|
|
323
|
|
|
324 /*
|
|
|
325 * (non-Javadoc)
|
|
|
326 *
|
|
|
327 * @see dwtx.jface.window.Window#configureShell(dwt.widgets.Shell)
|
|
|
328 */
|
|
|
329 protected void configureShell(Shell newShell) {
|
|
|
330 super.configureShell(newShell);
|
|
|
331 newShell.setText(JFaceResources.getString("PreferenceDialog.title")); //$NON-NLS-1$
|
|
|
332 newShell.addShellListener(new ShellAdapter() {
|
|
|
333 public void shellActivated(ShellEvent e) {
|
|
|
334 if (lastShellSize is null) {
|
|
|
335 lastShellSize = getShell().getSize();
|
|
|
336 }
|
|
|
337 }
|
|
|
338
|
|
|
339 });
|
|
|
340
|
|
|
341 }
|
|
|
342
|
|
|
343 /*
|
|
|
344 * (non-Javadoc)
|
|
|
345 *
|
|
|
346 * @see dwtx.jface.window.Window#constrainShellSize()
|
|
|
347 */
|
|
|
348 protected void constrainShellSize() {
|
|
|
349 super.constrainShellSize();
|
|
|
350 // record opening shell size
|
|
|
351 if (lastShellSize is null) {
|
|
|
352 lastShellSize = getShell().getSize();
|
|
|
353 }
|
|
|
354 }
|
|
|
355
|
|
|
356 /*
|
|
|
357 * (non-Javadoc)
|
|
|
358 *
|
|
|
359 * @see dwtx.jface.dialogs.Dialog#createButtonsForButtonBar(dwt.widgets.Composite)
|
|
|
360 */
|
|
|
361 protected void createButtonsForButtonBar(Composite parent) {
|
|
|
362 // create OK and Cancel buttons by default
|
|
|
363 okButton = createButton(parent, IDialogConstants.OK_ID, IDialogConstants.OK_LABEL, true);
|
|
|
364 getShell().setDefaultButton(okButton);
|
|
|
365 createButton(parent, IDialogConstants.CANCEL_ID, IDialogConstants.CANCEL_LABEL, false);
|
|
|
366 }
|
|
|
367
|
|
|
368 /*
|
|
|
369 * (non-Javadoc)
|
|
|
370 *
|
|
|
371 * @see dwtx.jface.window.Window#createContents(dwt.widgets.Composite)
|
|
|
372 */
|
|
|
373 protected Control createContents(final Composite parent) {
|
|
|
374 final Control[] control = new Control[1];
|
|
|
375 BusyIndicator.showWhile(getShell().getDisplay(), new Runnable() {
|
|
|
376 public void run() {
|
|
|
377 control[0] = PreferenceDialog.super.createContents(parent);
|
|
|
378 // Add the first page
|
|
|
379 selectSavedItem();
|
|
|
380 }
|
|
|
381 });
|
|
|
382
|
|
|
383 return control[0];
|
|
|
384 }
|
|
|
385
|
|
|
386 /*
|
|
|
387 * (non-Javadoc)
|
|
|
388 *
|
|
|
389 * @see dwtx.jface.dialogs.Dialog#createDialogArea(dwt.widgets.Composite)
|
|
|
390 */
|
|
|
391 protected Control createDialogArea(Composite parent) {
|
|
|
392 final Composite composite = (Composite) super.createDialogArea(parent);
|
|
|
393 GridLayout parentLayout = ((GridLayout) composite.getLayout());
|
|
|
394 parentLayout.numColumns = 4;
|
|
|
395 parentLayout.marginHeight = 0;
|
|
|
396 parentLayout.marginWidth = 0;
|
|
|
397 parentLayout.verticalSpacing = 0;
|
|
|
398 parentLayout.horizontalSpacing = 0;
|
|
|
399
|
|
|
400 composite.setBackground(parent.getDisplay().getSystemColor(DWT.COLOR_LIST_BACKGROUND));
|
|
|
401
|
|
|
402 Control treeControl = createTreeAreaContents(composite);
|
|
|
403 createSash(composite,treeControl);
|
|
|
404
|
|
|
405 Label versep = new Label(composite, DWT.SEPARATOR | DWT.VERTICAL);
|
|
|
406 GridData verGd = new GridData(GridData.FILL_VERTICAL | GridData.GRAB_VERTICAL);
|
|
|
407
|
|
|
408 versep.setLayoutData(verGd);
|
|
|
409 versep.setLayoutData(new GridData(DWT.LEFT, DWT.FILL, false, true));
|
|
|
410
|
|
|
411 Composite pageAreaComposite = new Composite(composite, DWT.NONE);
|
|
|
412 pageAreaComposite.setLayoutData(new GridData(GridData.FILL_BOTH));
|
|
|
413 GridLayout layout = new GridLayout(1, true);
|
|
|
414 layout.marginHeight = 0;
|
|
|
415 layout.marginWidth = 0;
|
|
|
416 layout.verticalSpacing = 0;
|
|
|
417 pageAreaComposite.setLayout(layout);
|
|
|
418
|
|
|
419 formTitleComposite = new Composite(pageAreaComposite, DWT.NONE);
|
|
|
420 FormLayout titleLayout = new FormLayout();
|
|
|
421 titleLayout.marginWidth = 0;
|
|
|
422 titleLayout.marginHeight = 0;
|
|
|
423 formTitleComposite.setLayout(titleLayout);
|
|
|
424
|
|
|
425 GridData titleGridData = new GridData(GridData.FILL_HORIZONTAL);
|
|
|
426 titleGridData.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
|
|
|
427 formTitleComposite.setLayoutData(titleGridData);
|
|
|
428
|
|
|
429 // Build the title area and separator line
|
|
|
430 Composite titleComposite = new Composite(formTitleComposite, DWT.NONE);
|
|
|
431 layout = new GridLayout();
|
|
|
432 layout.marginBottom = 5;
|
|
|
433 layout.marginHeight = 0;
|
|
|
434 layout.marginWidth = 0;
|
|
|
435 layout.horizontalSpacing = 0;
|
|
|
436 titleComposite.setLayout(layout);
|
|
|
437
|
|
|
438 FormData titleFormData = new FormData();
|
|
|
439 titleFormData.top = new FormAttachment(0,0);
|
|
|
440 titleFormData.left = new FormAttachment(0,0);
|
|
|
441 titleFormData.right = new FormAttachment(100,0);
|
|
|
442 titleFormData.bottom = new FormAttachment(100,0);
|
|
|
443
|
|
|
444 titleComposite.setLayoutData(titleFormData);
|
|
|
445 createTitleArea(titleComposite);
|
|
|
446
|
|
|
447 Label separator = new Label(pageAreaComposite, DWT.HORIZONTAL | DWT.SEPARATOR);
|
|
|
448
|
|
|
449 separator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
|
|
|
450
|
|
|
451
|
|
|
452 // Build the Page container
|
|
|
453 pageContainer = createPageContainer(pageAreaComposite);
|
|
|
454 GridData pageContainerData = new GridData(GridData.FILL_BOTH);
|
|
|
455 pageContainerData.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
|
|
|
456 pageContainer.setLayoutData(pageContainerData);
|
|
|
457 // Build the separator line
|
|
|
458 Label bottomSeparator = new Label(parent, DWT.HORIZONTAL | DWT.SEPARATOR);
|
|
|
459 bottomSeparator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL | GridData.GRAB_HORIZONTAL));
|
|
|
460 return composite;
|
|
|
461 }
|
|
|
462
|
|
|
463 /**
|
|
|
464 * Create the sash with right control on the right. Note
|
|
|
465 * that this method assumes GridData for the layout data
|
|
|
466 * of the rightControl.
|
|
|
467 * @param composite
|
|
|
468 * @param rightControl
|
|
|
469 * @return Sash
|
|
|
470 *
|
|
|
471 * @since 3.1
|
|
|
472 */
|
|
|
473 protected Sash createSash(final Composite composite, final Control rightControl) {
|
|
|
474 final Sash sash = new Sash(composite, DWT.VERTICAL);
|
|
|
475 sash.setLayoutData(new GridData(GridData.FILL_VERTICAL));
|
|
|
476 sash.setBackground(composite.getDisplay().getSystemColor(DWT.COLOR_LIST_BACKGROUND));
|
|
|
477 // the following listener resizes the tree control based on sash deltas.
|
|
|
478 // If necessary, it will also grow/shrink the dialog.
|
|
|
479 sash.addListener(DWT.Selection, new Listener() {
|
|
|
480 /*
|
|
|
481 * (non-Javadoc)
|
|
|
482 *
|
|
|
483 * @see dwt.widgets.Listener#handleEvent(dwt.widgets.Event)
|
|
|
484 */
|
|
|
485 public void handleEvent(Event event) {
|
|
|
486 if (event.detail is DWT.DRAG) {
|
|
|
487 return;
|
|
|
488 }
|
|
|
489 int shift = event.x - sash.getBounds().x;
|
|
|
490 GridData data = (GridData) rightControl.getLayoutData();
|
|
|
491 int newWidthHint = data.widthHint + shift;
|
|
|
492 if (newWidthHint < 20) {
|
|
|
493 return;
|
|
|
494 }
|
|
|
495 Point computedSize = getShell().computeSize(DWT.DEFAULT, DWT.DEFAULT);
|
|
|
496 Point currentSize = getShell().getSize();
|
|
|
497 // if the dialog wasn't of a custom size we know we can shrink
|
|
|
498 // it if necessary based on sash movement.
|
|
|
499 bool customSize = !computedSize.equals(currentSize);
|
|
|
500 data.widthHint = newWidthHint;
|
|
|
501 setLastTreeWidth(newWidthHint);
|
|
|
502 composite.layout(true);
|
|
|
503 // recompute based on new widget size
|
|
|
504 computedSize = getShell().computeSize(DWT.DEFAULT, DWT.DEFAULT);
|
|
|
505 // if the dialog was of a custom size then increase it only if
|
|
|
506 // necessary.
|
|
|
507 if (customSize) {
|
|
|
508 computedSize.x = Math.max(computedSize.x, currentSize.x);
|
|
|
509 }
|
|
|
510 computedSize.y = Math.max(computedSize.y, currentSize.y);
|
|
|
511 if (computedSize.equals(currentSize)) {
|
|
|
512 return;
|
|
|
513 }
|
|
|
514 setShellSize(computedSize.x, computedSize.y);
|
|
|
515 lastShellSize = getShell().getSize();
|
|
|
516 }
|
|
|
517 });
|
|
|
518 return sash;
|
|
|
519 }
|
|
|
520
|
|
|
521 /**
|
|
|
522 * Creates the inner page container.
|
|
|
523 *
|
|
|
524 * @param parent
|
|
|
525 * @return Composite
|
|
|
526 */
|
|
|
527 protected Composite createPageContainer(Composite parent) {
|
|
|
528
|
|
|
529 Composite outer = new Composite(parent, DWT.NONE);
|
|
|
530
|
|
|
531 GridData outerData = new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL
|
|
|
532 | GridData.GRAB_VERTICAL);
|
|
|
533 outerData.horizontalIndent = IDialogConstants.HORIZONTAL_MARGIN;
|
|
|
534
|
|
|
535 outer.setLayout(new GridLayout());
|
|
|
536 outer.setLayoutData(outerData);
|
|
|
537
|
|
|
538 //Create an outer composite for spacing
|
|
|
539 scrolled = new ScrolledComposite(outer, DWT.V_SCROLL | DWT.H_SCROLL);
|
|
|
540
|
|
|
541 scrolled.setExpandHorizontal(true);
|
|
|
542 scrolled.setExpandVertical(true);
|
|
|
543
|
|
|
544 GridData scrolledData = new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL
|
|
|
545 | GridData.GRAB_VERTICAL);
|
|
|
546
|
|
|
547 scrolled.setLayoutData(scrolledData);
|
|
|
548
|
|
|
549 Composite result = new Composite(scrolled, DWT.NONE);
|
|
|
550
|
|
|
551 GridData resultData = new GridData(GridData.FILL_BOTH | GridData.GRAB_HORIZONTAL
|
|
|
552 | GridData.GRAB_VERTICAL);
|
|
|
553
|
|
|
554 result.setLayout(getPageLayout());
|
|
|
555 result.setLayoutData(resultData);
|
|
|
556
|
|
|
557 scrolled.setContent(result);
|
|
|
558
|
|
|
559 return result;
|
|
|
560 }
|
|
|
561
|
|
|
562 /**
|
|
|
563 * Return the layout for the composite that contains
|
|
|
564 * the pages.
|
|
|
565 * @return PageLayout
|
|
|
566 *
|
|
|
567 * @since 3.1
|
|
|
568 */
|
|
|
569 protected Layout getPageLayout() {
|
|
|
570 return new PageLayout();
|
|
|
571 }
|
|
|
572
|
|
|
573 /**
|
|
|
574 * Creates the wizard's title area.
|
|
|
575 *
|
|
|
576 * @param parent
|
|
|
577 * the DWT parent for the title area composite.
|
|
|
578 * @return the created title area composite.
|
|
|
579 */
|
|
|
580 protected Composite createTitleArea(Composite parent) {
|
|
|
581 // Create the title area which will contain
|
|
|
582 // a title, message, and image.
|
|
|
583 int margins = 2;
|
|
|
584 titleArea = new Composite(parent, DWT.NONE);
|
|
|
585 FormLayout layout = new FormLayout();
|
|
|
586 layout.marginHeight = 0;
|
|
|
587 layout.marginWidth = margins;
|
|
|
588 titleArea.setLayout(layout);
|
|
|
589
|
|
|
590
|
|
|
591 GridData layoutData = new GridData(GridData.FILL_HORIZONTAL);
|
|
|
592 layoutData.verticalAlignment = DWT.TOP;
|
|
|
593 titleArea.setLayoutData(layoutData);
|
|
|
594
|
|
|
595 // Message label
|
|
|
596 messageArea = new DialogMessageArea();
|
|
|
597 messageArea.createContents(titleArea);
|
|
|
598
|
|
|
599 titleArea.addControlListener(new ControlAdapter() {
|
|
|
600 /* (non-Javadoc)
|
|
|
601 * @see dwt.events.ControlAdapter#controlResized(dwt.events.ControlEvent)
|
|
|
602 */
|
|
|
603 public void controlResized(ControlEvent e) {
|
|
|
604 updateMessage();
|
|
|
605 }
|
|
|
606 });
|
|
|
607
|
|
|
608 final IPropertyChangeListener fontListener = new IPropertyChangeListener() {
|
|
|
609 public void propertyChange(PropertyChangeEvent event) {
|
|
|
610 if (JFaceResources.BANNER_FONT.equals(event.getProperty())) {
|
|
|
611 updateMessage();
|
|
|
612 }
|
|
|
613 if (JFaceResources.DIALOG_FONT.equals(event.getProperty())) {
|
|
|
614 updateMessage();
|
|
|
615 Font dialogFont = JFaceResources.getDialogFont();
|
|
|
616 updateTreeFont(dialogFont);
|
|
|
617 Control[] children = ((Composite) buttonBar).getChildren();
|
|
|
618 for (int i = 0; i < children.length; i++) {
|
|
|
619 children[i].setFont(dialogFont);
|
|
|
620 }
|
|
|
621 }
|
|
|
622 }
|
|
|
623 };
|
|
|
624
|
|
|
625 titleArea.addDisposeListener(new DisposeListener() {
|
|
|
626 public void widgetDisposed(DisposeEvent event) {
|
|
|
627 JFaceResources.getFontRegistry().removeListener(fontListener);
|
|
|
628 }
|
|
|
629 });
|
|
|
630 JFaceResources.getFontRegistry().addListener(fontListener);
|
|
|
631 messageArea.setTitleLayoutData(createMessageAreaData());
|
|
|
632 messageArea.setMessageLayoutData(createMessageAreaData());
|
|
|
633 return titleArea;
|
|
|
634 }
|
|
|
635
|
|
|
636 /**
|
|
|
637 * Create the layout data for the message area.
|
|
|
638 *
|
|
|
639 * @return FormData for the message area.
|
|
|
640 */
|
|
|
641 private FormData createMessageAreaData() {
|
|
|
642 FormData messageData = new FormData();
|
|
|
643 messageData.top = new FormAttachment(0);
|
|
|
644 messageData.bottom = new FormAttachment(100);
|
|
|
645 messageData.right = new FormAttachment(100);
|
|
|
646 messageData.left = new FormAttachment(0);
|
|
|
647 return messageData;
|
|
|
648 }
|
|
|
649
|
|
|
650 /**
|
|
|
651 * @param parent
|
|
|
652 * the DWT parent for the tree area controls.
|
|
|
653 * @return the new <code>Control</code>.
|
|
|
654 * @since 3.0
|
|
|
655 */
|
|
|
656 protected Control createTreeAreaContents(Composite parent) {
|
|
|
657 // Build the tree an put it into the composite.
|
|
|
658 treeViewer = createTreeViewer(parent);
|
|
|
659 treeViewer.setInput(getPreferenceManager());
|
|
|
660 updateTreeFont(JFaceResources.getDialogFont());
|
|
|
661 layoutTreeAreaControl(treeViewer.getControl());
|
|
|
662 return treeViewer.getControl();
|
|
|
663 }
|
|
|
664
|
|
|
665 /**
|
|
|
666 * Create a new <code>TreeViewer</code>.
|
|
|
667 *
|
|
|
668 * @param parent
|
|
|
669 * the parent <code>Composite</code>.
|
|
|
670 * @return the <code>TreeViewer</code>.
|
|
|
671 * @since 3.0
|
|
|
672 */
|
|
|
673 protected TreeViewer createTreeViewer(Composite parent) {
|
|
|
674 final TreeViewer viewer = new TreeViewer(parent, DWT.NONE);
|
|
|
675 addListeners(viewer);
|
|
|
676 viewer.setLabelProvider(new PreferenceLabelProvider());
|
|
|
677 viewer.setContentProvider(new PreferenceContentProvider());
|
|
|
678 return viewer;
|
|
|
679 }
|
|
|
680
|
|
|
681 /**
|
|
|
682 * Add the listeners to the tree viewer.
|
|
|
683 * @param viewer
|
|
|
684 *
|
|
|
685 * @since 3.1
|
|
|
686 */
|
|
|
687 protected void addListeners(final TreeViewer viewer) {
|
|
|
688 viewer.addPostSelectionChangedListener(new ISelectionChangedListener() {
|
|
|
689 private void handleError() {
|
|
|
690 try {
|
|
|
691 // remove the listener temporarily so that the events caused
|
|
|
692 // by the error handling dont further cause error handling
|
|
|
693 // to occur.
|
|
|
694 viewer.removePostSelectionChangedListener(this);
|
|
|
695 showPageFlippingAbortDialog();
|
|
|
696 selectCurrentPageAgain();
|
|
|
697 clearSelectedNode();
|
|
|
698 } finally {
|
|
|
699 viewer.addPostSelectionChangedListener(this);
|
|
|
700 }
|
|
|
701 }
|
|
|
702
|
|
|
703 public void selectionChanged(SelectionChangedEvent event) {
|
|
|
704 Object selection = getSingleSelection(event.getSelection());
|
|
|
705 if (selection instanceof IPreferenceNode) {
|
|
|
706 if (!isCurrentPageValid()) {
|
|
|
707 handleError();
|
|
|
708 } else if (!showPage((IPreferenceNode) selection)) {
|
|
|
709 // Page flipping wasn't successful
|
|
|
710 handleError();
|
|
|
711 } else {
|
|
|
712 // Everything went well
|
|
|
713 lastSuccessfulNode = (IPreferenceNode) selection;
|
|
|
714 }
|
|
|
715 }
|
|
|
716 }
|
|
|
717 });
|
|
|
718 ((Tree) viewer.getControl()).addSelectionListener(new SelectionAdapter() {
|
|
|
719 public void widgetDefaultSelected(final SelectionEvent event) {
|
|
|
720 ISelection selection = viewer.getSelection();
|
|
|
721 if (selection.isEmpty()) {
|
|
|
722 return;
|
|
|
723 }
|
|
|
724 IPreferenceNode singleSelection = getSingleSelection(selection);
|
|
|
725 bool expanded = viewer.getExpandedState(singleSelection);
|
|
|
726 viewer.setExpandedState(singleSelection, !expanded);
|
|
|
727 }
|
|
|
728 });
|
|
|
729 //Register help listener on the tree to use context sensitive help
|
|
|
730 viewer.getControl().addHelpListener(new HelpListener() {
|
|
|
731 public void helpRequested(HelpEvent event) {
|
|
|
732 // call perform help on the current page
|
|
|
733 if (currentPage !is null) {
|
|
|
734 currentPage.performHelp();
|
|
|
735 }
|
|
|
736 }
|
|
|
737 });
|
|
|
738 }
|
|
|
739
|
|
|
740 /**
|
|
|
741 * Find the <code>IPreferenceNode</code> that has data the same id as the
|
|
|
742 * supplied value.
|
|
|
743 *
|
|
|
744 * @param nodeId
|
|
|
745 * the id to search for.
|
|
|
746 * @return <code>IPreferenceNode</code> or <code>null</code> if not
|
|
|
747 * found.
|
|
|
748 */
|
|
|
749 protected IPreferenceNode findNodeMatching(String nodeId) {
|
|
|
750 List nodes = preferenceManager.getElements(PreferenceManager.POST_ORDER);
|
|
|
751 for (Iterator i = nodes.iterator(); i.hasNext();) {
|
|
|
752 IPreferenceNode node = (IPreferenceNode) i.next();
|
|
|
753 if (node.getId().equals(nodeId)) {
|
|
|
754 return node;
|
|
|
755 }
|
|
|
756 }
|
|
|
757 return null;
|
|
|
758 }
|
|
|
759
|
|
|
760 /**
|
|
|
761 * Get the last known right side width.
|
|
|
762 *
|
|
|
763 * @return the width.
|
|
|
764 */
|
|
|
765 protected int getLastRightWidth() {
|
|
|
766 return lastTreeWidth;
|
|
|
767 }
|
|
|
768
|
|
|
769 /**
|
|
|
770 * Returns the preference mananger used by this preference dialog.
|
|
|
771 *
|
|
|
772 * @return the preference mananger
|
|
|
773 */
|
|
|
774 public PreferenceManager getPreferenceManager() {
|
|
|
775 return preferenceManager;
|
|
|
776 }
|
|
|
777
|
|
|
778 /*
|
|
|
779 * (non-Javadoc)
|
|
|
780 *
|
|
|
781 * @see dwtx.jface.preference.IPreferencePageContainer#getPreferenceStore()
|
|
|
782 */
|
|
|
783 public IPreferenceStore getPreferenceStore() {
|
|
|
784 return preferenceStore;
|
|
|
785 }
|
|
|
786
|
|
|
787 /**
|
|
|
788 * Get the name of the selected item preference
|
|
|
789 *
|
|
|
790 * @return String
|
|
|
791 */
|
|
|
792 protected String getSelectedNodePreference() {
|
|
|
793 return lastPreferenceId;
|
|
|
794 }
|
|
|
795
|
|
|
796 /**
|
|
|
797 * @param selection
|
|
|
798 * the <code>ISelection</code> to examine.
|
|
|
799 * @return the first element, or null if empty.
|
|
|
800 */
|
|
|
801 protected IPreferenceNode getSingleSelection(ISelection selection) {
|
|
|
802 if (!selection.isEmpty()) {
|
|
|
803 IStructuredSelection structured = (IStructuredSelection) selection;
|
|
|
804 if (structured.getFirstElement() instanceof IPreferenceNode) {
|
|
|
805 return (IPreferenceNode) structured.getFirstElement();
|
|
|
806 }
|
|
|
807 }
|
|
|
808 return null;
|
|
|
809 }
|
|
|
810
|
|
|
811 /**
|
|
|
812 * @return the <code>TreeViewer</code> for this dialog.
|
|
|
813 * @since 3.3
|
|
|
814 */
|
|
|
815 public TreeViewer getTreeViewer() {
|
|
|
816 return treeViewer;
|
|
|
817 }
|
|
|
818
|
|
|
819 /**
|
|
|
820 * Save the values specified in the pages.
|
|
|
821 * <p>
|
|
|
822 * The default implementation of this framework method saves all pages of
|
|
|
823 * type <code>PreferencePage</code> (if their store needs saving and is a
|
|
|
824 * <code>PreferenceStore</code>).
|
|
|
825 * </p>
|
|
|
826 * <p>
|
|
|
827 * Subclasses may override.
|
|
|
828 * </p>
|
|
|
829 */
|
|
|
830 protected void handleSave() {
|
|
|
831 Iterator nodes = preferenceManager.getElements(PreferenceManager.PRE_ORDER).iterator();
|
|
|
832 while (nodes.hasNext()) {
|
|
|
833 IPreferenceNode node = (IPreferenceNode) nodes.next();
|
|
|
834 IPreferencePage page = node.getPage();
|
|
|
835 if (page instanceof PreferencePage) {
|
|
|
836 // Save now in case tbe workbench does not shutdown cleanly
|
|
|
837 IPreferenceStore store = ((PreferencePage) page).getPreferenceStore();
|
|
|
838 if (store !is null && store.needsSaving()
|
|
|
839 && store instanceof IPersistentPreferenceStore) {
|
|
|
840 try {
|
|
|
841 ((IPersistentPreferenceStore) store).save();
|
|
|
842 } catch (IOException e) {
|
|
|
843 MessageDialog
|
|
|
844 .openError(
|
|
|
845 getShell(),
|
|
|
846 JFaceResources.getString("PreferenceDialog.saveErrorTitle"), //$NON-NLS-1$
|
|
|
847 JFaceResources
|
|
|
848 .format(
|
|
|
849 "PreferenceDialog.saveErrorMessage", new Object[] { page.getTitle(), e.getMessage() })); //$NON-NLS-1$
|
|
|
850 }
|
|
|
851 }
|
|
|
852 }
|
|
|
853 }
|
|
|
854 }
|
|
|
855
|
|
|
856 /**
|
|
|
857 * Notifies that the window's close button was pressed, the close menu was
|
|
|
858 * selected, or the ESCAPE key pressed.
|
|
|
859 * <p>
|
|
|
860 * The default implementation of this framework method sets the window's
|
|
|
861 * return code to <code>CANCEL</code> and closes the window using
|
|
|
862 * <code>close</code>. Subclasses may extend or reimplement.
|
|
|
863 * </p>
|
|
|
864 */
|
|
|
865 protected void handleShellCloseEvent() {
|
|
|
866 // handle the same as pressing cancel
|
|
|
867 cancelPressed();
|
|
|
868 }
|
|
|
869
|
|
|
870 /**
|
|
|
871 * Notifies of the pressing of the Help button.
|
|
|
872 * <p>
|
|
|
873 * The default implementation of this framework method calls
|
|
|
874 * <code>performHelp</code> on the currently active page.
|
|
|
875 * </p>
|
|
|
876 */
|
|
|
877 protected void helpPressed() {
|
|
|
878 if (currentPage !is null) {
|
|
|
879 currentPage.performHelp();
|
|
|
880 }
|
|
|
881 }
|
|
|
882
|
|
|
883 /**
|
|
|
884 * Returns whether the current page is valid.
|
|
|
885 *
|
|
|
886 * @return <code>false</code> if the current page is not valid, or or
|
|
|
887 * <code>true</code> if the current page is valid or there is no
|
|
|
888 * current page
|
|
|
889 */
|
|
|
890 protected bool isCurrentPageValid() {
|
|
|
891 if (currentPage is null) {
|
|
|
892 return true;
|
|
|
893 }
|
|
|
894 return currentPage.isValid();
|
|
|
895 }
|
|
|
896
|
|
|
897 /**
|
|
|
898 * @param control
|
|
|
899 * the <code>Control</code> to lay out.
|
|
|
900 * @since 3.0
|
|
|
901 */
|
|
|
902 protected void layoutTreeAreaControl(Control control) {
|
|
|
903 GridData gd = new GridData(GridData.FILL_VERTICAL);
|
|
|
904 gd.widthHint = getLastRightWidth();
|
|
|
905 gd.verticalSpan = 1;
|
|
|
906 control.setLayoutData(gd);
|
|
|
907 }
|
|
|
908
|
|
|
909 /**
|
|
|
910 * The preference dialog implementation of this <code>Dialog</code>
|
|
|
911 * framework method sends <code>performOk</code> to all pages of the
|
|
|
912 * preference dialog, then calls <code>handleSave</code> on this dialog to
|
|
|
913 * save any state, and then calls <code>close</code> to close this dialog.
|
|
|
914 */
|
|
|
915 protected void okPressed() {
|
|
|
916 SafeRunnable.run(new SafeRunnable() {
|
|
|
917 private bool errorOccurred;
|
|
|
918
|
|
|
919 /*
|
|
|
920 * (non-Javadoc)
|
|
|
921 *
|
|
|
922 * @see dwtx.core.runtime.ISafeRunnable#run()
|
|
|
923 */
|
|
|
924 public void run() {
|
|
|
925 getButton(IDialogConstants.OK_ID).setEnabled(false);
|
|
|
926 errorOccurred = false;
|
|
|
927 bool hasFailedOK = false;
|
|
|
928 try {
|
|
|
929 // Notify all the pages and give them a chance to abort
|
|
|
930 Iterator nodes = preferenceManager.getElements(PreferenceManager.PRE_ORDER)
|
|
|
931 .iterator();
|
|
|
932 while (nodes.hasNext()) {
|
|
|
933 IPreferenceNode node = (IPreferenceNode) nodes.next();
|
|
|
934 IPreferencePage page = node.getPage();
|
|
|
935 if (page !is null) {
|
|
|
936 if (!page.performOk()){
|
|
|
937 hasFailedOK = true;
|
|
|
938 return;
|
|
|
939 }
|
|
|
940 }
|
|
|
941 }
|
|
|
942 } catch (Exception e) {
|
|
|
943 handleException(e);
|
|
|
944 } finally {
|
|
|
945 //Don't bother closing if the OK failed
|
|
|
946 if(hasFailedOK){
|
|
|
947 setReturnCode(FAILED);
|
|
|
948 getButton(IDialogConstants.OK_ID).setEnabled(true);
|
|
|
949 return;
|
|
|
950 }
|
|
|
951
|
|
|
952 if (!errorOccurred) {
|
|
|
953 //Give subclasses the choice to save the state of the
|
|
|
954 //preference pages.
|
|
|
955 handleSave();
|
|
|
956 }
|
|
|
957 setReturnCode(OK);
|
|
|
958 close();
|
|
|
959 }
|
|
|
960 }
|
|
|
961
|
|
|
962 /*
|
|
|
963 * (non-Javadoc)
|
|
|
964 *
|
|
|
965 * @see dwtx.core.runtime.ISafeRunnable#handleException(java.lang.Throwable)
|
|
|
966 */
|
|
|
967 public void handleException(Throwable e) {
|
|
|
968 errorOccurred = true;
|
|
|
969
|
|
|
970 Policy.getLog().log(new Status(IStatus.ERROR, Policy.JFACE, 0, e.toString(), e));
|
|
|
971
|
|
|
972 clearSelectedNode();
|
|
|
973 String message = JFaceResources.getString("SafeRunnable.errorMessage"); //$NON-NLS-1$
|
|
|
974 MessageDialog.openError(getShell(), JFaceResources.getString("Error"), message); //$NON-NLS-1$
|
|
|
975
|
|
|
976 }
|
|
|
977 });
|
|
|
978 }
|
|
|
979
|
|
|
980 /**
|
|
|
981 * Selects the page determined by <code>lastSuccessfulNode</code> in the
|
|
|
982 * page hierarchy.
|
|
|
983 */
|
|
|
984 void selectCurrentPageAgain() {
|
|
|
985 if (lastSuccessfulNode is null) {
|
|
|
986 return;
|
|
|
987 }
|
|
|
988 getTreeViewer().setSelection(new StructuredSelection(lastSuccessfulNode));
|
|
|
989 currentPage.setVisible(true);
|
|
|
990 }
|
|
|
991
|
|
|
992 /**
|
|
|
993 * Selects the saved item in the tree of preference pages. If it cannot do
|
|
|
994 * this it saves the first one.
|
|
|
995 */
|
|
|
996 protected void selectSavedItem() {
|
|
|
997 IPreferenceNode node = findNodeMatching(getSelectedNodePreference());
|
|
|
998 if (node is null) {
|
|
|
999 IPreferenceNode[] nodes = preferenceManager.getRootSubNodes();
|
|
|
1000 ViewerFilter[] filters = getTreeViewer().getFilters();
|
|
|
1001 for (int i = 0; i < nodes.length; i++) {
|
|
|
1002 IPreferenceNode selectedNode = nodes[i];
|
|
|
1003 // See if it passes all filters
|
|
|
1004 for (int j = 0; j < filters.length; j++) {
|
|
|
1005 if (!filters[j].select(this.treeViewer, preferenceManager
|
|
|
1006 .getRoot(), selectedNode)) {
|
|
|
1007 selectedNode = null;
|
|
|
1008 break;
|
|
|
1009 }
|
|
|
1010 }
|
|
|
1011 // if it passes all filters select it
|
|
|
1012 if (selectedNode !is null) {
|
|
|
1013 node = selectedNode;
|
|
|
1014 break;
|
|
|
1015 }
|
|
|
1016 }
|
|
|
1017 }
|
|
|
1018 if (node !is null) {
|
|
|
1019 getTreeViewer().setSelection(new StructuredSelection(node), true);
|
|
|
1020 // Keep focus in tree. See bugs 2692, 2621, and 6775.
|
|
|
1021 getTreeViewer().getControl().setFocus();
|
|
|
1022 }
|
|
|
1023 }
|
|
|
1024
|
|
|
1025 /**
|
|
|
1026 * Display the given error message. The currently displayed message is saved
|
|
|
1027 * and will be redisplayed when the error message is set to
|
|
|
1028 * <code>null</code>.
|
|
|
1029 *
|
|
|
1030 * @param newErrorMessage
|
|
|
1031 * the errorMessage to display or <code>null</code>
|
|
|
1032 */
|
|
|
1033 public void setErrorMessage(String newErrorMessage) {
|
|
|
1034 if (newErrorMessage is null) {
|
|
|
1035 messageArea.clearErrorMessage();
|
|
|
1036 } else {
|
|
|
1037 messageArea.updateText(newErrorMessage, IMessageProvider.ERROR);
|
|
|
1038 }
|
|
|
1039 }
|
|
|
1040
|
|
|
1041 /**
|
|
|
1042 * Save the last known tree width.
|
|
|
1043 *
|
|
|
1044 * @param width
|
|
|
1045 * the width.
|
|
|
1046 */
|
|
|
1047 private void setLastTreeWidth(int width) {
|
|
|
1048 lastTreeWidth = width;
|
|
|
1049 }
|
|
|
1050
|
|
|
1051 /**
|
|
|
1052 * Set the message text. If the message line currently displays an error,
|
|
|
1053 * the message is stored and will be shown after a call to clearErrorMessage
|
|
|
1054 * <p>
|
|
|
1055 * Shortcut for <code>setMessage(newMessage, NONE)</code>
|
|
|
1056 * </p>
|
|
|
1057 *
|
|
|
1058 * @param newMessage
|
|
|
1059 * the message, or <code>null</code> to clear the message
|
|
|
1060 */
|
|
|
1061 public void setMessage(String newMessage) {
|
|
|
1062 setMessage(newMessage, IMessageProvider.NONE);
|
|
|
1063 }
|
|
|
1064
|
|
|
1065 /**
|
|
|
1066 * Sets the message for this dialog with an indication of what type of
|
|
|
1067 * message it is.
|
|
|
1068 * <p>
|
|
|
1069 * The valid message types are one of <code>NONE</code>,
|
|
|
1070 * <code>INFORMATION</code>,<code>WARNING</code>, or
|
|
|
1071 * <code>ERROR</code>.
|
|
|
1072 * </p>
|
|
|
1073 * <p>
|
|
|
1074 * Note that for backward compatibility, a message of type
|
|
|
1075 * <code>ERROR</code> is different than an error message (set using
|
|
|
1076 * <code>setErrorMessage</code>). An error message overrides the current
|
|
|
1077 * message until the error message is cleared. This method replaces the
|
|
|
1078 * current message and does not affect the error message.
|
|
|
1079 * </p>
|
|
|
1080 *
|
|
|
1081 * @param newMessage
|
|
|
1082 * the message, or <code>null</code> to clear the message
|
|
|
1083 * @param newType
|
|
|
1084 * the message type
|
|
|
1085 * @since 2.0
|
|
|
1086 */
|
|
|
1087 public void setMessage(String newMessage, int newType) {
|
|
|
1088 messageArea.updateText(newMessage, newType);
|
|
|
1089 }
|
|
|
1090
|
|
|
1091 /**
|
|
|
1092 * Sets the minimum page size.
|
|
|
1093 *
|
|
|
1094 * @param minWidth
|
|
|
1095 * the minimum page width
|
|
|
1096 * @param minHeight
|
|
|
1097 * the minimum page height
|
|
|
1098 * @see #setMinimumPageSize(Point)
|
|
|
1099 */
|
|
|
1100 public void setMinimumPageSize(int minWidth, int minHeight) {
|
|
|
1101 minimumPageSize.x = minWidth;
|
|
|
1102 minimumPageSize.y = minHeight;
|
|
|
1103 }
|
|
|
1104
|
|
|
1105 /**
|
|
|
1106 * Sets the minimum page size.
|
|
|
1107 *
|
|
|
1108 * @param size
|
|
|
1109 * the page size encoded as <code>new Point(width,height)</code>
|
|
|
1110 * @see #setMinimumPageSize(int,int)
|
|
|
1111 */
|
|
|
1112 public void setMinimumPageSize(Point size) {
|
|
|
1113 minimumPageSize.x = size.x;
|
|
|
1114 minimumPageSize.y = size.y;
|
|
|
1115 }
|
|
|
1116
|
|
|
1117 /**
|
|
|
1118 * Sets the preference store for this preference dialog.
|
|
|
1119 *
|
|
|
1120 * @param store
|
|
|
1121 * the preference store
|
|
|
1122 * @see #getPreferenceStore
|
|
|
1123 */
|
|
|
1124 public void setPreferenceStore(IPreferenceStore store) {
|
|
|
1125 Assert.isNotNull(store);
|
|
|
1126 preferenceStore = store;
|
|
|
1127 }
|
|
|
1128
|
|
|
1129 /**
|
|
|
1130 * Save the currently selected node.
|
|
|
1131 */
|
|
|
1132 private void setSelectedNode() {
|
|
|
1133 String storeValue = null;
|
|
|
1134 IStructuredSelection selection = (IStructuredSelection) getTreeViewer().getSelection();
|
|
|
1135 if (selection.size() is 1) {
|
|
|
1136 IPreferenceNode node = (IPreferenceNode) selection.getFirstElement();
|
|
|
1137 storeValue = node.getId();
|
|
|
1138 }
|
|
|
1139 setSelectedNodePreference(storeValue);
|
|
|
1140 }
|
|
|
1141
|
|
|
1142 /**
|
|
|
1143 * Sets the name of the selected item preference. Public equivalent to
|
|
|
1144 * <code>setSelectedNodePreference</code>.
|
|
|
1145 *
|
|
|
1146 * @param pageId
|
|
|
1147 * The identifier for the page
|
|
|
1148 * @since 3.0
|
|
|
1149 */
|
|
|
1150 public void setSelectedNode(String pageId) {
|
|
|
1151 setSelectedNodePreference(pageId);
|
|
|
1152 }
|
|
|
1153
|
|
|
1154 /**
|
|
|
1155 * Sets the name of the selected item preference.
|
|
|
1156 *
|
|
|
1157 * @param pageId
|
|
|
1158 * The identifier for the page
|
|
|
1159 */
|
|
|
1160 protected void setSelectedNodePreference(String pageId) {
|
|
|
1161 lastPreferenceId = pageId;
|
|
|
1162 }
|
|
|
1163
|
|
|
1164 /**
|
|
|
1165 * Changes the shell size to the given size, ensuring that it is no larger
|
|
|
1166 * than the display bounds.
|
|
|
1167 *
|
|
|
1168 * @param width
|
|
|
1169 * the shell width
|
|
|
1170 * @param height
|
|
|
1171 * the shell height
|
|
|
1172 */
|
|
|
1173 private void setShellSize(int width, int height) {
|
|
|
1174 Rectangle preferred = getShell().getBounds();
|
|
|
1175 preferred.width = width;
|
|
|
1176 preferred.height = height;
|
|
|
1177 getShell().setBounds(getConstrainedShellBounds(preferred));
|
|
|
1178 }
|
|
|
1179
|
|
|
1180 /**
|
|
|
1181 * Shows the preference page corresponding to the given preference node.
|
|
|
1182 * Does nothing if that page is already current.
|
|
|
1183 *
|
|
|
1184 * @param node
|
|
|
1185 * the preference node, or <code>null</code> if none
|
|
|
1186 * @return <code>true</code> if the page flip was successful, and
|
|
|
1187 * <code>false</code> is unsuccessful
|
|
|
1188 */
|
|
|
1189 protected bool showPage(IPreferenceNode node) {
|
|
|
1190 if (node is null) {
|
|
|
1191 return false;
|
|
|
1192 }
|
|
|
1193 // Create the page if nessessary
|
|
|
1194 if (node.getPage() is null) {
|
|
|
1195 createPage(node);
|
|
|
1196 }
|
|
|
1197 if (node.getPage() is null) {
|
|
|
1198 return false;
|
|
|
1199 }
|
|
|
1200 IPreferencePage newPage = getPage(node);
|
|
|
1201 if (newPage is currentPage) {
|
|
|
1202 return true;
|
|
|
1203 }
|
|
|
1204 if (currentPage !is null) {
|
|
|
1205 if (!currentPage.okToLeave()) {
|
|
|
1206 return false;
|
|
|
1207 }
|
|
|
1208 }
|
|
|
1209 IPreferencePage oldPage = currentPage;
|
|
|
1210 currentPage = newPage;
|
|
|
1211 // Set the new page's container
|
|
|
1212 currentPage.setContainer(this);
|
|
|
1213 // Ensure that the page control has been created
|
|
|
1214 // (this allows lazy page control creation)
|
|
|
1215 if (currentPage.getControl() is null) {
|
|
|
1216 final bool[] failed = { false };
|
|
|
1217 SafeRunnable.run(new ISafeRunnable() {
|
|
|
1218 public void handleException(Throwable e) {
|
|
|
1219 failed[0] = true;
|
|
|
1220 }
|
|
|
1221
|
|
|
1222 public void run() {
|
|
|
1223 createPageControl(currentPage, pageContainer);
|
|
|
1224 }
|
|
|
1225 });
|
|
|
1226 if (failed[0]) {
|
|
|
1227 return false;
|
|
|
1228 }
|
|
|
1229 // the page is responsible for ensuring the created control is
|
|
|
1230 // accessable
|
|
|
1231 // via getControl.
|
|
|
1232 Assert.isNotNull(currentPage.getControl());
|
|
|
1233 }
|
|
|
1234 // Force calculation of the page's description label because
|
|
|
1235 // label can be wrapped.
|
|
|
1236 final Point[] size = new Point[1];
|
|
|
1237 final Point failed = new Point(-1, -1);
|
|
|
1238 SafeRunnable.run(new ISafeRunnable() {
|
|
|
1239 public void handleException(Throwable e) {
|
|
|
1240 size[0] = failed;
|
|
|
1241 }
|
|
|
1242
|
|
|
1243 public void run() {
|
|
|
1244 size[0] = currentPage.computeSize();
|
|
|
1245 }
|
|
|
1246 });
|
|
|
1247 if (size[0].equals(failed)) {
|
|
|
1248 return false;
|
|
|
1249 }
|
|
|
1250 Point contentSize = size[0];
|
|
|
1251 // Do we need resizing. Computation not needed if the
|
|
|
1252 // first page is inserted since computing the dialog's
|
|
|
1253 // size is done by calling dialog.open().
|
|
|
1254 // Also prevent auto resize if the user has manually resized
|
|
|
1255 Shell shell = getShell();
|
|
|
1256 Point shellSize = shell.getSize();
|
|
|
1257 if (oldPage !is null) {
|
|
|
1258 Rectangle rect = pageContainer.getClientArea();
|
|
|
1259 Point containerSize = new Point(rect.width, rect.height);
|
|
|
1260 int hdiff = contentSize.x - containerSize.x;
|
|
|
1261 int vdiff = contentSize.y - containerSize.y;
|
|
|
1262 if ((hdiff > 0 || vdiff > 0) && shellSize.equals(lastShellSize)) {
|
|
|
1263 hdiff = Math.max(0, hdiff);
|
|
|
1264 vdiff = Math.max(0, vdiff);
|
|
|
1265 setShellSize(shellSize.x + hdiff, shellSize.y + vdiff);
|
|
|
1266 lastShellSize = shell.getSize();
|
|
|
1267 if (currentPage.getControl().getSize().x is 0) {
|
|
|
1268 currentPage.getControl().setSize(containerSize);
|
|
|
1269 }
|
|
|
1270
|
|
|
1271 } else {
|
|
|
1272 currentPage.setSize(containerSize);
|
|
|
1273 }
|
|
|
1274 }
|
|
|
1275
|
|
|
1276 scrolled.setMinSize(contentSize);
|
|
|
1277 // Ensure that all other pages are invisible
|
|
|
1278 // (including ones that triggered an exception during
|
|
|
1279 // their creation).
|
|
|
1280 Control[] children = pageContainer.getChildren();
|
|
|
1281 Control currentControl = currentPage.getControl();
|
|
|
1282 for (int i = 0; i < children.length; i++) {
|
|
|
1283 if (children[i] !is currentControl) {
|
|
|
1284 children[i].setVisible(false);
|
|
|
1285 }
|
|
|
1286 }
|
|
|
1287 // Make the new page visible
|
|
|
1288 currentPage.setVisible(true);
|
|
|
1289 if (oldPage !is null) {
|
|
|
1290 oldPage.setVisible(false);
|
|
|
1291 }
|
|
|
1292 // update the dialog controls
|
|
|
1293 update();
|
|
|
1294 return true;
|
|
|
1295 }
|
|
|
1296
|
|
|
1297 /**
|
|
|
1298 * Create the page for the node.
|
|
|
1299 * @param node
|
|
|
1300 *
|
|
|
1301 * @since 3.1
|
|
|
1302 */
|
|
|
1303 protected void createPage(IPreferenceNode node) {
|
|
|
1304 node.createPage();
|
|
|
1305 }
|
|
|
1306
|
|
|
1307 /**
|
|
|
1308 * Get the page for the node.
|
|
|
1309 * @param node
|
|
|
1310 * @return IPreferencePage
|
|
|
1311 *
|
|
|
1312 * @since 3.1
|
|
|
1313 */
|
|
|
1314 protected IPreferencePage getPage(IPreferenceNode node) {
|
|
|
1315 return node.getPage();
|
|
|
1316 }
|
|
|
1317
|
|
|
1318 /**
|
|
|
1319 * Shows the "Page Flipping abort" dialog.
|
|
|
1320 */
|
|
|
1321 void showPageFlippingAbortDialog() {
|
|
|
1322 MessageDialog.openError(getShell(), JFaceResources
|
|
|
1323 .getString("AbortPageFlippingDialog.title"), //$NON-NLS-1$
|
|
|
1324 JFaceResources.getString("AbortPageFlippingDialog.message")); //$NON-NLS-1$
|
|
|
1325 }
|
|
|
1326
|
|
|
1327 /**
|
|
|
1328 * Updates this dialog's controls to reflect the current page.
|
|
|
1329 */
|
|
|
1330 protected void update() {
|
|
|
1331 // Update the title bar
|
|
|
1332 updateTitle();
|
|
|
1333 // Update the message line
|
|
|
1334 updateMessage();
|
|
|
1335 // Update the buttons
|
|
|
1336 updateButtons();
|
|
|
1337 //Saved the selected node in the preferences
|
|
|
1338 setSelectedNode();
|
|
|
1339 firePageChanged(new PageChangedEvent(this, getCurrentPage()));
|
|
|
1340 }
|
|
|
1341
|
|
|
1342 /*
|
|
|
1343 * (non-Javadoc)
|
|
|
1344 *
|
|
|
1345 * @see dwtx.jface.preference.IPreferencePageContainer#updateButtons()
|
|
|
1346 */
|
|
|
1347 public void updateButtons() {
|
|
|
1348 okButton.setEnabled(isCurrentPageValid());
|
|
|
1349 }
|
|
|
1350
|
|
|
1351 /*
|
|
|
1352 * (non-Javadoc)
|
|
|
1353 *
|
|
|
1354 * @see dwtx.jface.preference.IPreferencePageContainer#updateMessage()
|
|
|
1355 */
|
|
|
1356 public void updateMessage() {
|
|
|
1357 String message = null;
|
|
|
1358 String errorMessage = null;
|
|
|
1359 if(currentPage !is null){
|
|
|
1360 message = currentPage.getMessage();
|
|
|
1361 errorMessage = currentPage.getErrorMessage();
|
|
|
1362 }
|
|
|
1363 int messageType = IMessageProvider.NONE;
|
|
|
1364 if (message !is null && currentPage instanceof IMessageProvider) {
|
|
|
1365 messageType = ((IMessageProvider) currentPage).getMessageType();
|
|
|
1366 }
|
|
|
1367
|
|
|
1368 if (errorMessage is null){
|
|
|
1369 if (showingError) {
|
|
|
1370 // we were previously showing an error
|
|
|
1371 showingError = false;
|
|
|
1372 }
|
|
|
1373 }
|
|
|
1374 else {
|
|
|
1375 message = errorMessage;
|
|
|
1376 messageType = IMessageProvider.ERROR;
|
|
|
1377 if (!showingError) {
|
|
|
1378 // we were not previously showing an error
|
|
|
1379 showingError = true;
|
|
|
1380 }
|
|
|
1381 }
|
|
|
1382 messageArea.updateText(message,messageType);
|
|
|
1383 }
|
|
|
1384
|
|
|
1385 /*
|
|
|
1386 * (non-Javadoc)
|
|
|
1387 *
|
|
|
1388 * @see dwtx.jface.preference.IPreferencePageContainer#updateTitle()
|
|
|
1389 */
|
|
|
1390 public void updateTitle() {
|
|
|
1391 if(currentPage is null) {
|
|
|
1392 return;
|
|
|
1393 }
|
|
|
1394 messageArea.showTitle(currentPage.getTitle(), currentPage.getImage());
|
|
|
1395 }
|
|
|
1396
|
|
|
1397 /**
|
|
|
1398 * Update the tree to use the specified <code>Font</code>.
|
|
|
1399 *
|
|
|
1400 * @param dialogFont
|
|
|
1401 * the <code>Font</code> to use.
|
|
|
1402 * @since 3.0
|
|
|
1403 */
|
|
|
1404 protected void updateTreeFont(Font dialogFont) {
|
|
|
1405 getTreeViewer().getControl().setFont(dialogFont);
|
|
|
1406 }
|
|
|
1407
|
|
|
1408 /**
|
|
|
1409 * Returns the currentPage.
|
|
|
1410 * @return IPreferencePage
|
|
|
1411 * @since 3.1
|
|
|
1412 */
|
|
|
1413 protected IPreferencePage getCurrentPage() {
|
|
|
1414 return currentPage;
|
|
|
1415 }
|
|
|
1416
|
|
|
1417 /**
|
|
|
1418 * Sets the current page.
|
|
|
1419 * @param currentPage
|
|
|
1420 *
|
|
|
1421 * @since 3.1
|
|
|
1422 */
|
|
|
1423 protected void setCurrentPage(IPreferencePage currentPage) {
|
|
|
1424 this.currentPage = currentPage;
|
|
|
1425 }
|
|
|
1426
|
|
|
1427 /**
|
|
|
1428 * Set the treeViewer.
|
|
|
1429 * @param treeViewer
|
|
|
1430 *
|
|
|
1431 * @since 3.1
|
|
|
1432 */
|
|
|
1433 protected void setTreeViewer(TreeViewer treeViewer) {
|
|
|
1434 this.treeViewer = treeViewer;
|
|
|
1435 }
|
|
|
1436
|
|
|
1437 /**
|
|
|
1438 * Get the composite that is showing the page.
|
|
|
1439 *
|
|
|
1440 * @return Composite.
|
|
|
1441 *
|
|
|
1442 * @since 3.1
|
|
|
1443 */
|
|
|
1444 protected Composite getPageContainer() {
|
|
|
1445 return this.pageContainer;
|
|
|
1446 }
|
|
|
1447
|
|
|
1448 /**
|
|
|
1449 * Set the composite that is showing the page.
|
|
|
1450 * @param pageContainer Composite
|
|
|
1451 *
|
|
|
1452 * @since 3.1
|
|
|
1453 */
|
|
|
1454 protected void setPageContainer(Composite pageContainer) {
|
|
|
1455 this.pageContainer = pageContainer;
|
|
|
1456 }
|
|
|
1457 /**
|
|
|
1458 * Create the page control for the supplied page.
|
|
|
1459 *
|
|
|
1460 * @param page - the preference page to be shown
|
|
|
1461 * @param parent - the composite to parent the page
|
|
|
1462 *
|
|
|
1463 * @since 3.1
|
|
|
1464 */
|
|
|
1465 protected void createPageControl(IPreferencePage page, Composite parent) {
|
|
|
1466 page.createControl(parent);
|
|
|
1467 }
|
|
|
1468
|
|
|
1469 /**
|
|
|
1470 * @see dwtx.jface.dialogs.IPageChangeProvider#getSelectedPage()
|
|
|
1471 *
|
|
|
1472 * @since 3.1
|
|
|
1473 */
|
|
|
1474 public Object getSelectedPage() {
|
|
|
1475 return getCurrentPage();
|
|
|
1476 }
|
|
|
1477
|
|
|
1478 /**
|
|
|
1479 * @see dwtx.jface.dialogs.IPageChangeProvider#addPageChangedListener(dwtx.jface.dialogs.IPageChangedListener)
|
|
|
1480 * @since 3.1
|
|
|
1481 */
|
|
|
1482 public void addPageChangedListener(IPageChangedListener listener) {
|
|
|
1483 pageChangedListeners.add(listener);
|
|
|
1484 }
|
|
|
1485
|
|
|
1486 /**
|
|
|
1487 * @see dwtx.jface.dialogs.IPageChangeProvider#removePageChangedListener(dwtx.jface.dialogs.IPageChangedListener)
|
|
|
1488 * @since 3.1
|
|
|
1489 */
|
|
|
1490 public void removePageChangedListener(IPageChangedListener listener) {
|
|
|
1491 pageChangedListeners.remove(listener);
|
|
|
1492
|
|
|
1493 }
|
|
|
1494
|
|
|
1495 /**
|
|
|
1496 * Notifies any selection changed listeners that the selected page
|
|
|
1497 * has changed.
|
|
|
1498 * Only listeners registered at the time this method is called are notified.
|
|
|
1499 *
|
|
|
1500 * @param event a selection changed event
|
|
|
1501 *
|
|
|
1502 * @see IPageChangedListener#pageChanged
|
|
|
1503 *
|
|
|
1504 * @since 3.1
|
|
|
1505 */
|
|
|
1506 protected void firePageChanged(final PageChangedEvent event) {
|
|
|
1507 Object[] listeners = pageChangedListeners.getListeners();
|
|
|
1508 for (int i = 0; i < listeners.length; i++) {
|
|
|
1509 final IPageChangedListener l = (IPageChangedListener) listeners[i];
|
|
|
1510 SafeRunnable.run(new SafeRunnable() {
|
|
|
1511 public void run() {
|
|
|
1512 l.pageChanged(event);
|
|
|
1513 }
|
|
|
1514 });
|
|
|
1515 }
|
|
|
1516 }
|
|
|
1517 }
|
|
|
1518 ++/ |
