2127637945
Imported GNU Classpath 0.20
* Makefile.am (AM_CPPFLAGS): Add classpath/include.
* java/nio/charset/spi/CharsetProvider.java: New override file.
* java/security/Security.java: Likewise.
* sources.am: Regenerated.
* Makefile.in: Likewise.
From-SVN: r109831
774 lines
22 KiB
Java
774 lines
22 KiB
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();
|
|
|
|
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);
|
|
int targetWidth = target.getWidth();
|
|
int targetHeight = target.getHeight();
|
|
|
|
/*
|
|
<-> 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 + (w.width == 0 ? 0 : hgap);
|
|
int x3;
|
|
if (targetWidth <= i.right + e.width)
|
|
x3 = x2 + w.width + (w.width == 0 ? 0 : hgap);
|
|
else
|
|
x3 = targetWidth - i.right - e.width;
|
|
int ww = targetWidth - i.right - i.left;
|
|
|
|
int y1 = i.top;
|
|
int y2 = y1 + n.height + (n.height == 0 ? 0 : vgap);
|
|
int midh = Math.max(e.height, Math.max(w.height, c.height));
|
|
int y3;
|
|
if (targetHeight <= i.bottom + s.height)
|
|
y3 = y2 + midh + vgap;
|
|
else
|
|
y3 = targetHeight - i.bottom - s.height;
|
|
int hh = y3-y2-(s.height == 0 ? 0 : vgap);
|
|
|
|
setBounds(center, x2, y2, x3-x2-(w.width == 0 ? 0 : 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 + "]";
|
|
}
|
|
|
|
/**
|
|
* This is a convenience method to set the bounds on a component.
|
|
* If the indicated component is null, nothing is done.
|
|
*/
|
|
private void setBounds(Component comp, int x, int y, int w, int h)
|
|
{
|
|
if (comp == null)
|
|
return;
|
|
comp.setBounds(x, y, w, h);
|
|
}
|
|
|
|
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;
|
|
}
|
|
}
|