You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
888 lines
30 KiB
888 lines
30 KiB
/*
|
|
* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package java.awt;
|
|
|
|
import java.util.Hashtable;
|
|
|
|
/**
|
|
* A border layout lays out a container, arranging and resizing
|
|
* its components to fit in five regions:
|
|
* north, south, east, west, and center.
|
|
* Each region may contain no more than one component, and
|
|
* is identified by a corresponding constant:
|
|
* <code>NORTH</code>, <code>SOUTH</code>, <code>EAST</code>,
|
|
* <code>WEST</code>, and <code>CENTER</code>. When adding a
|
|
* component to a container with a border layout, use one of these
|
|
* five constants, for example:
|
|
* <pre>
|
|
* Panel p = new Panel();
|
|
* p.setLayout(new BorderLayout());
|
|
* p.add(new Button("Okay"), BorderLayout.SOUTH);
|
|
* </pre>
|
|
* As a convenience, <code>BorderLayout</code> interprets the
|
|
* absence of a string specification the same as the constant
|
|
* <code>CENTER</code>:
|
|
* <pre>
|
|
* Panel p2 = new Panel();
|
|
* p2.setLayout(new BorderLayout());
|
|
* p2.add(new TextArea()); // Same as p.add(new TextArea(), BorderLayout.CENTER);
|
|
* </pre>
|
|
* <p>
|
|
* In addition, <code>BorderLayout</code> supports the relative
|
|
* positioning constants, <code>PAGE_START</code>, <code>PAGE_END</code>,
|
|
* <code>LINE_START</code>, and <code>LINE_END</code>.
|
|
* In a container whose <code>ComponentOrientation</code> is set to
|
|
* <code>ComponentOrientation.LEFT_TO_RIGHT</code>, these constants map to
|
|
* <code>NORTH</code>, <code>SOUTH</code>, <code>WEST</code>, and
|
|
* <code>EAST</code>, respectively.
|
|
* <p>
|
|
* For compatibility with previous releases, <code>BorderLayout</code>
|
|
* also includes the relative positioning constants <code>BEFORE_FIRST_LINE</code>,
|
|
* <code>AFTER_LAST_LINE</code>, <code>BEFORE_LINE_BEGINS</code> and
|
|
* <code>AFTER_LINE_ENDS</code>. These are equivalent to
|
|
* <code>PAGE_START</code>, <code>PAGE_END</code>, <code>LINE_START</code>
|
|
* and <code>LINE_END</code> respectively. For
|
|
* consistency with the relative positioning constants used by other
|
|
* components, the latter constants are preferred.
|
|
* <p>
|
|
* Mixing both absolute and relative positioning constants can lead to
|
|
* unpredictable results. If
|
|
* you use both types, the relative constants will take precedence.
|
|
* For example, if you add components using both the <code>NORTH</code>
|
|
* and <code>PAGE_START</code> constants in a container whose
|
|
* orientation is <code>LEFT_TO_RIGHT</code>, only the
|
|
* <code>PAGE_START</code> will be layed out.
|
|
* <p>
|
|
* NOTE: Currently (in the Java 2 platform v1.2),
|
|
* <code>BorderLayout</code> does not support vertical
|
|
* orientations. The <code>isVertical</code> setting on the container's
|
|
* <code>ComponentOrientation</code> is not respected.
|
|
* <p>
|
|
* The components are laid out according to their
|
|
* preferred sizes and the constraints of the container's size.
|
|
* The <code>NORTH</code> and <code>SOUTH</code> components may
|
|
* be stretched horizontally; the <code>EAST</code> and
|
|
* <code>WEST</code> components may be stretched vertically;
|
|
* the <code>CENTER</code> component may stretch both horizontally
|
|
* and vertically to fill any space left over.
|
|
* <p>
|
|
* Here is an example of five buttons in an applet laid out using
|
|
* the <code>BorderLayout</code> layout manager:
|
|
* <p>
|
|
* <img src="doc-files/BorderLayout-1.gif"
|
|
* alt="Diagram of an applet demonstrating BorderLayout.
|
|
* Each section of the BorderLayout contains a Button corresponding to its position in the layout, one of:
|
|
* North, West, Center, East, or South."
|
|
* style="float:center; margin: 7px 10px;">
|
|
* <p>
|
|
* The code for this applet is as follows:
|
|
*
|
|
* <hr><blockquote><pre>
|
|
* import java.awt.*;
|
|
* import java.applet.Applet;
|
|
*
|
|
* public class buttonDir extends Applet {
|
|
* public void init() {
|
|
* setLayout(new BorderLayout());
|
|
* add(new Button("North"), BorderLayout.NORTH);
|
|
* add(new Button("South"), BorderLayout.SOUTH);
|
|
* add(new Button("East"), BorderLayout.EAST);
|
|
* add(new Button("West"), BorderLayout.WEST);
|
|
* add(new Button("Center"), BorderLayout.CENTER);
|
|
* }
|
|
* }
|
|
* </pre></blockquote><hr>
|
|
* <p>
|
|
* @author Arthur van Hoff
|
|
* @see java.awt.Container#add(String, Component)
|
|
* @see java.awt.ComponentOrientation
|
|
* @since JDK1.0
|
|
*/
|
|
public class BorderLayout implements LayoutManager2,
|
|
java.io.Serializable {
|
|
/**
|
|
* Constructs a border layout with the horizontal gaps
|
|
* between components.
|
|
* The horizontal gap is specified by <code>hgap</code>.
|
|
*
|
|
* @see #getHgap()
|
|
* @see #setHgap(int)
|
|
*
|
|
* @serial
|
|
*/
|
|
int hgap;
|
|
|
|
/**
|
|
* Constructs a border layout with the vertical gaps
|
|
* between components.
|
|
* The vertical gap is specified by <code>vgap</code>.
|
|
*
|
|
* @see #getVgap()
|
|
* @see #setVgap(int)
|
|
* @serial
|
|
*/
|
|
int vgap;
|
|
|
|
/**
|
|
* Constant to specify components location to be the
|
|
* north portion of the border layout.
|
|
* @serial
|
|
* @see #getChild(String, boolean)
|
|
* @see #addLayoutComponent
|
|
* @see #getLayoutAlignmentX
|
|
* @see #getLayoutAlignmentY
|
|
* @see #removeLayoutComponent
|
|
*/
|
|
Component north;
|
|
/**
|
|
* Constant to specify components location to be the
|
|
* west portion of the border layout.
|
|
* @serial
|
|
* @see #getChild(String, boolean)
|
|
* @see #addLayoutComponent
|
|
* @see #getLayoutAlignmentX
|
|
* @see #getLayoutAlignmentY
|
|
* @see #removeLayoutComponent
|
|
*/
|
|
Component west;
|
|
/**
|
|
* Constant to specify components location to be the
|
|
* east portion of the border layout.
|
|
* @serial
|
|
* @see #getChild(String, boolean)
|
|
* @see #addLayoutComponent
|
|
* @see #getLayoutAlignmentX
|
|
* @see #getLayoutAlignmentY
|
|
* @see #removeLayoutComponent
|
|
*/
|
|
Component east;
|
|
/**
|
|
* Constant to specify components location to be the
|
|
* south portion of the border layout.
|
|
* @serial
|
|
* @see #getChild(String, boolean)
|
|
* @see #addLayoutComponent
|
|
* @see #getLayoutAlignmentX
|
|
* @see #getLayoutAlignmentY
|
|
* @see #removeLayoutComponent
|
|
*/
|
|
Component south;
|
|
/**
|
|
* Constant to specify components location to be the
|
|
* center portion of the border layout.
|
|
* @serial
|
|
* @see #getChild(String, boolean)
|
|
* @see #addLayoutComponent
|
|
* @see #getLayoutAlignmentX
|
|
* @see #getLayoutAlignmentY
|
|
* @see #removeLayoutComponent
|
|
*/
|
|
Component center;
|
|
|
|
/**
|
|
*
|
|
* A relative positioning constant, that can be used instead of
|
|
* north, south, east, west or center.
|
|
* mixing the two types of constants can lead to unpredictable results. If
|
|
* you use both types, the relative constants will take precedence.
|
|
* For example, if you add components using both the <code>NORTH</code>
|
|
* and <code>BEFORE_FIRST_LINE</code> constants in a container whose
|
|
* orientation is <code>LEFT_TO_RIGHT</code>, only the
|
|
* <code>BEFORE_FIRST_LINE</code> will be layed out.
|
|
* This will be the same for lastLine, firstItem, lastItem.
|
|
* @serial
|
|
*/
|
|
Component firstLine;
|
|
/**
|
|
* A relative positioning constant, that can be used instead of
|
|
* north, south, east, west or center.
|
|
* Please read Description for firstLine.
|
|
* @serial
|
|
*/
|
|
Component lastLine;
|
|
/**
|
|
* A relative positioning constant, that can be used instead of
|
|
* north, south, east, west or center.
|
|
* Please read Description for firstLine.
|
|
* @serial
|
|
*/
|
|
Component firstItem;
|
|
/**
|
|
* A relative positioning constant, that can be used instead of
|
|
* north, south, east, west or center.
|
|
* Please read Description for firstLine.
|
|
* @serial
|
|
*/
|
|
Component lastItem;
|
|
|
|
/**
|
|
* The north layout constraint (top of container).
|
|
*/
|
|
public static final String NORTH = "North";
|
|
|
|
/**
|
|
* The south layout constraint (bottom of container).
|
|
*/
|
|
public static final String SOUTH = "South";
|
|
|
|
/**
|
|
* The east layout constraint (right side of container).
|
|
*/
|
|
public static final String EAST = "East";
|
|
|
|
/**
|
|
* The west layout constraint (left side of container).
|
|
*/
|
|
public static final String WEST = "West";
|
|
|
|
/**
|
|
* The center layout constraint (middle of container).
|
|
*/
|
|
public static final String CENTER = "Center";
|
|
|
|
/**
|
|
* Synonym for PAGE_START. Exists for compatibility with previous
|
|
* versions. PAGE_START is preferred.
|
|
*
|
|
* @see #PAGE_START
|
|
* @since 1.2
|
|
*/
|
|
public static final String BEFORE_FIRST_LINE = "First";
|
|
|
|
/**
|
|
* Synonym for PAGE_END. Exists for compatibility with previous
|
|
* versions. PAGE_END is preferred.
|
|
*
|
|
* @see #PAGE_END
|
|
* @since 1.2
|
|
*/
|
|
public static final String AFTER_LAST_LINE = "Last";
|
|
|
|
/**
|
|
* Synonym for LINE_START. Exists for compatibility with previous
|
|
* versions. LINE_START is preferred.
|
|
*
|
|
* @see #LINE_START
|
|
* @since 1.2
|
|
*/
|
|
public static final String BEFORE_LINE_BEGINS = "Before";
|
|
|
|
/**
|
|
* Synonym for LINE_END. Exists for compatibility with previous
|
|
* versions. LINE_END is preferred.
|
|
*
|
|
* @see #LINE_END
|
|
* @since 1.2
|
|
*/
|
|
public static final String AFTER_LINE_ENDS = "After";
|
|
|
|
/**
|
|
* The component comes before the first line of the layout's content.
|
|
* For Western, left-to-right and top-to-bottom orientations, this is
|
|
* equivalent to NORTH.
|
|
*
|
|
* @see java.awt.Component#getComponentOrientation
|
|
* @since 1.4
|
|
*/
|
|
public static final String PAGE_START = BEFORE_FIRST_LINE;
|
|
|
|
/**
|
|
* The component comes after the last line of the layout's content.
|
|
* For Western, left-to-right and top-to-bottom orientations, this is
|
|
* equivalent to SOUTH.
|
|
*
|
|
* @see java.awt.Component#getComponentOrientation
|
|
* @since 1.4
|
|
*/
|
|
public static final String PAGE_END = AFTER_LAST_LINE;
|
|
|
|
/**
|
|
* The component goes at the beginning of the line direction for the
|
|
* layout. For Western, left-to-right and top-to-bottom orientations,
|
|
* this is equivalent to WEST.
|
|
*
|
|
* @see java.awt.Component#getComponentOrientation
|
|
* @since 1.4
|
|
*/
|
|
public static final String LINE_START = BEFORE_LINE_BEGINS;
|
|
|
|
/**
|
|
* The component goes at the end of the line direction for the
|
|
* layout. For Western, left-to-right and top-to-bottom orientations,
|
|
* this is equivalent to EAST.
|
|
*
|
|
* @see java.awt.Component#getComponentOrientation
|
|
* @since 1.4
|
|
*/
|
|
public static final String LINE_END = AFTER_LINE_ENDS;
|
|
|
|
/*
|
|
* JDK 1.1 serialVersionUID
|
|
*/
|
|
private static final long serialVersionUID = -8658291919501921765L;
|
|
|
|
/**
|
|
* Constructs a new border layout with
|
|
* no gaps between components.
|
|
*/
|
|
public BorderLayout() {
|
|
this(0, 0);
|
|
}
|
|
|
|
/**
|
|
* Constructs a border layout with the specified gaps
|
|
* between components.
|
|
* The horizontal gap is specified by <code>hgap</code>
|
|
* and the vertical gap is specified by <code>vgap</code>.
|
|
* @param hgap the horizontal gap.
|
|
* @param vgap the vertical gap.
|
|
*/
|
|
public BorderLayout(int hgap, int vgap) {
|
|
this.hgap = hgap;
|
|
this.vgap = vgap;
|
|
}
|
|
|
|
/**
|
|
* Returns the horizontal gap between components.
|
|
* @since JDK1.1
|
|
*/
|
|
public int getHgap() {
|
|
return hgap;
|
|
}
|
|
|
|
/**
|
|
* Sets the horizontal gap between components.
|
|
* @param hgap the horizontal gap between components
|
|
* @since JDK1.1
|
|
*/
|
|
public void setHgap(int hgap) {
|
|
this.hgap = hgap;
|
|
}
|
|
|
|
/**
|
|
* Returns the vertical gap between components.
|
|
* @since JDK1.1
|
|
*/
|
|
public int getVgap() {
|
|
return vgap;
|
|
}
|
|
|
|
/**
|
|
* Sets the vertical gap between components.
|
|
* @param vgap the vertical gap between components
|
|
* @since JDK1.1
|
|
*/
|
|
public void setVgap(int vgap) {
|
|
this.vgap = vgap;
|
|
}
|
|
|
|
/**
|
|
* Adds the specified component to the layout, using the specified
|
|
* constraint object. For border layouts, the constraint must be
|
|
* one of the following constants: <code>NORTH</code>,
|
|
* <code>SOUTH</code>, <code>EAST</code>,
|
|
* <code>WEST</code>, or <code>CENTER</code>.
|
|
* <p>
|
|
* Most applications do not call this method directly. This method
|
|
* is called when a component is added to a container using the
|
|
* <code>Container.add</code> method with the same argument types.
|
|
* @param comp the component to be added.
|
|
* @param constraints an object that specifies how and where
|
|
* the component is added to the layout.
|
|
* @see java.awt.Container#add(java.awt.Component, java.lang.Object)
|
|
* @exception IllegalArgumentException if the constraint object is not
|
|
* a string, or if it not one of the five specified
|
|
* constants.
|
|
* @since JDK1.1
|
|
*/
|
|
public void addLayoutComponent(Component comp, Object constraints) {
|
|
synchronized (comp.getTreeLock()) {
|
|
if ((constraints == null) || (constraints instanceof String)) {
|
|
addLayoutComponent((String)constraints, comp);
|
|
} else {
|
|
throw new IllegalArgumentException("cannot add to layout: constraint must be a string (or null)");
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @deprecated replaced by <code>addLayoutComponent(Component, Object)</code>.
|
|
*/
|
|
@Deprecated
|
|
public void addLayoutComponent(String name, Component comp) {
|
|
synchronized (comp.getTreeLock()) {
|
|
/* Special case: treat null the same as "Center". */
|
|
if (name == null) {
|
|
name = "Center";
|
|
}
|
|
|
|
/* Assign the component to one of the known regions of the layout.
|
|
*/
|
|
if ("Center".equals(name)) {
|
|
center = comp;
|
|
} else if ("North".equals(name)) {
|
|
north = comp;
|
|
} else if ("South".equals(name)) {
|
|
south = comp;
|
|
} else if ("East".equals(name)) {
|
|
east = comp;
|
|
} else if ("West".equals(name)) {
|
|
west = comp;
|
|
} else if (BEFORE_FIRST_LINE.equals(name)) {
|
|
firstLine = comp;
|
|
} else if (AFTER_LAST_LINE.equals(name)) {
|
|
lastLine = comp;
|
|
} else if (BEFORE_LINE_BEGINS.equals(name)) {
|
|
firstItem = comp;
|
|
} else if (AFTER_LINE_ENDS.equals(name)) {
|
|
lastItem = comp;
|
|
} else {
|
|
throw new IllegalArgumentException("cannot add to layout: unknown constraint: " + name);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes the specified component from this border layout. This
|
|
* method is called when a container calls its <code>remove</code> or
|
|
* <code>removeAll</code> methods. Most applications do not call this
|
|
* method directly.
|
|
* @param comp the component to be removed.
|
|
* @see java.awt.Container#remove(java.awt.Component)
|
|
* @see java.awt.Container#removeAll()
|
|
*/
|
|
public void removeLayoutComponent(Component comp) {
|
|
synchronized (comp.getTreeLock()) {
|
|
if (comp == center) {
|
|
center = null;
|
|
} else if (comp == north) {
|
|
north = null;
|
|
} else if (comp == south) {
|
|
south = null;
|
|
} else if (comp == east) {
|
|
east = null;
|
|
} else if (comp == west) {
|
|
west = null;
|
|
}
|
|
if (comp == firstLine) {
|
|
firstLine = null;
|
|
} else if (comp == lastLine) {
|
|
lastLine = null;
|
|
} else if (comp == firstItem) {
|
|
firstItem = null;
|
|
} else if (comp == lastItem) {
|
|
lastItem = null;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets the component that was added using the given constraint
|
|
*
|
|
* @param constraints the desired constraint, one of <code>CENTER</code>,
|
|
* <code>NORTH</code>, <code>SOUTH</code>,
|
|
* <code>WEST</code>, <code>EAST</code>,
|
|
* <code>PAGE_START</code>, <code>PAGE_END</code>,
|
|
* <code>LINE_START</code>, <code>LINE_END</code>
|
|
* @return the component at the given location, or <code>null</code> if
|
|
* the location is empty
|
|
* @exception IllegalArgumentException if the constraint object is
|
|
* not one of the nine specified constants
|
|
* @see #addLayoutComponent(java.awt.Component, java.lang.Object)
|
|
* @since 1.5
|
|
*/
|
|
public Component getLayoutComponent(Object constraints) {
|
|
if (CENTER.equals(constraints)) {
|
|
return center;
|
|
} else if (NORTH.equals(constraints)) {
|
|
return north;
|
|
} else if (SOUTH.equals(constraints)) {
|
|
return south;
|
|
} else if (WEST.equals(constraints)) {
|
|
return west;
|
|
} else if (EAST.equals(constraints)) {
|
|
return east;
|
|
} else if (PAGE_START.equals(constraints)) {
|
|
return firstLine;
|
|
} else if (PAGE_END.equals(constraints)) {
|
|
return lastLine;
|
|
} else if (LINE_START.equals(constraints)) {
|
|
return firstItem;
|
|
} else if (LINE_END.equals(constraints)) {
|
|
return lastItem;
|
|
} else {
|
|
throw new IllegalArgumentException("cannot get component: unknown constraint: " + constraints);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the component that corresponds to the given constraint location
|
|
* based on the target <code>Container</code>'s component orientation.
|
|
* Components added with the relative constraints <code>PAGE_START</code>,
|
|
* <code>PAGE_END</code>, <code>LINE_START</code>, and <code>LINE_END</code>
|
|
* take precedence over components added with the explicit constraints
|
|
* <code>NORTH</code>, <code>SOUTH</code>, <code>WEST</code>, and <code>EAST</code>.
|
|
* The <code>Container</code>'s component orientation is used to determine the location of components
|
|
* added with <code>LINE_START</code> and <code>LINE_END</code>.
|
|
*
|
|
* @param constraints the desired absolute position, one of <code>CENTER</code>,
|
|
* <code>NORTH</code>, <code>SOUTH</code>,
|
|
* <code>EAST</code>, <code>WEST</code>
|
|
* @param target the {@code Container} used to obtain
|
|
* the constraint location based on the target
|
|
* {@code Container}'s component orientation.
|
|
* @return the component at the given location, or <code>null</code> if
|
|
* the location is empty
|
|
* @exception IllegalArgumentException if the constraint object is
|
|
* not one of the five specified constants
|
|
* @exception NullPointerException if the target parameter is null
|
|
* @see #addLayoutComponent(java.awt.Component, java.lang.Object)
|
|
* @since 1.5
|
|
*/
|
|
public Component getLayoutComponent(Container target, Object constraints) {
|
|
boolean ltr = target.getComponentOrientation().isLeftToRight();
|
|
Component result = null;
|
|
|
|
if (NORTH.equals(constraints)) {
|
|
result = (firstLine != null) ? firstLine : north;
|
|
} else if (SOUTH.equals(constraints)) {
|
|
result = (lastLine != null) ? lastLine : south;
|
|
} else if (WEST.equals(constraints)) {
|
|
result = ltr ? firstItem : lastItem;
|
|
if (result == null) {
|
|
result = west;
|
|
}
|
|
} else if (EAST.equals(constraints)) {
|
|
result = ltr ? lastItem : firstItem;
|
|
if (result == null) {
|
|
result = east;
|
|
}
|
|
} else if (CENTER.equals(constraints)) {
|
|
result = center;
|
|
} else {
|
|
throw new IllegalArgumentException("cannot get component: invalid constraint: " + constraints);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Gets the constraints for the specified component
|
|
*
|
|
* @param comp the component to be queried
|
|
* @return the constraint for the specified component,
|
|
* or null if component is null or is not present
|
|
* in this layout
|
|
* @see #addLayoutComponent(java.awt.Component, java.lang.Object)
|
|
* @since 1.5
|
|
*/
|
|
public Object getConstraints(Component comp) {
|
|
//fix for 6242148 : API method java.awt.BorderLayout.getConstraints(null) should return null
|
|
if (comp == null){
|
|
return null;
|
|
}
|
|
if (comp == center) {
|
|
return CENTER;
|
|
} else if (comp == north) {
|
|
return NORTH;
|
|
} else if (comp == south) {
|
|
return SOUTH;
|
|
} else if (comp == west) {
|
|
return WEST;
|
|
} else if (comp == east) {
|
|
return EAST;
|
|
} else if (comp == firstLine) {
|
|
return PAGE_START;
|
|
} else if (comp == lastLine) {
|
|
return PAGE_END;
|
|
} else if (comp == firstItem) {
|
|
return LINE_START;
|
|
} else if (comp == lastItem) {
|
|
return LINE_END;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Determines the minimum size of the <code>target</code> container
|
|
* using this layout manager.
|
|
* <p>
|
|
* This method is called when a container calls its
|
|
* <code>getMinimumSize</code> method. Most applications do not call
|
|
* this method directly.
|
|
* @param target the container in which to do the layout.
|
|
* @return the minimum dimensions needed to lay out the subcomponents
|
|
* of the specified container.
|
|
* @see java.awt.Container
|
|
* @see java.awt.BorderLayout#preferredLayoutSize
|
|
* @see java.awt.Container#getMinimumSize()
|
|
*/
|
|
public Dimension minimumLayoutSize(Container target) {
|
|
synchronized (target.getTreeLock()) {
|
|
Dimension dim = new Dimension(0, 0);
|
|
|
|
boolean ltr = target.getComponentOrientation().isLeftToRight();
|
|
Component c = null;
|
|
|
|
if ((c=getChild(EAST,ltr)) != null) {
|
|
Dimension d = c.getMinimumSize();
|
|
dim.width += d.width + hgap;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(WEST,ltr)) != null) {
|
|
Dimension d = c.getMinimumSize();
|
|
dim.width += d.width + hgap;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(CENTER,ltr)) != null) {
|
|
Dimension d = c.getMinimumSize();
|
|
dim.width += d.width;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(NORTH,ltr)) != null) {
|
|
Dimension d = c.getMinimumSize();
|
|
dim.width = Math.max(d.width, dim.width);
|
|
dim.height += d.height + vgap;
|
|
}
|
|
if ((c=getChild(SOUTH,ltr)) != null) {
|
|
Dimension d = c.getMinimumSize();
|
|
dim.width = Math.max(d.width, dim.width);
|
|
dim.height += d.height + vgap;
|
|
}
|
|
|
|
Insets insets = target.getInsets();
|
|
dim.width += insets.left + insets.right;
|
|
dim.height += insets.top + insets.bottom;
|
|
|
|
return dim;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determines the preferred size of the <code>target</code>
|
|
* container using this layout manager, based on the components
|
|
* in the container.
|
|
* <p>
|
|
* Most applications do not call this method directly. This method
|
|
* is called when a container calls its <code>getPreferredSize</code>
|
|
* method.
|
|
* @param target the container in which to do the layout.
|
|
* @return the preferred dimensions to lay out the subcomponents
|
|
* of the specified container.
|
|
* @see java.awt.Container
|
|
* @see java.awt.BorderLayout#minimumLayoutSize
|
|
* @see java.awt.Container#getPreferredSize()
|
|
*/
|
|
public Dimension preferredLayoutSize(Container target) {
|
|
synchronized (target.getTreeLock()) {
|
|
Dimension dim = new Dimension(0, 0);
|
|
|
|
boolean ltr = target.getComponentOrientation().isLeftToRight();
|
|
Component c = null;
|
|
|
|
if ((c=getChild(EAST,ltr)) != null) {
|
|
Dimension d = c.getPreferredSize();
|
|
dim.width += d.width + hgap;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(WEST,ltr)) != null) {
|
|
Dimension d = c.getPreferredSize();
|
|
dim.width += d.width + hgap;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(CENTER,ltr)) != null) {
|
|
Dimension d = c.getPreferredSize();
|
|
dim.width += d.width;
|
|
dim.height = Math.max(d.height, dim.height);
|
|
}
|
|
if ((c=getChild(NORTH,ltr)) != null) {
|
|
Dimension d = c.getPreferredSize();
|
|
dim.width = Math.max(d.width, dim.width);
|
|
dim.height += d.height + vgap;
|
|
}
|
|
if ((c=getChild(SOUTH,ltr)) != null) {
|
|
Dimension d = c.getPreferredSize();
|
|
dim.width = Math.max(d.width, dim.width);
|
|
dim.height += d.height + vgap;
|
|
}
|
|
|
|
Insets insets = target.getInsets();
|
|
dim.width += insets.left + insets.right;
|
|
dim.height += insets.top + insets.bottom;
|
|
|
|
return dim;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the maximum dimensions for this layout given the components
|
|
* in the specified target container.
|
|
* @param target the component which needs to be laid out
|
|
* @see Container
|
|
* @see #minimumLayoutSize
|
|
* @see #preferredLayoutSize
|
|
*/
|
|
public Dimension maximumLayoutSize(Container target) {
|
|
return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment along the x axis. This specifies how
|
|
* the component would like to be aligned relative to other
|
|
* components. The value should be a number between 0 and 1
|
|
* where 0 represents alignment along the origin, 1 is aligned
|
|
* the furthest away from the origin, 0.5 is centered, etc.
|
|
*/
|
|
public float getLayoutAlignmentX(Container parent) {
|
|
return 0.5f;
|
|
}
|
|
|
|
/**
|
|
* Returns the alignment along the y axis. This specifies how
|
|
* the component would like to be aligned relative to other
|
|
* components. The value should be a number between 0 and 1
|
|
* where 0 represents alignment along the origin, 1 is aligned
|
|
* the furthest away from the origin, 0.5 is centered, etc.
|
|
*/
|
|
public float getLayoutAlignmentY(Container parent) {
|
|
return 0.5f;
|
|
}
|
|
|
|
/**
|
|
* Invalidates the layout, indicating that if the layout manager
|
|
* has cached information it should be discarded.
|
|
*/
|
|
public void invalidateLayout(Container target) {
|
|
}
|
|
|
|
/**
|
|
* Lays out the container argument using this border layout.
|
|
* <p>
|
|
* This method actually reshapes the components in the specified
|
|
* container in order to satisfy the constraints of this
|
|
* <code>BorderLayout</code> object. The <code>NORTH</code>
|
|
* and <code>SOUTH</code> components, if any, are placed at
|
|
* the top and bottom of the container, respectively. The
|
|
* <code>WEST</code> and <code>EAST</code> components are
|
|
* then placed on the left and right, respectively. Finally,
|
|
* the <code>CENTER</code> object is placed in any remaining
|
|
* space in the middle.
|
|
* <p>
|
|
* Most applications do not call this method directly. This method
|
|
* is called when a container calls its <code>doLayout</code> method.
|
|
* @param target the container in which to do the layout.
|
|
* @see java.awt.Container
|
|
* @see java.awt.Container#doLayout()
|
|
*/
|
|
public void layoutContainer(Container target) {
|
|
synchronized (target.getTreeLock()) {
|
|
Insets insets = target.getInsets();
|
|
int top = insets.top;
|
|
int bottom = target.height - insets.bottom;
|
|
int left = insets.left;
|
|
int right = target.width - insets.right;
|
|
|
|
boolean ltr = target.getComponentOrientation().isLeftToRight();
|
|
Component c = null;
|
|
|
|
if ((c=getChild(NORTH,ltr)) != null) {
|
|
c.setSize(right - left, c.height);
|
|
Dimension d = c.getPreferredSize();
|
|
c.setBounds(left, top, right - left, d.height);
|
|
top += d.height + vgap;
|
|
}
|
|
if ((c=getChild(SOUTH,ltr)) != null) {
|
|
c.setSize(right - left, c.height);
|
|
Dimension d = c.getPreferredSize();
|
|
c.setBounds(left, bottom - d.height, right - left, d.height);
|
|
bottom -= d.height + vgap;
|
|
}
|
|
if ((c=getChild(EAST,ltr)) != null) {
|
|
c.setSize(c.width, bottom - top);
|
|
Dimension d = c.getPreferredSize();
|
|
c.setBounds(right - d.width, top, d.width, bottom - top);
|
|
right -= d.width + hgap;
|
|
}
|
|
if ((c=getChild(WEST,ltr)) != null) {
|
|
c.setSize(c.width, bottom - top);
|
|
Dimension d = c.getPreferredSize();
|
|
c.setBounds(left, top, d.width, bottom - top);
|
|
left += d.width + hgap;
|
|
}
|
|
if ((c=getChild(CENTER,ltr)) != null) {
|
|
c.setBounds(left, top, right - left, bottom - top);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get the component that corresponds to the given constraint location
|
|
*
|
|
* @param key The desired absolute position,
|
|
* either NORTH, SOUTH, EAST, or WEST.
|
|
* @param ltr Is the component line direction left-to-right?
|
|
*/
|
|
private Component getChild(String key, boolean ltr) {
|
|
Component result = null;
|
|
|
|
if (key == NORTH) {
|
|
result = (firstLine != null) ? firstLine : north;
|
|
}
|
|
else if (key == SOUTH) {
|
|
result = (lastLine != null) ? lastLine : south;
|
|
}
|
|
else if (key == WEST) {
|
|
result = ltr ? firstItem : lastItem;
|
|
if (result == null) {
|
|
result = west;
|
|
}
|
|
}
|
|
else if (key == EAST) {
|
|
result = ltr ? lastItem : firstItem;
|
|
if (result == null) {
|
|
result = east;
|
|
}
|
|
}
|
|
else if (key == CENTER) {
|
|
result = center;
|
|
}
|
|
if (result != null && !result.visible) {
|
|
result = null;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of the state of this border layout.
|
|
* @return a string representation of this border layout.
|
|
*/
|
|
public String toString() {
|
|
return getClass().getName() + "[hgap=" + hgap + ",vgap=" + vgap + "]";
|
|
}
|
|
}
|