FormLayout.java :  » IDE-Eclipse » swt » org » eclipse » swt » layout » Java Open Source

Java Open Source » IDE Eclipse » swt 
swt » org » eclipse » swt » layout » FormLayout.java
/*******************************************************************************
 * 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
 *******************************************************************************/
package org.eclipse.swt.layout;

import org.eclipse.swt.*;
import org.eclipse.swt.graphics.*;
import org.eclipse.swt.widgets.*;

/**
 * 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">SWT Example: LayoutExample</a>
 * @see <a href="http://www.eclipse.org/swt/">Sample code and further information</a> 
 * 
 * @since 2.0
 */
public final class FormLayout extends 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 FormLayout () {
}

/*
 * 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 != 0, C != 0 and A != 1, C != 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, boolean flushCache) {
  FormAttachment top = data.getTopAttachment (control, spacing, flushCache);
  FormAttachment bottom = data.getBottomAttachment (control, spacing, flushCache);
  FormAttachment height = bottom.minus (top);
  if (height.numerator == 0) {
    if (bottom.numerator == 0) return bottom.offset;
    if (bottom.numerator == 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));
}

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

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

String getName () {
  String string = getClass ().getName ();
  int index = string.lastIndexOf ('.');
  if (index == -1) return string;
  return string.substring (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, boolean flushCache) {
  FormAttachment left = data.getLeftAttachment (control, spacing, flushCache);
  FormAttachment right = data.getRightAttachment (control, spacing, flushCache);
  FormAttachment width = right.minus (left);
  if (width.numerator == 0) {
    if (right.numerator == 0) return right.offset;
    if (right.numerator == 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));
}

protected void layout (Composite composite, boolean 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, boolean move, int x, int y, int width, int height, boolean flushCache) {
  Control [] children = composite.getChildren ();
  for (int i=0; i<children.length; i++) {
    Control child = children [i];
    FormData data = (FormData) child.getLayoutData ();
    if (data == null) child.setLayoutData (data = new FormData ());
    if (flushCache) data.flushCache ();
    data.cacheLeft = data.cacheRight = data.cacheTop = data.cacheBottom = null;
  }
  boolean [] flush = null;
  Rectangle [] bounds = null;
  int w = 0, h = 0;
  for (int i=0; i<children.length; i++) {
    Control child = children [i];
    FormData data = (FormData) child.getLayoutData ();
    if (width != SWT.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 == SWT.DEFAULT && !data.needed) {
        int trim = 0;
        //TEMPORARY CODE
        if (child instanceof Scrollable) {
          Rectangle rect = ((Scrollable) child).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 == null) flush = new boolean [children.length];
        flush [i] = true;
      }
      w = Math.max (x2, w);
      if (move) {
        if (bounds == 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 = (FormData) child.getLayoutData ();
    if (height != SWT.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 = (FormData) child.getLayoutData ();
    if (flush != 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
 */
public String toString () {
   String string =  getName ()+" {";
   if (marginWidth != 0) string += "marginWidth="+marginWidth+" ";
   if (marginHeight != 0) string += "marginHeight="+marginHeight+" ";
   if (marginLeft != 0) string += "marginLeft="+marginLeft+" ";
   if (marginRight != 0) string += "marginRight="+marginRight+" ";
   if (marginTop != 0) string += "marginTop="+marginTop+" ";
   if (marginBottom != 0) string += "marginBottom="+marginBottom+" ";
   if (spacing != 0) string += "spacing="+spacing+" ";
   string = string.trim();
   string += "}";
   return string;
}  
}
java2s.com  | Contact Us | Privacy Policy
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.