Mercurial > projects > dwt-addons

comparison dwtx/jface/text/AbstractInformationControl.d @ 129:eb30df5ca28b

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added JFace Text sources
author Frank Benoit <benoit@tionex.de>
date Sat, 23 Aug 2008 19:10:48 +0200
parents
children c4fb132a086c
comparison
equal deleted inserted replaced
128:8df1d4193877 129:eb30df5ca28b
1 /*******************************************************************************
2 * Copyright (c) 2008 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.text.AbstractInformationControl;
14
15 import dwt.dwthelper.utils;
16
17
18
19
20 import dwt.DWT;
21 import dwt.events.DisposeListener;
22 import dwt.events.FocusEvent;
23 import dwt.events.FocusListener;
24 import dwt.events.MouseAdapter;
25 import dwt.events.MouseEvent;
26 import dwt.events.MouseMoveListener;
27 import dwt.events.PaintEvent;
28 import dwt.events.PaintListener;
29 import dwt.graphics.Color;
30 import dwt.graphics.Cursor;
31 import dwt.graphics.Font;
32 import dwt.graphics.FontData;
33 import dwt.graphics.GC;
34 import dwt.graphics.Point;
35 import dwt.graphics.Rectangle;
36 import dwt.layout.FillLayout;
37 import dwt.layout.GridData;
38 import dwt.layout.GridLayout;
39 import dwt.widgets.Canvas;
40 import dwt.widgets.Composite;
41 import dwt.widgets.Control;
42 import dwt.widgets.Display;
43 import dwt.widgets.Event;
44 import dwt.widgets.Label;
45 import dwt.widgets.Listener;
46 import dwt.widgets.Shell;
47 import dwt.widgets.Slider;
48 import dwt.widgets.ToolBar;
49 import dwtx.core.runtime.Assert;
50 import dwtx.core.runtime.ListenerList;
51 import dwtx.jface.action.ToolBarManager;
52 import dwtx.jface.resource.JFaceResources;
53 import dwtx.jface.util.Geometry;
54
55
56 /**
57 * An abstract information control that can show content inside a shell.
58 * The information control can be created in two styles:
59 * <ul>
60 * <li>non-resizable tooltip with optional status</li>
61 * <li>resizable tooltip with optional tool bar</li>
62 * </ul>
63 * Additionally it can present either a status line containing a status text or
64 * a toolbar containing toolbar buttons.
65 * <p>
66 * Subclasses must either override {@link IInformationControl#setInformation(String)}
67 * or implement {@link IInformationControlExtension2}.
68 * They should also extend {@link #computeTrim()} if they create a content area
69 * with additional trim (e.g. scrollbars) and override {@link #getInformationPresenterControlCreator()}.
70 * </p>
71 *
72 * @since 3.4
73 */
74 public abstract class AbstractInformationControl : IInformationControl, IInformationControlExtension, IInformationControlExtension3, IInformationControlExtension4, IInformationControlExtension5 {
75
76 /** The information control's shell. */
77 private final Shell fShell;
78 /** Composite containing the content created by subclasses. */
79 private final Composite fContentComposite;
80 /** Whether the information control is resizable. */
81 private final bool fResizable;
82
83 /** Composite containing the status line content or <code>null</code> if none. */
84 private Composite fStatusComposite;
85 /** Separator between content and status line or <code>null</code> if none. */
86 private Label fSeparator;
87 /** Label in the status line or <code>null</code> if none. */
88 private Label fStatusLabel;
89 /** The toolbar manager used by the toolbar or <code>null</code> if none. */
90 private final ToolBarManager fToolBarManager;
91 /** Status line toolbar or <code>null</code> if none. */
92 private ToolBar fToolBar;
93
94 /** Listener for shell activation and deactivation. */
95 private Listener fShellListener;
96 /** All focus listeners registered to this information control. */
97 private ListenerList fFocusListeners= new ListenerList(ListenerList.IDENTITY);
98
99 /** Size constraints, x is the maxWidth and y is the maxHeight, or <code>null</code> if not set. */
100 private Point fSizeConstraints;
101 /** The size of the resize handle if already set, -1 otherwise */
102 private int fResizeHandleSize;
103
104 /**
105 * Creates an abstract information control with the given shell as parent.
106 * The control will not be resizable and optionally show a status line with
107 * the given status field text.
108 * <p>
109 * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em>
110 * </p>
111 *
112 * @param parentShell the parent of this control's shell
113 * @param statusFieldText the text to be used in the status field or <code>null</code> to hide the status field
114 */
115 public AbstractInformationControl(Shell parentShell, String statusFieldText) {
116 this(parentShell, DWT.TOOL | DWT.ON_TOP, statusFieldText, null);
117 }
118
119 /**
120 * Creates an abstract information control with the given shell as parent.
121 * The control will be resizable and optionally show a tool bar managed by
122 * the given tool bar manager.
123 * <p>
124 * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em>
125 * </p>
126 *
127 * @param parentShell the parent of this control's shell
128 * @param toolBarManager the manager or <code>null</code> if toolbar is not desired
129 */
130 public AbstractInformationControl(Shell parentShell, ToolBarManager toolBarManager) {
131 this(parentShell, DWT.TOOL | DWT.ON_TOP | DWT.RESIZE, null, toolBarManager);
132 }
133
134 /**
135 * Creates an abstract information control with the given shell as parent.
136 * <p>
137 * <em>Important: Subclasses are required to call {@link #create()} at the end of their constructor.</em>
138 * </p>
139 *
140 * @param parentShell the parent of this control's shell
141 * @param isResizable <code>true</code> if the control should be resizable
142 */
143 public AbstractInformationControl(Shell parentShell, bool isResizable) {
144 this(parentShell, DWT.TOOL | DWT.ON_TOP | (isResizable ? DWT.RESIZE : 0), null, null);
145 }
146
147 /**
148 * Creates an abstract information control with the given shell as parent.
149 * The given shell style is used for the shell (NO_TRIM will be removed to make sure there's a border).
150 * <p>
151 * The control will optionally show either a status line or a tool bar.
152 * At most one of <code>toolBarManager</code> or <code>statusFieldText</code> can be non-null.
153 * </p>
154 * <p>
155 * <strong>Important:</strong>: Subclasses are required to call {@link #create()} at the end of their constructor.
156 * </p>
157 *
158 * @param parentShell the parent of this control's shell
159 * @param shellStyle style of this control's shell
160 * @param statusFieldText the text to be used in the status field or <code>null</code> to hide the status field
161 * @param toolBarManager the manager or <code>null</code> if toolbar is not desired
162 *
163 * @deprecated clients should use one of the public constructors
164 */
165 AbstractInformationControl(Shell parentShell, int shellStyle, final String statusFieldText, final ToolBarManager toolBarManager) {
166 Assert.isTrue(statusFieldText is null || toolBarManager is null);
167 fResizeHandleSize= -1;
168 fToolBarManager= toolBarManager;
169
170 if ((shellStyle & DWT.NO_TRIM) !is 0)
171 shellStyle&= ~(DWT.NO_TRIM | DWT.SHELL_TRIM); // make sure we get the OS border but no other trims
172
173 fResizable= (shellStyle & DWT.RESIZE) !is 0; // on GTK, Shell removes DWT.RESIZE if DWT.ON_TOP is set
174 fShell= new Shell(parentShell, shellStyle);
175 Display display= fShell.getDisplay();
176 Color foreground= display.getSystemColor(DWT.COLOR_INFO_FOREGROUND);
177 Color background= display.getSystemColor(DWT.COLOR_INFO_BACKGROUND);
178 setColor(fShell, foreground, background);
179
180 GridLayout layout= new GridLayout(1, false);
181 layout.marginHeight= 0;
182 layout.marginWidth= 0;
183 layout.verticalSpacing= 0;
184 fShell.setLayout(layout);
185
186 fContentComposite= new Composite(fShell, DWT.NONE);
187 fContentComposite.setLayoutData(new GridData(DWT.FILL, DWT.FILL, true, true));
188 fContentComposite.setLayout(new FillLayout());
189 setColor(fContentComposite, foreground, background);
190
191 createStatusComposite(statusFieldText, toolBarManager, foreground, background);
192 }
193
194 private void createStatusComposite(final String statusFieldText, final ToolBarManager toolBarManager, Color foreground, Color background) {
195 if (toolBarManager is null && statusFieldText is null)
196 return;
197
198 fStatusComposite= new Composite(fShell, DWT.NONE);
199 GridData gridData= new GridData(DWT.FILL, DWT.BOTTOM, true, false);
200 fStatusComposite.setLayoutData(gridData);
201 GridLayout statusLayout= new GridLayout(1, false);
202 statusLayout.marginHeight= 0;
203 statusLayout.marginWidth= 0;
204 statusLayout.verticalSpacing= 1;
205 fStatusComposite.setLayout(statusLayout);
206
207 fSeparator= new Label(fStatusComposite, DWT.SEPARATOR | DWT.HORIZONTAL);
208 fSeparator.setLayoutData(new GridData(GridData.FILL_HORIZONTAL));
209
210 if (statusFieldText !is null) {
211 createStatusLabel(statusFieldText, foreground, background);
212 } else {
213 createToolBar(toolBarManager);
214 }
215 }
216
217 private void createStatusLabel(final String statusFieldText, Color foreground, Color background) {
218 fStatusLabel= new Label(fStatusComposite, DWT.RIGHT);
219 fStatusLabel.setLayoutData(new GridData(DWT.FILL, DWT.CENTER, true, false));
220 fStatusLabel.setText(statusFieldText);
221
222 FontData[] fontDatas= JFaceResources.getDialogFont().getFontData();
223 for (int i= 0; i < fontDatas.length; i++) {
224 fontDatas[i].setHeight(fontDatas[i].getHeight() * 9 / 10);
225 }
226 fStatusLabel.setFont(new Font(fStatusLabel.getDisplay(), fontDatas));
227
228 fStatusLabel.setForeground(fStatusLabel.getDisplay().getSystemColor(DWT.COLOR_WIDGET_DARK_SHADOW));
229 fStatusLabel.setBackground(background);
230 setColor(fStatusComposite, foreground, background);
231 }
232
233 private void createToolBar(ToolBarManager toolBarManager) {
234 final Composite bars= new Composite(fStatusComposite, DWT.NONE);
235 bars.setLayoutData(new GridData(DWT.FILL, DWT.FILL, false, false));
236
237 GridLayout layout= new GridLayout(3, false);
238 layout.marginHeight= 0;
239 layout.marginWidth= 0;
240 layout.horizontalSpacing= 0;
241 layout.verticalSpacing= 0;
242 bars.setLayout(layout);
243
244 fToolBar= toolBarManager.createControl(bars);
245 GridData gd= new GridData(DWT.BEGINNING, DWT.BEGINNING, false, false);
246 fToolBar.setLayoutData(gd);
247
248 Composite spacer= new Composite(bars, DWT.NONE);
249 gd= new GridData(DWT.FILL, DWT.FILL, true, true);
250 gd.widthHint= 0;
251 gd.heightHint= 0;
252 spacer.setLayoutData(gd);
253
254 addMoveSupport(spacer);
255 addResizeSupportIfNecessary(bars);
256 }
257
258 private void addResizeSupportIfNecessary(final Composite bars) {
259 // XXX: workarounds for
260 // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=219139 : API to add resize grip / grow box in lower right corner of shell
261 // - https://bugs.eclipse.org/bugs/show_bug.cgi?id=23980 : platform specific shell resize behavior
262 String platform= DWT.getPlatform();
263 final bool isWin= platform.equals("win32"); //$NON-NLS-1$
264 if (!isWin && !platform.equals("gtk")) //$NON-NLS-1$
265 return;
266
267 final Canvas resizer= new Canvas(bars, DWT.NONE);
268
269 int size= getResizeHandleSize(bars);
270
271 GridData data= new GridData(DWT.END, DWT.END, false, true);
272 data.widthHint= size;
273 data.heightHint= size;
274 resizer.setLayoutData(data);
275 resizer.addPaintListener(new PaintListener() {
276 public void paintControl(PaintEvent e) {
277 Point s= resizer.getSize();
278 int x= s.x - 2;
279 int y= s.y - 2;
280 int min= Math.min(x, y);
281 if (isWin) {
282 // draw dots
283 e.gc.setBackground(resizer.getDisplay().getSystemColor(DWT.COLOR_WIDGET_HIGHLIGHT_SHADOW));
284 int end= min - 1;
285 for (int i= 0; i <= 2; i++)
286 for (int j= 0; j <= 2 - i; j++)
287 e.gc.fillRectangle(end - 4 * i, end - 4 * j, 2, 2);
288 end--;
289 e.gc.setBackground(resizer.getDisplay().getSystemColor(DWT.COLOR_WIDGET_NORMAL_SHADOW));
290 for (int i= 0; i <= 2; i++)
291 for (int j= 0; j <= 2 - i; j++)
292 e.gc.fillRectangle(end - 4 * i, end - 4 * j, 2, 2);
293
294 } else {
295 // draw diagonal lines
296 e.gc.setForeground(resizer.getDisplay().getSystemColor(DWT.COLOR_WIDGET_NORMAL_SHADOW));
297 for (int i= 1; i < min; i+= 4) {
298 e.gc.drawLine(i, y, x, i);
299 }
300 e.gc.setForeground(resizer.getDisplay().getSystemColor(DWT.COLOR_WIDGET_HIGHLIGHT_SHADOW));
301 for (int i= 2; i < min; i+= 4) {
302 e.gc.drawLine(i, y, x, i);
303 }
304 }
305 }
306 });
307
308 resizer.setCursor(new Cursor(resizer.getDisplay(), DWT.CURSOR_SIZESE));
309 MouseAdapter resizeSupport= new MouseAdapter() {
310 private MouseMoveListener fResizeListener;
311
312 public void mouseDown(MouseEvent e) {
313 Point shellSize= fShell.getSize();
314 final int shellX= shellSize.x;
315 final int shellY= shellSize.y;
316 Point mouseLoc= resizer.toDisplay(e.x, e.y);
317 final int mouseX= mouseLoc.x;
318 final int mouseY= mouseLoc.y;
319 fResizeListener= new MouseMoveListener() {
320 public void mouseMove(MouseEvent e2) {
321 Point mouseLoc2= resizer.toDisplay(e2.x, e2.y);
322 int dx= mouseLoc2.x - mouseX;
323 int dy= mouseLoc2.y - mouseY;
324 setSize(shellX + dx, shellY + dy);
325 }
326 };
327 resizer.addMouseMoveListener(fResizeListener);
328 }
329
330 public void mouseUp(MouseEvent e) {
331 resizer.removeMouseMoveListener(fResizeListener);
332 fResizeListener= null;
333 }
334 };
335 resizer.addMouseListener(resizeSupport);
336 }
337
338 private int getResizeHandleSize(Composite parent) {
339 if (fResizeHandleSize is -1) {
340 Slider sliderV= new Slider(parent, DWT.VERTICAL);
341 Slider sliderH= new Slider(parent, DWT.HORIZONTAL);
342 int width= sliderV.computeSize(DWT.DEFAULT, DWT.DEFAULT).x;
343 int height= sliderH.computeSize(DWT.DEFAULT, DWT.DEFAULT).y;
344 sliderV.dispose();
345 sliderH.dispose();
346 fResizeHandleSize= Math.min(width, height);
347 }
348
349 return fResizeHandleSize;
350 }
351
352 /**
353 * Adds support to move the shell by dragging the given control.
354 *
355 * @param control the control that can be used to move the shell
356 */
357 private void addMoveSupport(final Control control) {
358 MouseAdapter moveSupport= new MouseAdapter() {
359 private MouseMoveListener fMoveListener;
360
361 public void mouseDown(MouseEvent e) {
362 Point shellLoc= fShell.getLocation();
363 final int shellX= shellLoc.x;
364 final int shellY= shellLoc.y;
365 Point mouseLoc= control.toDisplay(e.x, e.y);
366 final int mouseX= mouseLoc.x;
367 final int mouseY= mouseLoc.y;
368 fMoveListener= new MouseMoveListener() {
369 public void mouseMove(MouseEvent e2) {
370 Point mouseLoc2= control.toDisplay(e2.x, e2.y);
371 int dx= mouseLoc2.x - mouseX;
372 int dy= mouseLoc2.y - mouseY;
373 fShell.setLocation(shellX + dx, shellY + dy);
374 }
375 };
376 control.addMouseMoveListener(fMoveListener);
377 }
378
379 public void mouseUp(MouseEvent e) {
380 control.removeMouseMoveListener(fMoveListener);
381 fMoveListener= null;
382 }
383 };
384 control.addMouseListener(moveSupport);
385 }
386
387 /**
388 * Utility to set the foreground and the background color of the given
389 * control
390 *
391 * @param control the control to modify
392 * @param foreground the color to use for the foreground
393 * @param background the color to use for the background
394 */
395 private static void setColor(Control control, Color foreground, Color background) {
396 control.setForeground(foreground);
397 control.setBackground(background);
398 }
399
400 /**
401 * The shell of the popup window.
402 *
403 * @return the shell used for the popup window
404 */
405 protected final Shell getShell() {
406 return fShell;
407 }
408
409 /**
410 * The toolbar manager used to manage the toolbar, or <code>null</code> if
411 * no toolbar is shown.
412 *
413 * @return the tool bar manager or <code>null</code>
414 */
415 protected final ToolBarManager getToolBarManager() {
416 return fToolBarManager;
417 }
418
419 /**
420 * Creates the content of this information control. Subclasses must call
421 * this method at the end of their constructor(s).
422 */
423 protected final void create() {
424 createContent(fContentComposite);
425 }
426
427 /**
428 * Creates the content of the popup window.
429 * <p>
430 * Implementors will usually take over {@link Composite#getBackground()} and
431 * {@link Composite#getForeground()} from <code>parent</code>.
432 * </p>
433 * <p>
434 * Implementors are expected to consider {@link #isResizable()}: If
435 * <code>true</code>, they should show scrollbars if their content may
436 * exceed the size of the information control. If <code>false</code>,
437 * they should never show scrollbars.
438 * </p>
439 * <p>
440 * The given <code>parent</code> comes with a {@link FillLayout}.
441 * Subclasses may set a different layout.
442 * </p>
443 *
444 * @param parent the container of the content
445 */
446 protected abstract void createContent(Composite parent);
447
448 /**
449 * Sets the information to be presented by this information control.
450 * <p>
451 * The default implementation does nothing. Subclasses must either override this method
452 * or implement {@link IInformationControlExtension2}.
453 *
454 * @param information the information to be presented
455 *
456 * @see dwtx.jface.text.IInformationControl#setInformation(java.lang.String)
457 */
458 public void setInformation(String information) {
459
460 }
461
462 /**
463 * Returns whether the information control is resizable.
464 *
465 * @return <code>true</code> if the information control is resizable,
466 * <code>false</code> if it is not resizable.
467 */
468 public bool isResizable() {
469 return fResizable;
470 }
471
472 /*
473 * @see IInformationControl#setVisible(bool)
474 */
475 public void setVisible(bool visible) {
476 if (fShell.isVisible() is visible)
477 return;
478
479 fShell.setVisible(visible);
480 }
481
482 /*
483 * @see IInformationControl#dispose()
484 */
485 public void dispose() {
486 if (fShell !is null && !fShell.isDisposed())
487 fShell.dispose();
488 }
489
490 /*
491 * @see IInformationControl#setSize(int, int)
492 */
493 public void setSize(int width, int height) {
494 fShell.setSize(width, height);
495 }
496
497 /*
498 * @see IInformationControl#setLocation(Point)
499 */
500 public void setLocation(Point location) {
501 fShell.setLocation(location);
502 }
503
504 /*
505 * @see IInformationControl#setSizeConstraints(int, int)
506 */
507 public void setSizeConstraints(int maxWidth, int maxHeight) {
508 fSizeConstraints= new Point(maxWidth, maxHeight);
509 }
510
511 /**
512 * Returns the size constraints.
513 *
514 * @return the size constraints or <code>null</code> if not set
515 * @see #setSizeConstraints(int, int)
516 */
517 protected final Point getSizeConstraints() {
518 return fSizeConstraints !is null ? Geometry.copy(fSizeConstraints) : null;
519 }
520
521 /*
522 * @see IInformationControl#computeSizeHint()
523 */
524 public Point computeSizeHint() {
525 // XXX: Verify whether this is a good default implementation. If yes, document it.
526 Point constrains= getSizeConstraints();
527 if (constrains is null)
528 return fShell.computeSize(DWT.DEFAULT, DWT.DEFAULT, true);
529
530 return fShell.computeSize(constrains.x, constrains.y, true);
531 }
532
533 /**
534 * Computes the trim (status text and tool bar are considered as trim).
535 * Subclasses can extend this method to add additional trim (e.g. scroll
536 * bars for resizable information controls).
537 *
538 * @see dwtx.jface.text.IInformationControlExtension3#computeTrim()
539 */
540 public Rectangle computeTrim() {
541 Rectangle trim= fShell.computeTrim(0, 0, 0, 0);
542
543 if (fStatusComposite !is null)
544 trim.height+= fStatusComposite.computeSize(DWT.DEFAULT, DWT.DEFAULT).y;
545
546 return trim;
547 }
548
549 /*
550 * @see dwtx.jface.text.IInformationControlExtension3#getBounds()
551 */
552 public Rectangle getBounds() {
553 return fShell.getBounds();
554 }
555
556 /**
557 * {@inheritDoc}
558 * <p>
559 * The default implementation always returns <code>false</code>.
560 * </p>
561 * @see dwtx.jface.text.IInformationControlExtension3#restoresLocation()
562 */
563 public bool restoresLocation() {
564 return false;
565 }
566
567 /**
568 * {@inheritDoc}
569 * <p>
570 * The default implementation always returns <code>false</code>.
571 * </p>
572 * @see dwtx.jface.text.IInformationControlExtension3#restoresSize()
573 */
574 public bool restoresSize() {
575 return false;
576 }
577
578 /*
579 * @see IInformationControl#addDisposeListener(DisposeListener)
580 */
581 public void addDisposeListener(DisposeListener listener) {
582 fShell.addDisposeListener(listener);
583 }
584
585 /*
586 * @see IInformationControl#removeDisposeListener(DisposeListener)
587 */
588 public void removeDisposeListener(DisposeListener listener) {
589 fShell.removeDisposeListener(listener);
590 }
591
592 /*
593 * @see IInformationControl#setForegroundColor(Color)
594 */
595 public void setForegroundColor(Color foreground) {
596 fContentComposite.setForeground(foreground);
597 }
598
599 /*
600 * @see IInformationControl#setBackgroundColor(Color)
601 */
602 public void setBackgroundColor(Color background) {
603 fContentComposite.setBackground(background);
604 }
605
606 /**
607 * {@inheritDoc}
608 * This method is not intended to be overridden by subclasses.
609 */
610 public bool isFocusControl() {
611 return fShell.getDisplay().getActiveShell() is fShell;
612 }
613
614 /**
615 * This default implementation sets the focus on the popup shell.
616 * Subclasses can override or extend.
617 *
618 * @see IInformationControl#setFocus()
619 */
620 public void setFocus() {
621 bool focusTaken= fShell.setFocus();
622 if (!focusTaken)
623 fShell.forceFocus();
624 }
625
626 /**
627 * {@inheritDoc}
628 * This method is not intended to be overridden by subclasses.
629 */
630 public void addFocusListener(final FocusListener listener) {
631 if (fFocusListeners.isEmpty()) {
632 fShellListener= new Listener() {
633
634 public void handleEvent(Event event) {
635 Object[] listeners= fFocusListeners.getListeners();
636 for (int i= 0; i < listeners.length; i++) {
637 FocusListener focusListener= (FocusListener)listeners[i];
638 if (event.type is DWT.Activate) {
639 focusListener.focusGained(new FocusEvent(event));
640 } else {
641 focusListener.focusLost(new FocusEvent(event));
642 }
643 }
644 }
645 };
646 fShell.addListener(DWT.Deactivate, fShellListener);
647 fShell.addListener(DWT.Activate, fShellListener);
648 }
649 fFocusListeners.add(listener);
650 }
651
652 /**
653 * {@inheritDoc}
654 * This method is not intended to be overridden by subclasses.
655 */
656 public void removeFocusListener(FocusListener listener) {
657 fFocusListeners.remove(listener);
658 if (fFocusListeners.isEmpty()) {
659 fShell.removeListener(DWT.Activate, fShellListener);
660 fShell.removeListener(DWT.Deactivate, fShellListener);
661 fShellListener= null;
662 }
663 }
664
665 /**
666 * Sets the text of the status field.
667 * <p>
668 * The default implementation currently only updates the status field when
669 * the popup shell is not visible. The status field can currently only be
670 * shown if the information control has been created with a non-null status
671 * field text.
672 * </p>
673 *
674 * @param statusFieldText the text to be used in the optional status field
675 * or <code>null</code> if the status field should be hidden
676 *
677 * @see dwtx.jface.text.IInformationControlExtension4#setStatusText(java.lang.String)
678 */
679 public void setStatusText(String statusFieldText) {
680 if (fStatusLabel !is null && ! getShell().isVisible()) {
681 if (statusFieldText is null ) {
682 fStatusComposite.setVisible(false);
683 } else {
684 fStatusLabel.setText(statusFieldText);
685 fStatusComposite.setVisible(true);
686 }
687 }
688 }
689
690 /*
691 * @see dwtx.jface.text.IInformationControlExtension5#containsControl(dwt.widgets.Control)
692 */
693 public bool containsControl(Control control) {
694 do {
695 if (control is fShell)
696 return true;
697 if (control instanceof Shell)
698 return false;
699 control= control.getParent();
700 } while (control !is null);
701 return false;
702 }
703
704 /*
705 * @see dwtx.jface.text.IInformationControlExtension5#isVisible()
706 */
707 public bool isVisible() {
708 return fShell !is null && !fShell.isDisposed() && fShell.isVisible();
709 }
710
711 /**
712 * {@inheritDoc}
713 * This default implementation returns <code>null</code>. Subclasses may override.
714 */
715 public IInformationControlCreator getInformationPresenterControlCreator() {
716 return null;
717 }
718
719 /**
720 * Computes the size constraints based on the
721 * {@link JFaceResources#getDialogFont() dialog font}. Subclasses can
722 * override or extend.
723 *
724 * @see dwtx.jface.text.IInformationControlExtension5#computeSizeConstraints(int, int)
725 */
726 public Point computeSizeConstraints(int widthInChars, int heightInChars) {
727 GC gc= new GC(fContentComposite);
728 gc.setFont(JFaceResources.getDialogFont());
729 int width= gc.getFontMetrics().getAverageCharWidth();
730 int height= gc.getFontMetrics().getHeight();
731 gc.dispose();
732
733 return new Point(widthInChars * width, heightInChars * height);
734 }
735
736 }