707 lines
18 KiB
Java
707 lines
18 KiB
Java
/* 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 (arenn@urbanophile.com)
|
|
* @author Rolf W. Rasmussen <rolfwr@ii.uib.no>
|
|
*/
|
|
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";
|
|
|
|
|
|
/**
|
|
* 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;
|
|
|
|
/*************************************************************************/
|
|
|
|
/*
|
|
* 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
|