root/dwt/layout/FormLayout.d

/*******************************************************************************
 * Copyright (c) 2000, 2008 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
 * Port to the D programming language:
 *     Frank Benoit <benoit@tionex.de>
 *******************************************************************************/
module dwt.layout.FormLayout;

import dwt.layout.FormAttachment;
import dwt.layout.FormData;
import dwt.DWT;
import dwt.graphics.Point;
import dwt.graphics.Rectangle;
import dwt.widgets.Control;
import dwt.widgets.Layout;
import dwt.widgets.Composite;
import dwt.widgets.Scrollable;

import tango.util.Convert;
import Math = tango.math.Math;
import dwt.dwthelper.utils;

/**
 * Instances of this class control the position and size of the
 * children of a composite control by using <code>FormAttachments</code>
 * to optionally configure the left, top, right and bottom edges of
 * each child.
 * <p>
 * The following example code creates a <code>FormLayout</code> and then sets
 * it into a <code>Shell</code>:
 * <pre>
 *      Display display = new Display ();
 *      Shell shell = new Shell(display);
 *      FormLayout layout = new FormLayout();
 *      layout.marginWidth = 3;
 *      layout.marginHeight = 3;
 *      shell.setLayout(layout);
 * </pre>
 * </p>
 * <p>
 * To use a <code>FormLayout</code>, create a <code>FormData</code> with
 * <code>FormAttachment</code> for each child of <code>Composite</code>.
 * The following example code attaches <code>button1</code> to the top
 * and left edge of the composite and <code>button2</code> to the right
 * edge of <code>button1</code> and the top and right edges of the
 * composite:
 * <pre>
 *      FormData data1 = new FormData();
 *      data1.left = new FormAttachment(0, 0);
 *      data1.top = new FormAttachment(0, 0);
 *      button1.setLayoutData(data1);
 *      FormData data2 = new FormData();
 *      data2.left = new FormAttachment(button1);
 *      data2.top = new FormAttachment(0, 0);
 *      data2.right = new FormAttachment(100, 0);
 *      button2.setLayoutData(data2);
 * </pre>
 * </p>
 * <p>
 * Each side of a child control can be attached to a position in the parent
 * composite, or to other controls within the <code>Composite</code> by
 * creating instances of <code>FormAttachment</code> and setting them into
 * the top, bottom, left, and right fields of the child's <code>FormData</code>.
 * </p>
 * <p>
 * If a side is not given an attachment, it is defined as not being attached
 * to anything, causing the child to remain at its preferred size.  If a child
 * is given no attachment on either the left or the right or top or bottom, it is
 * automatically attached to the left and top of the composite respectively.
 * The following code positions <code>button1</code> and <code>button2</code>
 * but relies on default attachments:
 * <pre>
 *      FormData data2 = new FormData();
 *      data2.left = new FormAttachment(button1);
 *      data2.right = new FormAttachment(100, 0);
 *      button2.setLayoutData(data2);
 * </pre>
 * </p>
 * <p>
 * IMPORTANT: Do not define circular attachments.  For example, do not attach
 * the right edge of <code>button1</code> to the left edge of <code>button2</code>
 * and then attach the left edge of <code>button2</code> to the right edge of
 * <code>button1</code>.  This will over constrain the layout, causing undefined
 * behavior.  The algorithm will terminate, but the results are undefined.
 * </p>
 *
 * @see FormData
 * @see FormAttachment
 * @see <a href="http://www.eclipse.org/swt/snippets/#formlayout">FormLayout snippets</a>
 * @see <a href="http://www.eclipse.org/swt/examples.php">DWT Example: LayoutExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> 
 *
 * @since 2.0
 */
public final class FormLayout : Layout {

    /**
     * marginWidth specifies the number of pixels of horizontal margin
     * that will be placed along the left and right edges of the layout.
     *
     * The default value is 0.
     */
    public int marginWidth = 0;

    /**
     * marginHeight specifies the number of pixels of vertical margin
     * that will be placed along the top and bottom edges of the layout.
     *
     * The default value is 0.
     */
    public int marginHeight = 0;


    /**
     * marginLeft specifies the number of pixels of horizontal margin
     * that will be placed along the left edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginLeft = 0;

    /**
     * marginTop specifies the number of pixels of vertical margin
     * that will be placed along the top edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginTop = 0;

    /**
     * marginRight specifies the number of pixels of horizontal margin
     * that will be placed along the right edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginRight = 0;

    /**
     * marginBottom specifies the number of pixels of vertical margin
     * that will be placed along the bottom edge of the layout.
     *
     * The default value is 0.
     *
     * @since 3.1
     */
    public int marginBottom = 0;

    /**
     * spacing specifies the number of pixels between the edge of one control
     * and the edge of its neighbouring control.
     *
     * The default value is 0.
     *
     * @since 3.0
     */
    public int spacing = 0;

/**
 * Constructs a new instance of this class.
 */
public this () {
}

/*
 * Computes the preferred height of the form with
 * respect to the preferred height of the control.
 *
 * Given that the equations for top (T) and bottom (B)
 * of the control in terms of the height of the form (X)
 * are:
 *      T = AX + B
 *      B = CX + D
 *
 * The equation for the height of the control (H)
 * is bottom (B) minus top (T) or (H = B - T) or:
 *
 *      H = (CX + D) - (AX + B)
 *
 * Solving for (X), the height of the form, we get:
 *
 *      X = (H + B - D) / (C - A)
 *
 * When (A = C), (C - A = 0) and the equation has no
 * solution for X.  This is a special case meaning that
 * the control does not constrain the height of the
 * form.  In this case, we need to arbitrarily define
 * the height of the form (X):
 *
 * Case 1: A = C, A = 0, C = 0
 *
 *      Let X = D, the distance from the top of the form
 *      to the bottom edge of the control.  In this case,
 *      the control was attached to the top of the form
 *      and the form needs to be large enough to show the
 *      bottom edge of the control.
 *
 * Case 2: A = C, A = 1, C = 1
 *
 *      Let X = -B, the distance from the bottom of the
 *      form to the top edge of the control.  In this case,
 *      the control was attached to the bottom of the form
 *      and the only way that the control would be visible
 *      is if the offset is negative.  If the offset is
 *      positive, there is no possible height for the form
 *      that will show the control as it will always be
 *      below the bottom edge of the form.
 *
 * Case 3: A = C, A !is 0, C !is 0 and A !is 1, C !is 0
 *
 *      Let X = D / (1 - C), the distance from the top of the
 *      form to the bottom edge of the control.  In this case,
 *      since C is not 0 or 1, it must be a fraction, U / V.
 *      The offset D is the distance from CX to the bottom edge
 *      of the control.  This represents a fraction of the form
 *      (1 - C)X. Since the height of a fraction of the form is
 *      known, the height of the entire form can be found by setting
 *      (1 - C)X = D.  We solve this equation for X in terms of U
 *      and V, giving us X = (U * D) / (U - V). Similarly, if the
 *      offset D is negative, the control is positioned above CX.
 *      The offset -B is the distance from the top edge of the control
 *      to CX. We can find the height of the entire form by setting
 *      CX = -B. Solving in terms of U and V gives us X = (-B * V) / U.
 */
int computeHeight (Control control, FormData data, bool flushCache) {
    FormAttachment top = data.getTopAttachment (control, spacing, flushCache);
    FormAttachment bottom = data.getBottomAttachment (control, spacing, flushCache);
    FormAttachment height = bottom.minus (top);
    if (height.numerator is 0) {
        if (bottom.numerator is 0) return bottom.offset;
        if (bottom.numerator is bottom.denominator) return -top.offset;
        if (bottom.offset <= 0) {
            return -top.offset * top.denominator / bottom.numerator;
        }
        int divider = bottom.denominator - bottom.numerator;
        return bottom.denominator * bottom.offset / divider;
    }
    return height.solveY (data.getHeight (control, flushCache));
}

override protected Point computeSize (Composite composite, int wHint, int hHint, bool flushCache) {
    Point size = layout (composite, false, 0, 0, wHint, hHint, flushCache);
    if (wHint !is DWT.DEFAULT) size.x = wHint;
    if (hHint !is DWT.DEFAULT) size.y = hHint;
    return size;
}

override protected bool flushCache (Control control) {
    Object data = control.getLayoutData ();
    if (data !is null) (cast(FormData) data).flushCache ();
    return true;
}

String getName () {
    String string = this.classinfo.name;
    int index = string.lastIndexOf('.');
    if (index is -1 ) return string;
    return string[ index + 1 .. string.length ];
}

/*
 * Computes the preferred height of the form with
 * respect to the preferred height of the control.
 */
int computeWidth (Control control, FormData data, bool flushCache) {
    FormAttachment left = data.getLeftAttachment (control, spacing, flushCache);
    FormAttachment right = data.getRightAttachment (control, spacing, flushCache);
    FormAttachment width = right.minus (left);
    if (width.numerator is 0) {
        if (right.numerator is 0) return right.offset;
        if (right.numerator is right.denominator) return -left.offset;
        if (right.offset <= 0) {
            return -left.offset * left.denominator / left.numerator;
        }
        int divider = right.denominator - right.numerator;
        return right.denominator * right.offset / divider;
    }
    return width.solveY (data.getWidth (control, flushCache));
}

override protected void layout (Composite composite, bool flushCache) {
    Rectangle rect = composite.getClientArea ();
    int x = rect.x + marginLeft + marginWidth;
    int y = rect.y + marginTop + marginHeight;
    int width = Math.max (0, rect.width - marginLeft - 2 * marginWidth - marginRight);
    int height = Math.max (0, rect.height - marginTop - 2 * marginHeight - marginBottom);
    layout (composite, true, x, y, width, height, flushCache);
}

Point layout (Composite composite, bool move, int x, int y, int width, int height, bool flushCache) {
    Control [] children = composite.getChildren ();
    for (int i=0; i<children.length; i++) {
        Control child = children [i];
        FormData data = cast(FormData) child.getLayoutData ();
        if (data is null) child.setLayoutData (data = new FormData ());
        if (flushCache) data.flushCache ();
        data.cacheLeft = data.cacheRight = data.cacheTop = data.cacheBottom = null;
    }
    bool [] flush = null;
    Rectangle [] bounds = null;
    int w = 0, h = 0;
    for (int i=0; i<children.length; i++) {
        Control child = children [i];
        FormData data = cast(FormData) child.getLayoutData ();
        if (width !is DWT.DEFAULT) {
            data.needed = false;
            FormAttachment left = data.getLeftAttachment (child, spacing, flushCache);
            FormAttachment right = data.getRightAttachment (child, spacing, flushCache);
            int x1 = left.solveX (width), x2 = right.solveX (width);
            if (data.height is DWT.DEFAULT && !data.needed) {
                int trim = 0;
                //TEMPORARY CODE
                if ( auto sa = cast(Scrollable)child) {
                    Rectangle rect = sa.computeTrim (0, 0, 0, 0);
                    trim = rect.width;
                } else {
                    trim = child.getBorderWidth () * 2;
                }
                data.cacheWidth = data.cacheHeight = -1;
                int currentWidth = Math.max (0, x2 - x1 - trim);
                data.computeSize (child, currentWidth, data.height, flushCache);
                if (flush is null) flush = new bool [children.length];
                flush [i] = true;
            }
            w = Math.max (x2, w);
            if (move) {
                if (bounds is null) bounds = new Rectangle [children.length];
                bounds [i] = new Rectangle (0, 0, 0, 0);
                bounds [i].x = x + x1;
                bounds [i].width = x2 - x1;
            }
        } else {
            w = Math.max (computeWidth (child, data, flushCache), w);
        }
    }
    for (int i=0; i<children.length; i++) {
        Control child = children [i];
        FormData data = cast(FormData) child.getLayoutData ();
        if (height !is DWT.DEFAULT) {
            int y1 = data.getTopAttachment (child, spacing, flushCache).solveX (height);
            int y2 = data.getBottomAttachment (child, spacing, flushCache).solveX (height);
            h = Math.max (y2, h);
            if (move) {
                bounds [i].y = y + y1;
                bounds [i].height = y2 - y1;
            }
        } else {
            h = Math.max (computeHeight (child, data, flushCache), h);
        }
    }
    for (int i=0; i<children.length; i++) {
        Control child = children [i];
        FormData data = cast(FormData) child.getLayoutData ();
        if (flush !is null && flush [i]) data.cacheWidth = data.cacheHeight = -1;
        data.cacheLeft = data.cacheRight = data.cacheTop = data.cacheBottom = null;
    }
    if (move) {
        for (int i=0; i<children.length; i++) {
            children [i].setBounds (bounds [i]);
        }
    }
    w += marginLeft + marginWidth * 2 + marginRight;
    h += marginTop + marginHeight * 2 + marginBottom;
    return new Point (w, h);
}

/**
 * Returns a string containing a concise, human-readable
 * description of the receiver.
 *
 * @return a string representation of the layout
 */
override public String toString () {
    String string =  getName ()~" {";
    if (marginWidth !is 0) string ~= "marginWidth="~to!(String)(marginWidth)~" ";
    if (marginHeight !is 0) string ~= "marginHeight="~to!(String)(marginHeight)~" ";
    if (marginLeft !is 0) string ~= "marginLeft="~to!(String)(marginLeft)~" ";
    if (marginRight !is 0) string ~= "marginRight="~to!(String)(marginRight)~" ";
    if (marginTop !is 0) string ~= "marginTop="~to!(String)(marginTop)~" ";
    if (marginBottom !is 0) string ~= "marginBottom="~to!(String)(marginBottom)~" ";
    if (spacing !is 0) string ~= "spacing="~to!(String)(spacing)~" ";
    string = string.trim();
    string ~= "}";
    return string;
}
}