* In addition to being the control factory, the toolkit is also responsible for * painting flat borders for select controls, managing hyperlink groups and * control colors. *
* The toolkit creates some of the most common controls used to populate Eclipse
* forms. Controls that must be created using their constructors,
* adapt() method is available to change its properties in the
* same way as with the supported toolkit controls.
*
* Typically, one toolkit object is created per workbench part (for example, an * editor or a form wizard). The toolkit is disposed when the part is disposed. * To conserve resources, it is possible to create one color object for the * entire plug-in and share it between several toolkits. The plug-in is * responsible for disposing the colors (disposing the toolkit that uses shared * color object will not dispose the colors). *
* FormToolkit is normally instantiated, but can also be subclassed if some of
* the methods needs to be modified. In those cases, super must
* be called to preserve normal behaviour.
*
* @since 1.0
*/
public class FormToolkit {
public static final String KEY_DRAW_BORDER = "FormWidgetFactory.drawBorder"; //$NON-NLS-1$
public static final String TREE_BORDER = "treeBorder"; //$NON-NLS-1$
public static final String TEXT_BORDER = "textBorder"; //$NON-NLS-1$
private int borderStyle = SWT.NULL;
private FormColors colors;
private int orientation = Window.getDefaultOrientation();
// private KeyListener deleteListener;
// RAP [rh] Paint events missing
// private BorderPainter borderPainter;
private BoldFontHolder boldFontHolder;
// private HyperlinkGroup hyperlinkGroup;
private boolean isDisposed = false;
/* default */
VisibilityHandler visibilityHandler;
/* default */
KeyboardHandler keyboardHandler;
// RAP [rh] Paint events missing
// private class BorderPainter implements PaintListener {
// public void paintControl(PaintEvent event) {
// Composite composite = (Composite) event.widget;
// Control[] children = composite.getChildren();
// for (int i = 0; i < children.length; i++) {
// Control c = children[i];
// boolean inactiveBorder = false;
// boolean textBorder = false;
// if (!c.isVisible())
// continue;
// /*
// * if (c.getEnabled() == false && !(c instanceof CCombo))
// * continue;
// */
// if (c instanceof Hyperlink)
// continue;
// Object flag = c.getData(KEY_DRAW_BORDER);
// if (flag != null) {
// if (flag.equals(Boolean.FALSE))
// continue;
// if (flag.equals(TREE_BORDER))
// inactiveBorder = true;
// else if (flag.equals(TEXT_BORDER))
// textBorder = true;
// }
// if (getBorderStyle() == SWT.BORDER) {
// if (!inactiveBorder && !textBorder) {
// continue;
// }
// if (c instanceof Text || c instanceof Table
// || c instanceof Tree)
// continue;
// }
// if (!inactiveBorder
// && (c instanceof Text || c instanceof CCombo || textBorder)) {
// Rectangle b = c.getBounds();
// GC gc = event.gc;
// gc.setForeground(c.getBackground());
// gc.drawRectangle(b.x - 1, b.y - 1, b.width + 1,
// b.height + 1);
// // gc.setForeground(getBorderStyle() == SWT.BORDER ? colors
// // .getBorderColor() : colors.getForeground());
// gc.setForeground(colors.getBorderColor());
// if (c instanceof CCombo)
// gc.drawRectangle(b.x - 1, b.y - 1, b.width + 1,
// b.height + 1);
// else
// gc.drawRectangle(b.x - 1, b.y - 2, b.width + 1,
// b.height + 3);
// } else if (inactiveBorder || c instanceof Table
// || c instanceof Tree) {
// Rectangle b = c.getBounds();
// GC gc = event.gc;
// gc.setForeground(colors.getBorderColor());
// gc.drawRectangle(b.x - 1, b.y - 1, b.width + 1,
// b.height + 1);
// }
// }
// }
// }
private static class VisibilityHandler extends FocusAdapter {
public void focusGained(FocusEvent e) {
Widget w = e.widget;
if (w instanceof Control) {
FormUtil.ensureVisible((Control) w);
}
}
}
private static class KeyboardHandler extends KeyAdapter {
public void keyPressed(KeyEvent e) {
Widget w = e.widget;
if (w instanceof Control) {
if (e.doit)
FormUtil.processKey(e.keyCode, (Control) w);
}
}
}
private class BoldFontHolder {
private Font normalFont;
private Font boldFont;
public BoldFontHolder() {
}
public Font getBoldFont(Font font) {
createBoldFont(font);
return boldFont;
}
private void createBoldFont(Font font) {
if (normalFont == null || !normalFont.equals(font)) {
normalFont = font;
dispose();
}
if (boldFont == null) {
boldFont = FormFonts.getInstance().getBoldFont(colors.getDisplay(),
normalFont);
}
}
public void dispose() {
if (boldFont != null) {
FormFonts.getInstance().markFinished(boldFont);
boldFont = null;
}
}
}
/**
* Creates a toolkit that is self-sufficient (will manage its own colors).
*
* Clients that call this method must call {@link #dispose()} when they
* are finished using the toolkit.
*
*/
public FormToolkit(Display display) {
this(new FormColors(display));
}
/**
* Creates a toolkit that will use the provided (shared) colors. The toolkit
* will dispose the colors if and only if they are not marked as
* shared via the markShared() method.
*
* Clients that call this method must call {@link #dispose()} when they
* are finished using the toolkit.
*
* @param colors
* the shared colors
*/
public FormToolkit(FormColors colors) {
this.colors = colors;
initialize();
}
/**
* Creates a button as a part of the form.
*
* @param parent
* the button parent
* @param text
* an optional text for the button (can be null)
* @param style
* the button style (for example, SWT.PUSH)
* @return the button widget
*/
public Button createButton(Composite parent, String text, int style) {
Button button = new Button(parent, style | SWT.FLAT | orientation);
if (text != null)
button.setText(text);
adapt(button, true, true);
return button;
}
/**
* Creates the composite as a part of the form.
*
* @param parent
* the composite parent
* @return the composite widget
*/
public Composite createComposite(Composite parent) {
return createComposite(parent, SWT.NULL);
}
/**
* Creates the composite as part of the form using the provided style.
*
* @param parent
* the composite parent
* @param style
* the composite style
* @return the composite widget
*/
public Composite createComposite(Composite parent, int style) {
// Composite composite = new LayoutComposite(parent, style | orientation);
Composite composite = new Composite(parent, style | orientation);
adapt(composite);
return composite;
}
/**
* Creats the composite that can server as a separator between various parts
* of a form. Separator height should be controlled by setting the height
* hint on the layout data for the composite.
*
* @param parent
* the separator parent
* @return the separator widget
*/
// RAP [rh] createCompositeSeparator: currently no useful implementation possible, delete?
public Composite createCompositeSeparator(Composite parent) {
final Composite composite = new Composite(parent, orientation);
// RAP [rh] GC and paint events missing
// composite.addListener(SWT.Paint, new Listener() {
// public void handleEvent(Event e) {
// if (composite.isDisposed())
// return;
// Rectangle bounds = composite.getBounds();
// GC gc = e.gc;
// gc.setForeground(colors.getColor(IFormColors.SEPARATOR));
// if (colors.getBackground() != null)
// gc.setBackground(colors.getBackground());
// gc.fillGradientRectangle(0, 0, bounds.width, bounds.height,
// false);
// }
// });
// if (parent instanceof Section)
// ((Section) parent).setSeparatorControl(composite);
return composite;
}
/**
* Creates a label as a part of the form.
*
* @param parent
* the label parent
* @param text
* the label text
* @return the label widget
*/
public Label createLabel(Composite parent, String text) {
return createLabel(parent, text, SWT.NONE);
}
/**
* Creates a label as a part of the form.
*
* @param parent
* the label parent
* @param text
* the label text
* @param style
* the label style
* @return the label widget
*/
public Label createLabel(Composite parent, String text, int style) {
Label label = new Label(parent, style | orientation);
if (text != null)
label.setText(text);
adapt(label, false, false);
return label;
}
/**
* Creates a hyperlink as a part of the form. The hyperlink will be added to
* the hyperlink group that belongs to this toolkit.
*
* @param parent
* the hyperlink parent
* @param text
* the text of the hyperlink
* @param style
* the hyperlink style
* @return the hyperlink widget
*/
// public Hyperlink createHyperlink(Composite parent, String text, int style) {
// Hyperlink hyperlink = new Hyperlink(parent, style | orientation);
// if (text != null)
// hyperlink.setText(text);
// hyperlink.addFocusListener(visibilityHandler);
// hyperlink.addKeyListener(keyboardHandler);
// hyperlinkGroup.add(hyperlink);
// return hyperlink;
// }
/**
* Creates an image hyperlink as a part of the form. The hyperlink will be
* added to the hyperlink group that belongs to this toolkit.
*
* @param parent
* the hyperlink parent
* @param style
* the hyperlink style
* @return the image hyperlink widget
*/
// public ImageHyperlink createImageHyperlink(Composite parent, int style) {
// ImageHyperlink hyperlink = new ImageHyperlink(parent, style
// | orientation);
// hyperlink.addFocusListener(visibilityHandler);
// hyperlink.addKeyListener(keyboardHandler);
// hyperlinkGroup.add(hyperlink);
// return hyperlink;
// }
/**
* Creates a rich text as a part of the form.
*
* @param parent
* the rich text parent
* @param trackFocus
* if true, the toolkit will monitor focus
* transfers to ensure that the hyperlink in focus is visible in
* the form.
* @return the rich text widget
* @since 1.2
*/
// public FormText createFormText(Composite parent, boolean trackFocus) {
// FormText engine = new FormText(parent, SWT.WRAP | orientation);
// engine.marginWidth = 1;
// engine.marginHeight = 0;
// engine.setHyperlinkSettings(getHyperlinkGroup());
// adapt(engine, trackFocus, true);
// engine.setMenu(parent.getMenu());
// return engine;
// }
/**
* Adapts a control to be used in a form that is associated with this
* toolkit. This involves adjusting colors and optionally adding handlers to
* ensure focus tracking and keyboard management.
*
* @param control
* a control to adapt
* @param trackFocus
* if true, form will be scrolled horizontally
* and/or vertically if needed to ensure that the control is
* visible when it gains focus. Set it to false if
* the control is not capable of gaining focus.
* @param trackKeyboard
* if true, the control that is capable of
* gaining focus will be tracked for certain keys that are
* important to the underlying form (for example, PageUp,
* PageDown, ScrollUp, ScrollDown etc.). Set it to
* false if the control is not capable of gaining
* focus or these particular key event are already used by the
* control.
*/
public void adapt(Control control, boolean trackFocus, boolean trackKeyboard) {
control.setBackground(colors.getBackground());
control.setForeground(colors.getForeground());
// if (control instanceof ExpandableComposite) {
// ExpandableComposite ec = (ExpandableComposite) control;
// if (ec.toggle != null) {
// if (trackFocus)
// ec.toggle.addFocusListener(visibilityHandler);
// if (trackKeyboard)
// ec.toggle.addKeyListener(keyboardHandler);
// }
// if (ec.textLabel != null) {
// if (trackFocus)
// ec.textLabel.addFocusListener(visibilityHandler);
// if (trackKeyboard)
// ec.textLabel.addKeyListener(keyboardHandler);
// }
// return;
// }
if (trackFocus)
control.addFocusListener(visibilityHandler);
if (trackKeyboard)
control.addKeyListener(keyboardHandler);
}
/**
* Adapts a composite to be used in a form associated with this toolkit.
*
* @param composite
* the composite to adapt
*/
public void adapt(Composite composite) {
composite.setBackground(colors.getBackground());
composite.addMouseListener(new MouseAdapter() {
public void mouseDown(MouseEvent e) {
((Control) e.widget).setFocus();
}
});
if (composite.getParent() != null)
composite.setMenu(composite.getParent().getMenu());
}
/**
* A helper method that ensures the provided control is visible when
* ScrolledComposite is somewhere in the parent chain. If scroll bars are
* visible and the control is clipped, the client of the scrolled composite
* will be scrolled to reveal the control.
*
* @param c
* the control to reveal
*/
public static void ensureVisible(Control c) {
FormUtil.ensureVisible(c);
}
/**
* Creates a section as a part of the form.
*
* @param parent
* the section parent
* @param sectionStyle
* the section style
* @return the section widget
*/
// public Section createSection(Composite parent, int sectionStyle) {
// Section section = new Section(parent, orientation, sectionStyle);
// section.setMenu(parent.getMenu());
// adapt(section, true, true);
// if (section.toggle != null) {
// section.toggle.setHoverDecorationColor(colors
// .getColor(IFormColors.TB_TOGGLE_HOVER));
// section.toggle.setDecorationColor(colors
// .getColor(IFormColors.TB_TOGGLE));
// }
// section.setFont(boldFontHolder.getBoldFont(parent.getFont()));
// if ((sectionStyle & Section.TITLE_BAR) != 0
// || (sectionStyle & Section.SHORT_TITLE_BAR) != 0) {
// colors.initializeSectionToolBarColors();
// section.setTitleBarBackground(colors.getColor(IFormColors.TB_BG));
// section.setTitleBarBorderColor(colors
// .getColor(IFormColors.TB_BORDER));
// }
// // call setTitleBarForeground regardless as it also sets the label color
// section.setTitleBarForeground(colors
// .getColor(IFormColors.TB_TOGGLE));
// return section;
// }
/**
* Creates an expandable composite as a part of the form.
*
* @param parent
* the expandable composite parent
* @param expansionStyle
* the expandable composite style
* @return the expandable composite widget
*/
// public ExpandableComposite createExpandableComposite(Composite parent,
// int expansionStyle) {
// ExpandableComposite ec = new ExpandableComposite(parent, orientation,
// expansionStyle);
// ec.setMenu(parent.getMenu());
// adapt(ec, true, true);
// ec.setFont(boldFontHolder.getBoldFont(ec.getFont()));
// return ec;
// }
/**
* Creates a separator label as a part of the form.
*
* @param parent
* the separator parent
* @param style
* the separator style
* @return the separator label
*/
public Label createSeparator(Composite parent, int style) {
Label label = new Label(parent, SWT.SEPARATOR | style | orientation);
label.setBackground(colors.getBackground());
label.setForeground(colors.getBorderColor());
return label;
}
/**
* Creates a table as a part of the form.
*
* @param parent
* the table parent
* @param style
* the table style
* @return the table widget
*/
public Table createTable(Composite parent, int style) {
Table table = new Table(parent, style | borderStyle | orientation);
adapt(table, false, false);
// hookDeleteListener(table);
return table;
}
/**
* Creates a text as a part of the form.
*
* @param parent
* the text parent
* @param value
* the text initial value
* @return the text widget
*/
public Text createText(Composite parent, String value) {
return createText(parent, value, SWT.SINGLE);
}
/**
* Creates a text as a part of the form.
*
* @param parent
* the text parent
* @param value
* the text initial value
* @param style
* the text style
* @return the text widget
*/
public Text createText(Composite parent, String value, int style) {
Text text = new Text(parent, borderStyle | style | orientation);
if (value != null)
text.setText(value);
text.setForeground(colors.getForeground());
text.setBackground(colors.getBackground());
text.addFocusListener(visibilityHandler);
return text;
}
/**
* Creates a tree widget as a part of the form.
*
* @param parent
* the tree parent
* @param style
* the tree style
* @return the tree widget
*/
public Tree createTree(Composite parent, int style) {
Tree tree = new Tree(parent, borderStyle | style | orientation);
adapt(tree, false, false);
// hookDeleteListener(tree);
return tree;
}
/**
* Creates a scrolled form widget in the provided parent. If you do not
* require scrolling because there is already a scrolled composite up the
* parent chain, use 'createForm' instead.
*
* @param parent
* the scrolled form parent
* @return the form that can scroll itself
* @see #createForm
*/
public ScrolledComposite createScrolledForm(Composite parent) {
ScrolledComposite form = new ScrolledComposite(parent, SWT.V_SCROLL
| SWT.H_SCROLL | orientation);
form.setExpandHorizontal(true);
form.setExpandVertical(true);
form.setBackground(colors.getBackground());
form.setForeground(colors.getColor(IFormColors.TITLE));
form.setFont(JFaceResources.getHeaderFont());
return form;
}
/**
* Creates a form widget in the provided parent. Note that this widget does
* not scroll its content, so make sure there is a scrolled composite up the
* parent chain. If you require scrolling, use 'createScrolledForm' instead.
*
* @param parent
* the form parent
* @return the form that does not scroll
* @see #createScrolledForm
*/
// public Form createForm(Composite parent) {
// Form formContent = new Form(parent, orientation);
// formContent.setBackground(colors.getBackground());
// formContent.setForeground(colors.getColor(IFormColors.TITLE));
// formContent.setFont(JFaceResources.getHeaderFont());
// return formContent;
// }
/**
* Takes advantage of the gradients and other capabilities to decorate the
* form heading using colors computed based on the current skin and
* operating system.
*
* @param form
* the form to decorate
*/
// public void decorateFormHeading(Form form) {
// Color top = colors.getColor(IFormColors.H_GRADIENT_END);
// Color bot = colors.getColor(IFormColors.H_GRADIENT_START);
// form.setTextBackground(new Color[] { top, bot }, new int[] { 100 },
// true);
// form.setHeadColor(IFormColors.H_BOTTOM_KEYLINE1, colors
// .getColor(IFormColors.H_BOTTOM_KEYLINE1));
// form.setHeadColor(IFormColors.H_BOTTOM_KEYLINE2, colors
// .getColor(IFormColors.H_BOTTOM_KEYLINE2));
// form.setHeadColor(IFormColors.H_HOVER_LIGHT, colors
// .getColor(IFormColors.H_HOVER_LIGHT));
// form.setHeadColor(IFormColors.H_HOVER_FULL, colors
// .getColor(IFormColors.H_HOVER_FULL));
// form.setHeadColor(IFormColors.TB_TOGGLE, colors
// .getColor(IFormColors.TB_TOGGLE));
// form.setHeadColor(IFormColors.TB_TOGGLE_HOVER, colors
// .getColor(IFormColors.TB_TOGGLE_HOVER));
// form.setSeparatorVisible(true);
// }
/**
* Creates a scrolled page book widget as a part of the form.
*
* @param parent
* the page book parent
* @param style
* the text style
* @return the scrolled page book widget
*/
// public ScrolledPageBook createPageBook(Composite parent, int style) {
// ScrolledPageBook book = new ScrolledPageBook(parent, style
// | orientation);
// adapt(book, true, true);
// book.setMenu(parent.getMenu());
// return book;
// }
/**
* Disposes the toolkit.
*/
public void dispose() {
if (isDisposed) {
return;
}
isDisposed = true;
if (colors.isShared() == false) {
colors.dispose();
colors = null;
}
boldFontHolder.dispose();
}
/**
* Returns the hyperlink group that manages hyperlinks for this toolkit.
*
* @return the hyperlink group
*/
// public HyperlinkGroup getHyperlinkGroup() {
// return hyperlinkGroup;
// }
/**
* Sets the background color for the entire toolkit. The method delegates
* the call to the FormColors object and also updates the hyperlink group so
* that hyperlinks and other objects are in sync.
*
* @param bg
* the new background color
*/
public void setBackground(Color bg) {
// hyperlinkGroup.setBackground(bg);
colors.setBackground(bg);
}
/**
* Refreshes the hyperlink colors by loading from JFace settings.
*/
// public void refreshHyperlinkColors() {
// hyperlinkGroup.initializeDefaultForegrounds(colors.getDisplay());
// }
// RAP [rh] paintBordersFor not useful as no GC to actually paint borders
// /**
// * Paints flat borders for widgets created by this toolkit within the
// * provided parent. Borders will not be painted if the global border style
// * is SWT.BORDER (i.e. if native borders are used). Call this method during
// * creation of a form composite to get the borders of its children painted.
// * Care should be taken when selection layout margins. At least one pixel
// * pargin width and height must be chosen to allow the toolkit to paint the
// * border on the parent around the widgets.
// *
// * Borders are painted for some controls that are selected by the toolkit by // * default. If a control needs a border but is not on its list, it is // * possible to force border in the following way: // * // *
// * // * // * // * widget.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TREE_BORDER); // * // * or // * // * widget.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER); // * // * // * // *// * // * @param parent // * the parent that owns the children for which the border needs // * to be painted. // */ // public void paintBordersFor(Composite parent) { // // if (borderStyle == SWT.BORDER) // // return; // if (borderPainter == null) // borderPainter = new BorderPainter(); // parent.addPaintListener(borderPainter); // } /** * Returns the colors used by this toolkit. * * @return the color object */ public FormColors getColors() { return colors; } /** * Returns the border style used for various widgets created by this * toolkit. The intent of the toolkit is to create controls with styles that * yield a 'flat' appearance. On systems where the native borders are * already flat, we set the style to SWT.BORDER and don't paint the borders * ourselves. Otherwise, the style is set to SWT.NULL, and borders are * painted by the toolkit. * * @return the global border style */ public int getBorderStyle() { return borderStyle; } /** * Returns the margin required around the children whose border is being * painted by the toolkit using {@link #paintBordersFor(Composite)}. Since * the border is painted around the controls on the parent, a number of * pixels needs to be reserved for this border. For windowing systems where * the native border is used, this margin is 0. * * @return the margin in the parent when children have their border painted */ public int getBorderMargin() { return getBorderStyle() == SWT.BORDER ? 0 : 2; } /** * Sets the border style to be used when creating widgets. The toolkit * chooses the correct style based on the platform but this value can be * changed using this method. * * @param style *
SWT.BORDER or SWT.NULL
* @see #getBorderStyle
*/
public void setBorderStyle(int style) {
this.borderStyle = style;
}
/**
* A utility method that ensures that the control is visible in the scrolled
* composite. The prerequisite for this method is that the control has a
* class that extends ScrolledComposite somewhere in the parent chain. If
* the control is partially or fully clipped, the composite is scrolled to
* set by setting the origin to the control origin.
*
* @param c
* the control to make visible
* @param verticalOnly
* if true, the scrolled composite will be
* scrolled only vertically if needed. Otherwise, the scrolled
* composite origin will be set to the control origin.
*/
public static void setControlVisible(Control c, boolean verticalOnly) {
ScrolledComposite scomp = FormUtil.getScrolledComposite(c);
if (scomp == null)
return;
Point location = FormUtil.getControlLocation(scomp, c);
scomp.setOrigin(location);
}
private void initialize() {
initializeBorderStyle();
// hyperlinkGroup = new HyperlinkGroup(colors.getDisplay());
// hyperlinkGroup.setBackground(colors.getBackground());
visibilityHandler = new VisibilityHandler();
keyboardHandler = new KeyboardHandler();
boldFontHolder = new BoldFontHolder();
}
// RAP [rh] revise detection of border style: can't ask OS here
private void initializeBorderStyle() {
// String osname = System.getProperty("os.name"); //$NON-NLS-1$
// String osversion = System.getProperty("os.version"); //$NON-NLS-1$
// if (osname.startsWith("Windows") && "5.1".compareTo(osversion) <= 0) { //$NON-NLS-1$ //$NON-NLS-2$
// // Skinned widgets used on newer Windows (e.g. XP (5.1), Vista
// // (6.0))
// // Check for Windows Classic. If not used, set the style to BORDER
// RGB rgb = colors.getSystemColor(SWT.COLOR_WIDGET_BACKGROUND);
// if (rgb.red != 212 || rgb.green != 208 || rgb.blue != 200)
// borderStyle = SWT.BORDER;
// } else if (osname.startsWith("Mac")) //$NON-NLS-1$
// borderStyle = SWT.BORDER;
borderStyle = SWT.BORDER;
}
/**
* Returns the orientation that all the widgets created by this toolkit will
* inherit, if set. Can be SWT.NULL,
* SWT.LEFT_TO_RIGHT and SWT.RIGHT_TO_LEFT.
*
* @return orientation style for this toolkit, or SWT.NULL if
* not set. The default orientation is inherited from the Window
* default orientation.
* @see org.eclipse.jface.window.Window#getDefaultOrientation()
*/
public int getOrientation() {
return orientation;
}
/**
* Sets the orientation that all the widgets created by this toolkit will
* inherit. Can be SWT.NULL, SWT.LEFT_TO_RIGHT
* and SWT.RIGHT_TO_LEFT.
*
* @param orientation
* style for this toolkit.
*/
public void setOrientation(int orientation) {
this.orientation = orientation;
}
}