/*******************************************************************************
 * Copyright (c) 2000, 2007 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Michael Williamson (eclipse-bugs@magnaworks.com) - patch (see Bugzilla #92545)
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwtx.ui.forms.widgets.FormToolkit;

import dwtx.ui.forms.widgets.Hyperlink;
import dwtx.ui.forms.widgets.ImageHyperlink;
import dwtx.ui.forms.widgets.ExpandableComposite;
import dwtx.ui.forms.widgets.Form;
import dwtx.ui.forms.widgets.ScrolledPageBook;
import dwtx.ui.forms.widgets.ScrolledForm;
import dwtx.ui.forms.widgets.FormText;
import dwtx.ui.forms.widgets.Section;
import dwtx.ui.forms.widgets.LayoutComposite;

import dwt.DWT;
import dwt.custom.CCombo;
import dwt.custom.ScrolledComposite;
import dwt.events.FocusAdapter;
import dwt.events.FocusEvent;
import dwt.events.KeyAdapter;
import dwt.events.KeyEvent;
import dwt.events.MouseAdapter;
import dwt.events.MouseEvent;
import dwt.events.PaintEvent;
import dwt.events.PaintListener;
import dwt.graphics.Color;
import dwt.graphics.Font;
import dwt.graphics.GC;
import dwt.graphics.Point;
import dwt.graphics.RGB;
import dwt.graphics.Rectangle;
import dwt.widgets.Button;
import dwt.widgets.Composite;
import dwt.widgets.Control;
import dwt.widgets.Display;
import dwt.widgets.Event;
import dwt.widgets.Label;
import dwt.widgets.Listener;
import dwt.widgets.Table;
import dwt.widgets.Text;
import dwt.widgets.Tree;
import dwt.widgets.Widget;
import dwtx.jface.resource.JFaceResources;
import dwtx.jface.window.Window;
import dwtx.ui.forms.FormColors;
import dwtx.ui.forms.HyperlinkGroup;
import dwtx.ui.forms.IFormColors;
import dwtx.ui.internal.forms.widgets.FormFonts;
import dwtx.ui.internal.forms.widgets.FormUtil;

import dwt.dwthelper.utils;

/**
 * The toolkit is responsible for creating DWT controls adapted to work in
 * Eclipse forms. In addition to changing their presentation properties (fonts,
 * colors etc.), various listeners are attached to make them behave correctly in
 * the form context.
 * <p>
 * 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.
 * <p>
 * The toolkit creates some of the most common controls used to populate Eclipse
 * forms. Controls that must be created using their constructors,
 * <code>adapt()</code> method is available to change its properties in the
 * same way as with the supported toolkit controls.
 * <p>
 * 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).
 * <p>
 * FormToolkit is normally instantiated, but can also be subclassed if some of
 * the methods needs to be modified. In those cases, <code>super</code> must
 * be called to preserve normal behaviour.
 *
 * @since 3.0
 */
public class FormToolkit {
    public static const String KEY_DRAW_BORDER = "FormWidgetFactory.drawBorder"; //$NON-NLS-1$

    public static const String TREE_BORDER = "treeBorder"; //$NON-NLS-1$

    public static const String TEXT_BORDER = "textBorder"; //$NON-NLS-1$

    private int borderStyle = DWT.NULL;

    private FormColors colors;

    private int orientation;

    // private KeyListener deleteListener;
    private BorderPainter borderPainter;

    private BoldFontHolder boldFontHolder;

    private HyperlinkGroup hyperlinkGroup;

    /* default */
    VisibilityHandler visibilityHandler;

    /* default */
    KeyboardHandler keyboardHandler;

    private class BorderPainter : PaintListener {
        public void paintControl(PaintEvent event) {
            Composite composite = cast(Composite) event.widget;
            Control[] children = composite.getChildren();
            for (int i = 0; i < children.length; i++) {
                Control c = children[i];
                bool inactiveBorder = false;
                bool textBorder = false;
                if (!c.isVisible())
                    continue;
                /*
                 * if (c.getEnabled() is false && !(c instanceof CCombo))
                 * continue;
                 */
                if (null !is cast(Hyperlink)c )
                    continue;
                Object flag = c.getData(KEY_DRAW_BORDER);
                if (flag !is null) {
                    if (flag.opEquals(Boolean.FALSE))
                        continue;
                    if (flag.opEquals(stringcast(TREE_BORDER)))
                        inactiveBorder = true;
                    else if (flag.opEquals(stringcast(TEXT_BORDER)))
                        textBorder = true;
                }
                if (getBorderStyle() is DWT.BORDER) {
                    if (!inactiveBorder && !textBorder) {
                        continue;
                    }
                    if (null !is cast(Text)c  || null !is cast(Table)c
                            || null !is cast(Tree)c )
                        continue;
                }
                if (!inactiveBorder
                        && (null !is cast(Text)c  || null !is cast(CCombo)c  || 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() is DWT.BORDER ? colors
                    // .getBorderColor() : colors.getForeground());
                    gc.setForeground(colors.getBorderColor());
                    if (null !is cast(CCombo)c )
                        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 || null !is cast(Table)c
                        || null !is cast(Tree)c ) {
                    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 : FocusAdapter {
        public void focusGained(FocusEvent e) {
            Widget w = e.widget;
            if (null !is cast(Control)w ) {
                FormUtil.ensureVisible(cast(Control) w);
            }
        }
    }

    private static class KeyboardHandler : KeyAdapter {
        public void keyPressed(KeyEvent e) {
            Widget w = e.widget;
            if (null !is cast(Control)w ) {
                if (e.doit)
                    FormUtil.processKey(e.keyCode, cast(Control) w);
            }
        }
    }

    private class BoldFontHolder {
        private Font normalFont;

        private Font boldFont;

        public this() {
        }

        public Font getBoldFont(Font font) {
            createBoldFont(font);
            return boldFont;
        }

        private void createBoldFont(Font font) {
            if (normalFont is null || !normalFont.opEquals(font)) {
                normalFont = font;
                dispose();
            }
            if (boldFont is null) {
                boldFont = FormFonts.getInstance().getBoldFont(colors.getDisplay(),
                        normalFont);
            }
        }

        public void dispose() {
            if (boldFont !is null) {
                FormFonts.getInstance().markFinished(boldFont);
                boldFont = null;
            }
        }
    }

    /**
     * Creates a toolkit that is self-sufficient (will manage its own colors).
     *
     */
    public this(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 <b>not</b> marked as
     * shared via the <code>markShared()</code> method.
     *
     * @param colors
     *            the shared colors
     */
    public this(FormColors colors) {
        orientation = Window.getDefaultOrientation();
        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 <code>null</code>)
     * @param style
     *            the button style (for example, <code>DWT.PUSH</code>)
     * @return the button widget
     */
    public Button createButton(Composite parent, String text, int style) {
        Button button = new Button(parent, style | DWT.FLAT | orientation);
        if (text !is 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, DWT.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);
        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
     */
    public Composite createCompositeSeparator(Composite parent) {
        final Composite composite = new Composite(parent, orientation);
    // DWT FIXME: problem with DMD and anonclass/nested func
        composite.addListener(DWT.Paint, dgListener( &dwtWorkaround, composite));
        if (null !is cast(Section)parent )
            (cast(Section) parent).setSeparatorControl(composite);
        return composite;
    }
    // DWT FIXME: problem with DMD and anonclass/nested func
        private void dwtWorkaround (Event e, Composite composite) {
            if (composite.isDisposed())
                return;
            Rectangle bounds = composite.getBounds();
            GC gc = e.gc;
            gc.setForeground(colors.getColor(IFormColors.SEPARATOR));
            if (colors.getBackground() !is null)
                gc.setBackground(colors.getBackground());
            gc.fillGradientRectangle(0, 0, bounds.width, bounds.height,
                    false);
        }
    /**
     * 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, DWT.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 !is 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 !is 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 <code>true</code>, the toolkit will monitor focus
     *            transfers to ensure that the hyperlink in focus is visible in
     *            the form.
     * @return the rich text widget
     */
    public FormText createFormText(Composite parent, bool trackFocus) {
        FormText engine = new FormText(parent, DWT.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 <code>true</code>, form will be scrolled horizontally
     *            and/or vertically if needed to ensure that the control is
     *            visible when it gains focus. Set it to <code>false</code> if
     *            the control is not capable of gaining focus.
     * @param trackKeyboard
     *            if <code>true</code>, 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
     *            <code>false</code> 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, bool trackFocus, bool trackKeyboard) {
        control.setBackground(colors.getBackground());
        control.setForeground(colors.getForeground());
        if (null !is cast(ExpandableComposite)control ) {
            ExpandableComposite ec = cast(ExpandableComposite) control;
            if (ec.toggle_package !is null) {
                if (trackFocus)
                    ec.toggle_package.addFocusListener(visibilityHandler);
                if (trackKeyboard)
                    ec.toggle_package.addKeyListener(keyboardHandler);
            }
            if (ec.textLabel_package !is null) {
                if (trackFocus)
                    ec.textLabel_package.addFocusListener(visibilityHandler);
                if (trackKeyboard)
                    ec.textLabel_package.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 class MouseAdapter {
            public void mouseDown(MouseEvent e) {
                (cast(Control) e.widget).setFocus();
            }
        });
        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_package !is null) {
            section.toggle_package.setHoverDecorationColor(colors
                    .getColor(IFormColors.TB_TOGGLE_HOVER));
            section.toggle_package.setDecorationColor(colors
                    .getColor(IFormColors.TB_TOGGLE));
        }
        section.setFont(boldFontHolder.getBoldFont(parent.getFont()));
        if ((sectionStyle & Section.TITLE_BAR) !is 0
                || (sectionStyle & Section.SHORT_TITLE_BAR) !is 0) {
            colors.initializeSectionToolBarColors();
            section.setTitleBarBackground(colors.getColor(IFormColors.TB_BG));
            section.setTitleBarBorderColor(colors
                    .getColor(IFormColors.TB_BORDER));
            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, DWT.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, DWT.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 !is 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 ScrolledForm createScrolledForm(Composite parent) {
        ScrolledForm form = new ScrolledForm(parent, DWT.V_SCROLL
                | DWT.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.
     *
     * @since 3.3
     * @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([ top, bot ], [ 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 (colors.isShared() is 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());
    }

    /**
     * Paints flat borders for widgets created by this toolkit within the
     * provided parent. Borders will not be painted if the global border style
     * is DWT.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.
     * <p>
     * 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:
     *
     * <pre>
     *
     *
     *
     *             widget.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TREE_BORDER);
     *
     *             or
     *
     *             widget.setData(FormToolkit.KEY_DRAW_BORDER, FormToolkit.TEXT_BORDER);
     *
     *
     *
     * </pre>
     *
     * @param parent
     *            the parent that owns the children for which the border needs
     *            to be painted.
     */
    public void paintBordersFor(Composite parent) {
        // if (borderStyle is DWT.BORDER)
        // return;
        if (borderPainter is 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 DWT.BORDER and don't paint the borders
     * ourselves. Otherwise, the style is set to DWT.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
     * @since 3.3
     */
    public int getBorderMargin() {
        return getBorderStyle() is DWT.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
     *            <code>DWT.BORDER</code> or <code>DWT.NULL</code>
     * @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 <code>true</code>, the scrolled composite will be
     *            scrolled only vertically if needed. Otherwise, the scrolled
     *            composite origin will be set to the control origin.
     * @since 3.1
     */
    public static void setControlVisible(Control c, bool verticalOnly) {
        ScrolledComposite scomp = FormUtil.getScrolledComposite(c);
        if (scomp is 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();
    }

    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(DWT.COLOR_WIDGET_BACKGROUND);
            if (rgb.red !is 212 || rgb.green !is 208 || rgb.blue !is 200)
                borderStyle = DWT.BORDER;
        } else if (osname.startsWith("Mac")) //$NON-NLS-1$
            borderStyle = DWT.BORDER;
    }

    /**
     * Returns the orientation that all the widgets created by this toolkit will
     * inherit, if set. Can be <code>DWT.NULL</code>,
     * <code>DWT.LEFT_TO_RIGHT</code> and <code>DWT.RIGHT_TO_LEFT</code>.
     *
     * @return orientation style for this toolkit, or <code>DWT.NULL</code> if
     *         not set. The default orientation is inherited from the Window
     *         default orientation.
     * @see dwtx.jface.window.Window#getDefaultOrientation()
     * @since 3.1
     */

    public int getOrientation() {
        return orientation;
    }

    /**
     * Sets the orientation that all the widgets created by this toolkit will
     * inherit. Can be <code>DWT.NULL</code>, <code>DWT.LEFT_TO_RIGHT</code>
     * and <code>DWT.RIGHT_TO_LEFT</code>.
     *
     * @param orientation
     *            style for this toolkit.
     * @since 3.1
     */

    public void setOrientation(int orientation) {
        this.orientation = orientation;
    }
}