Mercurial > projects > dwt-win
view dwt/layout/FormLayout.d @ 212:ab60f3309436
reverted the char[] to String and use the an alias.
author | Frank Benoit <benoit@tionex.de> |
---|---|
date | Mon, 05 May 2008 00:12:38 +0200 |
parents | 9a64a7781bab |
children | fd9c62a2998e |
line wrap: on
line source
/******************************************************************************* * 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 * 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 * * @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; } }