package com.swtSample.layout;

import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Point;
import org.eclipse.swt.graphics.Rectangle;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Layout;

/**
 * This class contains a BorderLayout, which is loosely patterned after the old
 * AWT BorderLayout. It uses the <code>BorderData</code> class to determine
 * positioning of controls. To position controls, call <code>control.setLayoutData()</code>,
 * passing the <code>BorderData</code> of your choice.
 * 
 * For example:
 * 
 * <code>
 *  shell.setLayoutData(new BorderLayout());
 *  Button button = new Button(shell, SWT.PUSH);
 *  button.setLayoutData(BorderData.NORTH);
 * </code>
 * 
 * Note that you can add as many controls to the same direction as you like, but
 * the last one added for the direction will be the one displayed.
 */
public class BorderLayout extends Layout {
  private Control north;
  private Control south;
  private Control east;
  private Control west;
  private Control center;

  /**
   * Computes the size for this BorderLayout.
   * 
   * @param composite the composite that contains the controls
   * @param wHint width hint in pixels for the minimum width
   * @param hHint height hint in pixels for the minimum height
   * @param flushCache if true, flushes any cached values
   * @return Point
   * @see org.eclipse.swt.widgets.Layout#computeSize(org.eclipse.swt.widgets.Composite,
   *      int, int, boolean)
   */
  protected Point computeSize(Composite composite, int wHint, int hHint,
      boolean flushCache) {
    getControls(composite);
    int width = 0, height = 0;

    // The width is the width of the west control
    // plus the width of the center control
    // plus the width of the east control.
    // If this is less than the width of the north
    // or the south control, however, use the largest
    // of those three widths.
    width += west == null ? 0 : getSize(west, flushCache).x;
    width += east == null ? 0 : getSize(east, flushCache).x;
    width += center == null ? 0 : getSize(center, flushCache).x;

    if (north != null) {
      Point pt = getSize(north, flushCache);
      width = Math.max(width, pt.x);
    }
    if (south != null) {
      Point pt = getSize(south, flushCache);
      width = Math.max(width, pt.x);
    }

    // The height is the height of the north control
    // plus the height of the maximum height of the
    // west, center, and east controls
    // plus the height of the south control.
    height += north == null ? 0 : getSize(north, flushCache).y;
    height += south == null ? 0 : getSize(south, flushCache).y;

    int heightOther = center == null ? 0 : getSize(center, flushCache).y;
    if (west != null) {
      Point pt = getSize(west, flushCache);
      heightOther = Math.max(heightOther, pt.y);
    }
    if (east != null) {
      Point pt = getSize(east, flushCache);
      heightOther = Math.max(heightOther, pt.y);
    }
    height += heightOther;

    // Respect the wHint and hHint
    return new Point(Math.max(width, wHint), Math.max(height, hHint));
  }

  /**
   * This does the work of laying out our controls.
   * 
   * @see org.eclipse.swt.widgets.Layout#layout(org.eclipse.swt.widgets.Composite,
   *      boolean)
   */
  protected void layout(Composite composite, boolean flushCache) {
    getControls(composite);
    Rectangle rect = composite.getClientArea();
    int left = rect.x, right = rect.width, top = rect.y, bottom = rect.height;
    if (north != null) {
      Point pt = getSize(north, flushCache);
      north.setBounds(left, top, rect.width, pt.y);
      top += pt.y;
    }
    if (south != null) {
      Point pt = getSize(south, flushCache);
      south.setBounds(left, rect.height - pt.y, rect.width, pt.y);
      bottom -= pt.y;
    }
    if (east != null) {
      Point pt = getSize(east, flushCache);
      east.setBounds(rect.width - pt.x, top, pt.x, (bottom - top));
      right -= pt.x;
    }
    if (west != null) {
      Point pt = getSize(west, flushCache);
      west.setBounds(left, top, pt.x, (bottom - top));
      left += pt.x;
    }
    if (center != null) {
      center.setBounds(left, top, (right - left), (bottom - top));
    }
  }

  protected Point getSize(Control control, boolean flushCache) {
    return control.computeSize(SWT.DEFAULT, SWT.DEFAULT, flushCache);
  }

  protected void getControls(Composite composite) {
    // Iterate through all the controls, setting
    // the member data according to the BorderData.
    // Note that we overwrite any previously set data.
    // Note also that we default to CENTER
    Control[] children = composite.getChildren();
    for (int i = 0, n = children.length; i < n; i++) {
      Control child = children[i];
      BorderData borderData = (BorderData) child.getLayoutData();
      if (borderData == BorderData.NORTH)
        north = child;
      else if (borderData == BorderData.SOUTH)
        south = child;
      else if (borderData == BorderData.EAST)
        east = child;
      else if (borderData == BorderData.WEST)
        west = child;
      else
        center = child;
    }
  }
}