java/awt/BorderLayout.java

/* BorderLayout.java -- A layout manager class
   Copyright (C) 1999, 2002, 2005  Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */


package java.awt;


/**
  * This class implements a layout manager that positions components
  * in certain sectors of the parent container.
  *
  * @author Aaron M. Renn (arenn@urbanophile.com)
  * @author Rolf W. Rasmussen  (rolfwr@ii.uib.no)
  */
public class BorderLayout implements LayoutManager2, java.io.Serializable
{

  /**
   * Constant indicating the top of the container
   */
  public static final String NORTH = "North";

  /**
   * Constant indicating the bottom of the container
   */
  public static final String SOUTH = "South";

  /**
   * Constant indicating the right side of the container
   */
  public static final String EAST = "East";

  /**
   * Constant indicating the left side of the container
   */
  public static final String WEST = "West";

  /**
   * Constant indicating the center of the container
   */
  public static final String CENTER = "Center";


  /**
   * The constant indicating the position before the first line of the
   * layout.  The exact position depends on the writing system: For a
   * top-to-bottom orientation, it is the same as {@link #NORTH}, for
   * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
   *
   * <p>This constant is an older name for {@link #PAGE_START} which
   * has exactly the same value.
   *
   * @since 1.2
   */
  public static final String BEFORE_FIRST_LINE = "First";

  /**
   * The constant indicating the position after the last line of the
   * layout.  The exact position depends on the writing system: For a
   * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
   * a bottom-to-top orientation, it is the same as {@link #NORTH}.
   *
   * <p>This constant is an older name for {@link #PAGE_END} which
   * has exactly the same value.
   *
   * @since 1.2
   */
  public static final String AFTER_LAST_LINE = "Last";

  /**
   * The constant indicating the position before the first item of the
   * layout.  The exact position depends on the writing system: For a
   * left-to-right orientation, it is the same as {@link #WEST}, for
   * a right-to-left orientation, it is the same as {@link #EAST}.
   *
   * <p>This constant is an older name for {@link #LINE_START} which
   * has exactly the same value.
   *
   * @since 1.2
   */
  public static final String BEFORE_LINE_BEGINS = "Before";

  /**
   * The constant indicating the position after the last item of the
   * layout.  The exact position depends on the writing system: For a
   * left-to-right orientation, it is the same as {@link #EAST}, for
   * a right-to-left orientation, it is the same as {@link #WEST}.
   *
   * <p>This constant is an older name for {@link #LINE_END} which
   * has exactly the same value.
   *
   * @since 1.2
   */
  public static final String AFTER_LINE_ENDS = "After";

  /**
   * The constant indicating the position before the first line of the
   * layout.  The exact position depends on the writing system: For a
   * top-to-bottom orientation, it is the same as {@link #NORTH}, for
   * a bottom-to-top orientation, it is the same as {@link #SOUTH}.
   *
   * @since 1.4
   */
  public static final String PAGE_START = BEFORE_FIRST_LINE;

  /**
   * The constant indicating the position after the last line of the
   * layout.  The exact position depends on the writing system: For a
   * top-to-bottom orientation, it is the same as {@link #SOUTH}, for
   * a bottom-to-top orientation, it is the same as {@link #NORTH}.
   *
   * @since 1.4
   */
  public static final String PAGE_END = AFTER_LAST_LINE;

  /**
   * The constant indicating the position before the first item of the
   * layout.  The exact position depends on the writing system: For a
   * left-to-right orientation, it is the same as {@link #WEST}, for
   * a right-to-left orientation, it is the same as {@link #EAST}.
   *
   * @since 1.4
   */
  public static final String LINE_START = BEFORE_LINE_BEGINS;

  /**
   * The constant indicating the position after the last item of the
   * layout.  The exact position depends on the writing system: For a
   * left-to-right orientation, it is the same as {@link #EAST}, for
   * a right-to-left orientation, it is the same as {@link #WEST}.
   *
   * @since 1.4
   */
  public static final String LINE_END = AFTER_LINE_ENDS;


  /**
   * Serialization constant.
   */
  private static final long serialVersionUID = -8658291919501921765L;


  /**
   * @serial
   */
  private Component north;

  /**
   * @serial
   */
  private Component south;

  /**
   * @serial
   */
  private Component east;

  /**
   * @serial
   */
  private Component west;

  /**
   * @serial
  */
  private Component center;

  /**
   * @serial
   */
  private Component firstLine;

  /**
   * @serial
   */
  private Component lastLine;

  /**
   * @serial
   */
  private Component firstItem;

  /**
   * @serial
   */
  private Component lastItem;

  /**
   * @serial The horizontal gap between components
   */
  private int hgap;

  /**
   * @serial The vertical gap between components
   */
  private int vgap;


  // Some constants for use with calcSize().
  private static final int MIN = 0;
  private static final int MAX = 1;
  private static final int PREF = 2;


  /**
   * Initializes a new instance of <code>BorderLayout</code> with no
   * horiztonal or vertical gaps between components.
   */
  public BorderLayout()
  {
    this(0,0);
  }

  /**
   * Initializes a new instance of <code>BorderLayout</code> with the
   * specified horiztonal and vertical gaps between components.
   *
   * @param hgap The horizontal gap between components.
   * @param vgap The vertical gap between components.
   */
  public BorderLayout(int hgap, int vgap)
  {
    this.hgap = hgap;
    this.vgap = vgap;
  }

  /**
   * Returns the horitzontal gap value.
   *
   * @return The horitzontal gap value.
   */
  public int getHgap()
  {
    return(hgap);
  }

  /**
   * Sets the horizontal gap to the specified value.
   *
   * @param hgap The new horizontal gap.
   */
  public void setHgap(int hgap)
  {
    this.hgap = hgap;
  }

  /**
   * Returns the vertical gap value.
   *
   * @return The vertical gap value.
   */
  public int getVgap()
  {
    return(vgap);
  }

  /**
   * Sets the vertical gap to the specified value.
   *
   * @param vgap The new vertical gap value.
   */
  public void setVgap(int vgap)
  {
    this.vgap = vgap;
  }

  /**
   * Adds a component to the layout in the specified constraint position,
   * which must be one of the string constants defined in this class.
   *
   * @param component The component to add.
   * @param constraints The constraint string.
   *
   * @exception IllegalArgumentException If the constraint object is not
   * a string, or is not one of the specified constants in this class.
   */
  public void addLayoutComponent(Component component, Object constraints)
  {
    if (constraints != null && ! (constraints instanceof String))
      throw new IllegalArgumentException("Constraint must be a string");

    addLayoutComponent((String) constraints, component);
  }

  /**
   * Adds a component to the layout in the specified constraint position,
   * which must be one of the string constants defined in this class.
   *
   * @param constraints The constraint string.
   * @param component The component to add.
   *
   * @exception IllegalArgumentException If the constraint object is not
   *            one of the specified constants in this class.
   *
   * @deprecated This method is deprecated in favor of
   *             <code>addLayoutComponent(Component, Object)</code>.
   */
  public void addLayoutComponent(String constraints, Component component)
  {
    String str = constraints;

    if (str == null || str.equals(CENTER))
      center = component;
    else if (str.equals(NORTH))
      north = component;
    else if (str.equals(SOUTH))
      south = component;
    else if (str.equals(EAST))
      east = component;
    else if (str.equals(WEST))
      west = component;
    else if (str.equals(BEFORE_FIRST_LINE))
      firstLine = component;
    else if (str.equals(AFTER_LAST_LINE))
      lastLine = component;
    else if (str.equals(BEFORE_LINE_BEGINS))
      firstItem = component;
    else if (str.equals(AFTER_LINE_ENDS))
      lastItem = component;
    else
      throw new IllegalArgumentException("Constraint value not valid: " + str);
  }

  /**
   * Removes the specified component from the layout.
   *
   * @param component The component to remove from the layout.
   */
  public void removeLayoutComponent(Component component)
  {
    if (north == component)
      north = null;
    if (south == component)
      south = null;
    if (east == component)
      east = null;
    if (west == component)
      west = null;
    if (center == component)
      center = null;
    if (firstItem == component)
      firstItem = null;
    if (lastItem == component)
      lastItem = null;
    if (firstLine == component)
      firstLine = null;
    if (lastLine == component)
      lastLine = null;
  }

  /**
   * Returns the minimum size of the specified container using this layout.
   *
   * @param target The container to calculate the minimum size for.
   *
   * @return The minimum size of the container
   */
  public Dimension minimumLayoutSize(Container target)
  {
    return calcSize(target, MIN);
  }

  /**
   * Returns the preferred size of the specified container using this layout.
   *
   * @param target The container to calculate the preferred size for.
   *
   * @return The preferred size of the container
   */
  public Dimension preferredLayoutSize(Container target)
  {
    return calcSize(target, PREF);
  }

  /**
   * Returns the maximum size of the specified container using this layout.
   *
   * @param target The container to calculate the maximum size for.
   *
   * @return The maximum size of the container
   */
  public Dimension maximumLayoutSize(Container target)
  {
    return new Dimension (Integer.MAX_VALUE, Integer.MAX_VALUE);
  }

  /**
   * Returns the X axis alignment, which is a <code>float</code> indicating
   * where along the X axis this container wishs to position its layout.
   * 0 indicates align to the left, 1 indicates align to the right, and 0.5
   * indicates align to the center.
   *
   * @param parent The parent container.
   *
   * @return The X alignment value.
   */
  public float getLayoutAlignmentX(Container parent)
  {
    return 0.5F;
  }

  /**
   * Returns the Y axis alignment, which is a <code>float</code> indicating
   * where along the Y axis this container wishs to position its layout.
   * 0 indicates align to the top, 1 indicates align to the bottom, and 0.5
   * indicates align to the center.
   *
   * @param parent The parent container.
   *
   * @return The Y alignment value.
   */
  public float getLayoutAlignmentY(Container parent)
  {
    return 0.5F;
  }

  /**
   * Instructs this object to discard any layout information it might
   * have cached.
   *
   * @param parent The parent container.
   */
  public void invalidateLayout(Container parent)
  {
    // Nothing to do here.
  }

  /**
   * Lays out the specified container according to the constraints in this
   * object.
   *
   * @param target The container to lay out.
   */
  public void layoutContainer(Container target)
  {
    synchronized (target.getTreeLock())
      {
        Insets i = target.getInsets();
        int top = i.top;
        int bottom = target.height - i.bottom;
        int left = i.left;
        int right = target.width - i.right;

        boolean left_to_right = target.getComponentOrientation().isLeftToRight();

        Component my_north = north;
        Component my_east = east;
        Component my_south = south;
        Component my_west = west;

        // Note that we currently don't handle vertical layouts.
        // Neither does JDK 1.3.
        if (firstLine != null)
          my_north = firstLine;
        if (lastLine != null)
          my_south = lastLine;
        if (firstItem != null)
          {
            if (left_to_right)
              my_west = firstItem;
            else
              my_east = firstItem;
          }
        if (lastItem != null)
          {
            if (left_to_right)
              my_east = lastItem;
            else
              my_west = lastItem;
          }

        if (my_north != null)
          {
            Dimension n = calcCompSize(my_north, PREF);
            my_north.setBounds(left, top, right - left, n.height);
            top += n.height + vgap;
          }

        if (my_south != null)
          {
            Dimension s = calcCompSize(my_south, PREF);
            my_south.setBounds(left, bottom - s.height, right - left, s.height);
            bottom -= s.height + vgap;
          }

        if (my_east != null)
          {
            Dimension e = calcCompSize(my_east, PREF);
            my_east.setBounds(right - e.width, top, e.width, bottom - top);
            right -= e.width + hgap;
          }

        if (my_west != null)
          {
            Dimension w = calcCompSize(my_west, PREF);
            my_west.setBounds(left, top, w.width, bottom - top);
            left += w.width + hgap;
          }

        if (center != null)
          center.setBounds(left, top, right - left, bottom - top);
      }
  }

  /**
   * Returns a string representation of this layout manager.
   *
   * @return A string representation of this object.
   */
  public String toString()
  {
    return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
  }

  private Dimension calcCompSize(Component comp, int what)
  {
    if (comp == null || ! comp.isVisible())
      return new Dimension(0, 0);
    if (what == MIN)
      return comp.getMinimumSize();
    else if (what == MAX)
      return comp.getMaximumSize();
    return comp.getPreferredSize();
  }

  /**
   * This is a helper function used to compute the various sizes for this
   * layout.
   */
  private Dimension calcSize(Container target, int what)
  {
    synchronized (target.getTreeLock())
      {
        Insets ins = target.getInsets();

        ComponentOrientation orient = target.getComponentOrientation ();
        boolean left_to_right = orient.isLeftToRight ();

        Component my_north = north;
        Component my_east = east;
        Component my_south = south;
        Component my_west = west;

        // Note that we currently don't handle vertical layouts.  Neither
        // does JDK 1.3.
        if (firstLine != null)
          my_north = firstLine;
        if (lastLine != null)
          my_south = lastLine;
        if (firstItem != null)
          {
            if (left_to_right)
              my_west = firstItem;
            else
              my_east = firstItem;
          }
        if (lastItem != null)
          {
            if (left_to_right)
              my_east = lastItem;
            else
              my_west = lastItem;
          }

        Dimension ndim = calcCompSize(my_north, what);
        Dimension sdim = calcCompSize(my_south, what);
        Dimension edim = calcCompSize(my_east, what);
        Dimension wdim = calcCompSize(my_west, what);
        Dimension cdim = calcCompSize(center, what);

        int width = edim.width + cdim.width + wdim.width + (hgap * 2);
        // Check for overflow.
        if (width < edim.width || width < cdim.width || width < cdim.width)
          width = Integer.MAX_VALUE;

        if (ndim.width > width)
          width = ndim.width;
        if (sdim.width > width)
          width = sdim.width;

        width += (ins.left + ins.right);

        int height = edim.height;
        if (cdim.height > height)
          height = cdim.height;
        if (wdim.height > height)
          height = wdim.height;

        int addedHeight = height + (ndim.height + sdim.height + (vgap * 2)
                                    + ins.top + ins.bottom);
        // Check for overflow.
        if (addedHeight < height)
          height = Integer.MAX_VALUE;
        else
          height = addedHeight;

        return(new Dimension(width, height));
      }
  }

  /**
   * Return the component at the indicated location, or null if no component
   * is at that location.  The constraints argument must be one of the
   * location constants specified by this class.
   * @param constraints the location
   * @return the component at that location, or null
   * @throws IllegalArgumentException if the constraints argument is not
   * recognized
   * @since 1.5
   */
  public Component getLayoutComponent(Object constraints)
  {
    if (constraints == CENTER)
      return center;
    if (constraints == NORTH)
      return north;
    if (constraints == EAST)
      return east;
    if (constraints == SOUTH)
      return south;
    if (constraints == WEST)
      return west;
    if (constraints == PAGE_START)
      return firstLine;
    if (constraints == PAGE_END)
      return lastLine;
    if (constraints == LINE_START)
      return firstItem;
    if (constraints == LINE_END)
      return lastItem;
    throw new IllegalArgumentException("constraint " + constraints
                                       + " is not recognized");
  }

  /**
   * Return the component at the specified location, which must be one
   * of the absolute constants such as CENTER or SOUTH.  The container's
   * orientation is used to map this location to the correct corresponding
   * component, so for instance in a right-to-left container, a request
   * for the EAST component could return the LINE_END component.  This will
   * return null if no component is available at the given location.
   * @param container the container whose orientation is used
   * @param constraints the absolute location of the component
   * @return the component at the location, or null
   * @throws IllegalArgumentException if the constraint is not recognized
   */
  public Component getLayoutComponent(Container container, Object constraints)
  {
    ComponentOrientation orient = container.getComponentOrientation();
    if (constraints == CENTER)
      return center;
    // Note that we don't support vertical layouts.
    if (constraints == NORTH)
      return north;
    if (constraints == SOUTH)
      return south;
    if (constraints == WEST)
      {
        // Note that relative layout takes precedence.
        if (orient.isLeftToRight())
          return firstItem == null ? west : firstItem;
        return lastItem == null ? west : lastItem;
      }
    if (constraints == EAST)
      {
        // Note that relative layout takes precedence.
        if (orient.isLeftToRight())
          return lastItem == null ? east : lastItem;
        return firstItem == null ? east : firstItem;
      }
    throw new IllegalArgumentException("constraint " + constraints
                                       + " is not recognized");
  }

  /**
   * Return the constraint corresponding to a component in this layout.
   * If the component is null, or is not in this layout, returns null.
   * Otherwise, this will return one of the constraint constants defined
   * in this class.
   * @param c the component
   * @return the constraint, or null
   * @since 1.5
   */
  public Object getConstraints(Component c)
  {
    if (c == null)
      return null;
    if (c == center)
      return CENTER;
    if (c == north)
      return NORTH;
    if (c == east)
      return EAST;
    if (c == south)
      return SOUTH;
    if (c == west)
      return WEST;
    if (c == firstLine)
      return PAGE_START;
    if (c == lastLine)
      return PAGE_END;
    if (c == firstItem)
      return LINE_START;
    if (c == lastItem)
      return LINE_END;
    return null;
  }
}