source: trunk/src/gcc/libjava/java/awt/BorderLayout.java@ 1389

/* BorderLayout.java -- A layout manager class
   Copyright (C) 1999, 2002 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., 59 Temple Place, Suite 330, Boston, MA
02111-1307 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 ([email protected])
  * @author Rolf W. Rasmussen  <[email protected]>
  */
public class BorderLayout implements LayoutManager2, java.io.Serializable
{

/*
 * Static Variables
 */

/**
  * 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";

/**
  * Constant indicating the position just after the last line of the
  * layout.
  */
public static final String AFTER_LAST_LINE = "Last";

/**
  * Constant indicating the position just after the end of the line.
  */
public static final String AFTER_LINE_ENDS = "After";

/**
  * Constant indicating the position just before the first line of the
  * layout.
  */
public static final String BEFORE_FIRST_LINE = "First";

/**
  * Constant indicating the position at the beginning of the line.
  */
public static final String BEFORE_LINE_BEGINS = "Before";

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

/*************************************************************************/

/*
 * Instance Variables
 */

/**
  * @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;

/*************************************************************************/

/*
 * Constructors
 */

/**
  * 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;
}

/*************************************************************************/

/*
 * Instance Variables
 */

/**
  * 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");

  String str = (String)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);
}

/*************************************************************************/

/**
  * 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)
{
  addLayoutComponent(component, constraints);
}

/*************************************************************************/

/**
  * 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 calcSize(target, MAX);
}

/*************************************************************************/

/**
  * 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(parent.getAlignmentX());
}

/*************************************************************************/

/**
  * 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(parent.getAlignmentY());
}

/*************************************************************************/

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

/*************************************************************************/

/**
  * Lays out the specified container according to the constraints
  * in this object.
  *
  * @param target The container to lay out.
  */
public void
layoutContainer(Container target)
{
  Insets i = 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 c = calcCompSize(center, PREF);
  Dimension n = calcCompSize(my_north, PREF);
  Dimension s = calcCompSize(my_south, PREF);
  Dimension e = calcCompSize(my_east, PREF);
  Dimension w = calcCompSize(my_west, PREF);
  Dimension t = target.getSize();

    /*
             <-> hgap     <-> hgap
      +----------------------------+          }
      |t                           |          } i.top
      |  +----------------------+  |  --- y1  }
      |  |n                     |  |
      |  +----------------------+  |          } vgap
      |  +---+ +----------+ +---+  |  --- y2  }        }
      |  |w  | |c         | |e  |  |                   } hh
      |  +---+ +----------+ +---+  |          } vgap   }
      |  +----------------------+  |  --- y3  }
      |  |s                     |  |
      |  +----------------------+  |          }
      |                            |          } i.bottom
      +----------------------------+          }
         |x1   |x2          |x3
         <---------------------->
      <-->         ww           <-->
     i.left                    i.right
    */

  int x1 = i.left;
  int x2 = x1 + w.width + hgap;
  int x3 = t.width - i.right - e.width;
  int ww = t.width - i.right - i.left;

  int y1 = i.top;
  int y2 = y1 + n.height + vgap;
  int y3 = t.height - i.bottom - s.height;
  int hh = y3-y2-vgap;

  setBounds(center, x2, y2, x3-x2-hgap, hh);
  setBounds(my_north, x1, y1, ww, n.height);
  setBounds(my_south, x1, y3, ww, s.height);
  setBounds(my_west, x1, y2, w.width, hh);
  setBounds(my_east, x3, y2, e.width, hh);
}

/*************************************************************************/

/**
  * 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 void
setBounds(Component comp, int x, int y, int w, int h)
{
  if (comp == null)
    return;
  comp.setBounds(x, y, w, h);
}

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

private Dimension
calcCompSize(Component comp, int what)
{
  if (comp == null)
    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)
{
  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);
  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;

  height += (ndim.height + sdim.height + (vgap * 2) + ins.top + ins.bottom);

  return(new Dimension(width, height));
}
} // class BorderLayout