/*
* 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;
import java.util.
Arrays;
/**
* The <code>GridBagLayout</code> class is a flexible layout
* manager that aligns components vertically, horizontally or along their
* baseline without requiring that the components be of the same size.
* Each <code>GridBagLayout</code> object maintains a dynamic,
* rectangular grid of cells, with each component occupying
* one or more cells, called its <em>display area</em>.
* <p>
* Each component managed by a <code>GridBagLayout</code> is associated with
* an instance of {@link GridBagConstraints}. The constraints object
* specifies where a component's display area should be located on the grid
* and how the component should be positioned within its display area. In
* addition to its constraints object, the <code>GridBagLayout</code> also
* considers each component's minimum and preferred sizes in order to
* determine a component's size.
* <p>
* The overall orientation of the grid depends on the container's
* {@link ComponentOrientation} property. For horizontal left-to-right
* orientations, grid coordinate (0,0) is in the upper left corner of the
* container with x increasing to the right and y increasing downward. For
* horizontal right-to-left orientations, grid coordinate (0,0) is in the upper
* right corner of the container with x increasing to the left and y
* increasing downward.
* <p>
* To use a grid bag layout effectively, you must customize one or more
* of the <code>GridBagConstraints</code> objects that are associated
* with its components. You customize a <code>GridBagConstraints</code>
* object by setting one or more of its instance variables:
*
* <dl>
* <dt>{@link GridBagConstraints#gridx},
* {@link GridBagConstraints#gridy}
* <dd>Specifies the cell containing the leading corner of the component's
* display area, where the cell at the origin of the grid has address
* <code>gridx = 0</code>,
* <code>gridy = 0</code>. For horizontal left-to-right layout,
* a component's leading corner is its upper left. For horizontal
* right-to-left layout, a component's leading corner is its upper right.
* Use <code>GridBagConstraints.RELATIVE</code> (the default value)
* to specify that the component be placed immediately following
* (along the x axis for <code>gridx</code> or the y axis for
* <code>gridy</code>) the component that was added to the container
* just before this component was added.
* <dt>{@link GridBagConstraints#gridwidth},
* {@link GridBagConstraints#gridheight}
* <dd>Specifies the number of cells in a row (for <code>gridwidth</code>)
* or column (for <code>gridheight</code>)
* in the component's display area.
* The default value is 1.
* Use <code>GridBagConstraints.REMAINDER</code> to specify
* that the component's display area will be from <code>gridx</code>
* to the last cell in the row (for <code>gridwidth</code>)
* or from <code>gridy</code> to the last cell in the column
* (for <code>gridheight</code>).
*
* Use <code>GridBagConstraints.RELATIVE</code> to specify
* that the component's display area will be from <code>gridx</code>
* to the next to the last cell in its row (for <code>gridwidth</code>
* or from <code>gridy</code> to the next to the last cell in its
* column (for <code>gridheight</code>).
*
* <dt>{@link GridBagConstraints#fill}
* <dd>Used when the component's display area
* is larger than the component's requested size
* to determine whether (and how) to resize the component.
* Possible values are
* <code>GridBagConstraints.NONE</code> (the default),
* <code>GridBagConstraints.HORIZONTAL</code>
* (make the component wide enough to fill its display area
* horizontally, but don't change its height),
* <code>GridBagConstraints.VERTICAL</code>
* (make the component tall enough to fill its display area
* vertically, but don't change its width), and
* <code>GridBagConstraints.BOTH</code>
* (make the component fill its display area entirely).
* <dt>{@link GridBagConstraints#ipadx},
* {@link GridBagConstraints#ipady}
* <dd>Specifies the component's internal padding within the layout,
* how much to add to the minimum size of the component.
* The width of the component will be at least its minimum width
* plus <code>ipadx</code> pixels. Similarly, the height of
* the component will be at least the minimum height plus
* <code>ipady</code> pixels.
* <dt>{@link GridBagConstraints#insets}
* <dd>Specifies the component's external padding, the minimum
* amount of space between the component and the edges of its display area.
* <dt>{@link GridBagConstraints#anchor}
* <dd>Specifies where the component should be positioned in its display area.
* There are three kinds of possible values: absolute, orientation-relative,
* and baseline-relative
* Orientation relative values are interpreted relative to the container's
* <code>ComponentOrientation</code> property while absolute values
* are not. Baseline relative values are calculated relative to the
* baseline. Valid values are:
*
* <center><table BORDER=0 WIDTH=800
* SUMMARY="absolute, relative and baseline values as described above">
* <tr>
* <th><P style="text-align:left">Absolute Values</th>
* <th><P style="text-align:left">Orientation Relative Values</th>
* <th><P style="text-align:left">Baseline Relative Values</th>
* </tr>
* <tr>
* <td>
* <ul style="list-style-type:none">
* <li><code>GridBagConstraints.NORTH</code></li>
* <li><code>GridBagConstraints.SOUTH</code></li>
* <li><code>GridBagConstraints.WEST</code></li>
* <li><code>GridBagConstraints.EAST</code></li>
* <li><code>GridBagConstraints.NORTHWEST</code></li>
* <li><code>GridBagConstraints.NORTHEAST</code></li>
* <li><code>GridBagConstraints.SOUTHWEST</code></li>
* <li><code>GridBagConstraints.SOUTHEAST</code></li>
* <li><code>GridBagConstraints.CENTER</code> (the default)</li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
* <li><code>GridBagConstraints.PAGE_START</code></li>
* <li><code>GridBagConstraints.PAGE_END</code></li>
* <li><code>GridBagConstraints.LINE_START</code></li>
* <li><code>GridBagConstraints.LINE_END</code></li>
* <li><code>GridBagConstraints.FIRST_LINE_START</code></li>
* <li><code>GridBagConstraints.FIRST_LINE_END</code></li>
* <li><code>GridBagConstraints.LAST_LINE_START</code></li>
* <li><code>GridBagConstraints.LAST_LINE_END</code></li>
* </ul>
* </td>
* <td>
* <ul style="list-style-type:none">
* <li><code>GridBagConstraints.BASELINE</code></li>
* <li><code>GridBagConstraints.BASELINE_LEADING</code></li>
* <li><code>GridBagConstraints.BASELINE_TRAILING</code></li>
* <li><code>GridBagConstraints.ABOVE_BASELINE</code></li>
* <li><code>GridBagConstraints.ABOVE_BASELINE_LEADING</code></li>
* <li><code>GridBagConstraints.ABOVE_BASELINE_TRAILING</code></li>
* <li><code>GridBagConstraints.BELOW_BASELINE</code></li>
* <li><code>GridBagConstraints.BELOW_BASELINE_LEADING</code></li>
* <li><code>GridBagConstraints.BELOW_BASELINE_TRAILING</code></li>
* </ul>
* </td>
* </tr>
* </table></center>
* <dt>{@link GridBagConstraints#weightx},
* {@link GridBagConstraints#weighty}
* <dd>Used to determine how to distribute space, which is
* important for specifying resizing behavior.
* Unless you specify a weight for at least one component
* in a row (<code>weightx</code>) and column (<code>weighty</code>),
* all the components clump together in the center of their container.
* This is because when the weight is zero (the default),
* the <code>GridBagLayout</code> object puts any extra space
* between its grid of cells and the edges of the container.
* </dl>
* <p>
* Each row may have a baseline; the baseline is determined by the
* components in that row that have a valid baseline and are aligned
* along the baseline (the component's anchor value is one of {@code
* BASELINE}, {@code BASELINE_LEADING} or {@code BASELINE_TRAILING}).
* If none of the components in the row has a valid baseline, the row
* does not have a baseline.
* <p>
* If a component spans rows it is aligned either to the baseline of
* the start row (if the baseline-resize behavior is {@code
* CONSTANT_ASCENT}) or the end row (if the baseline-resize behavior
* is {@code CONSTANT_DESCENT}). The row that the component is
* aligned to is called the <em>prevailing row</em>.
* <p>
* The following figure shows a baseline layout and includes a
* component that spans rows:
* <center><table summary="Baseline Layout">
* <tr ALIGN=CENTER>
* <td>
* <img src="doc-files/GridBagLayout-baseline.png"
* alt="The following text describes this graphic (Figure 1)." style="float:center">
* </td>
* </table></center>
* This layout consists of three components:
* <ul><li>A panel that starts in row 0 and ends in row 1. The panel
* has a baseline-resize behavior of <code>CONSTANT_DESCENT</code> and has
* an anchor of <code>BASELINE</code>. As the baseline-resize behavior
* is <code>CONSTANT_DESCENT</code> the prevailing row for the panel is
* row 1.
* <li>Two buttons, each with a baseline-resize behavior of
* <code>CENTER_OFFSET</code> and an anchor of <code>BASELINE</code>.
* </ul>
* Because the second button and the panel share the same prevailing row,
* they are both aligned along their baseline.
* <p>
* Components positioned using one of the baseline-relative values resize
* differently than when positioned using an absolute or orientation-relative
* value. How components change is dictated by how the baseline of the
* prevailing row changes. The baseline is anchored to the
* bottom of the display area if any components with the same prevailing row
* have a baseline-resize behavior of <code>CONSTANT_DESCENT</code>,
* otherwise the baseline is anchored to the top of the display area.
* The following rules dictate the resize behavior:
* <ul>
* <li>Resizable components positioned above the baseline can only
* grow as tall as the baseline. For example, if the baseline is at 100
* and anchored at the top, a resizable component positioned above the
* baseline can never grow more than 100 units.
* <li>Similarly, resizable components positioned below the baseline can
* only grow as high as the difference between the display height and the
* baseline.
* <li>Resizable components positioned on the baseline with a
* baseline-resize behavior of <code>OTHER</code> are only resized if
* the baseline at the resized size fits within the display area. If
* the baseline is such that it does not fit within the display area
* the component is not resized.
* <li>Components positioned on the baseline that do not have a
* baseline-resize behavior of <code>OTHER</code>
* can only grow as tall as {@code display height - baseline + baseline of component}.
* </ul>
* If you position a component along the baseline, but the
* component does not have a valid baseline, it will be vertically centered
* in its space. Similarly if you have positioned a component relative
* to the baseline and none of the components in the row have a valid
* baseline the component is vertically centered.
* <p>
* The following figures show ten components (all buttons)
* managed by a grid bag layout. Figure 2 shows the layout for a horizontal,
* left-to-right container and Figure 3 shows the layout for a horizontal,
* right-to-left container.
*
* <center><table WIDTH=600 summary="layout">
* <tr ALIGN=CENTER>
* <td>
* <img src="doc-files/GridBagLayout-1.gif" alt="The preceding text describes this graphic (Figure 1)." style="float:center; margin: 7px 10px;">
* </td>
* <td>
* <img src="doc-files/GridBagLayout-2.gif" alt="The preceding text describes this graphic (Figure 2)." style="float:center; margin: 7px 10px;">
* </td>
* <tr ALIGN=CENTER>
* <td>Figure 2: Horizontal, Left-to-Right</td>
* <td>Figure 3: Horizontal, Right-to-Left</td>
* </tr>
* </table></center>
* <p>
* Each of the ten components has the <code>fill</code> field
* of its associated <code>GridBagConstraints</code> object
* set to <code>GridBagConstraints.BOTH</code>.
* In addition, the components have the following non-default constraints:
*
* <ul>
* <li>Button1, Button2, Button3: <code>weightx = 1.0</code>
* <li>Button4: <code>weightx = 1.0</code>,
* <code>gridwidth = GridBagConstraints.REMAINDER</code>
* <li>Button5: <code>gridwidth = GridBagConstraints.REMAINDER</code>
* <li>Button6: <code>gridwidth = GridBagConstraints.RELATIVE</code>
* <li>Button7: <code>gridwidth = GridBagConstraints.REMAINDER</code>
* <li>Button8: <code>gridheight = 2</code>,
* <code>weighty = 1.0</code>
* <li>Button9, Button 10:
* <code>gridwidth = GridBagConstraints.REMAINDER</code>
* </ul>
* <p>
* Here is the code that implements the example shown above:
*
* <hr><blockquote><pre>
* import java.awt.*;
* import java.util.*;
* import java.applet.Applet;
*
* public class GridBagEx1 extends Applet {
*
* protected void makebutton(String name,
* GridBagLayout gridbag,
* GridBagConstraints c) {
* Button button = new Button(name);
* gridbag.setConstraints(button, c);
* add(button);
* }
*
* public void init() {
* GridBagLayout gridbag = new GridBagLayout();
* GridBagConstraints c = new GridBagConstraints();
*
* setFont(new Font("SansSerif", Font.PLAIN, 14));
* setLayout(gridbag);
*
* c.fill = GridBagConstraints.BOTH;
* c.weightx = 1.0;
* makebutton("Button1", gridbag, c);
* makebutton("Button2", gridbag, c);
* makebutton("Button3", gridbag, c);
*
* c.gridwidth = GridBagConstraints.REMAINDER; //end row
* makebutton("Button4", gridbag, c);
*
* c.weightx = 0.0; //reset to the default
* makebutton("Button5", gridbag, c); //another row
*
* c.gridwidth = GridBagConstraints.RELATIVE; //next-to-last in row
* makebutton("Button6", gridbag, c);
*
* c.gridwidth = GridBagConstraints.REMAINDER; //end row
* makebutton("Button7", gridbag, c);
*
* c.gridwidth = 1; //reset to the default
* c.gridheight = 2;
* c.weighty = 1.0;
* makebutton("Button8", gridbag, c);
*
* c.weighty = 0.0; //reset to the default
* c.gridwidth = GridBagConstraints.REMAINDER; //end row
* c.gridheight = 1; //reset to the default
* makebutton("Button9", gridbag, c);
* makebutton("Button10", gridbag, c);
*
* setSize(300, 100);
* }
*
* public static void main(String args[]) {
* Frame f = new Frame("GridBag Layout Example");
* GridBagEx1 ex1 = new GridBagEx1();
*
* ex1.init();
*
* f.add("Center", ex1);
* f.pack();
* f.setSize(f.getPreferredSize());
* f.show();
* }
* }
* </pre></blockquote><hr>
* <p>
* @author Doug Stein
* @author Bill Spitzak (orignial NeWS & OLIT implementation)
* @see java.awt.GridBagConstraints
* @see java.awt.GridBagLayoutInfo
* @see java.awt.ComponentOrientation
* @since JDK1.0
*/
public class
GridBagLayout implements
LayoutManager2,
java.io.
Serializable {
static final int
EMPIRICMULTIPLIER = 2;
/**
* This field is no longer used to reserve arrays and kept for backward
* compatibility. Previously, this was
* the maximum number of grid positions (both horizontal and
* vertical) that could be laid out by the grid bag layout.
* Current implementation doesn't impose any limits
* on the size of a grid.
*/
protected static final int
MAXGRIDSIZE = 512;
/**
* The smallest grid that can be laid out by the grid bag layout.
*/
protected static final int
MINSIZE = 1;
/**
* The preferred grid size that can be laid out by the grid bag layout.
*/
protected static final int
PREFERREDSIZE = 2;
/**
* This hashtable maintains the association between
* a component and its gridbag constraints.
* The Keys in <code>comptable</code> are the components and the
* values are the instances of <code>GridBagConstraints</code>.
*
* @serial
* @see java.awt.GridBagConstraints
*/
protected
Hashtable<
Component,
GridBagConstraints>
comptable;
/**
* This field holds a gridbag constraints instance
* containing the default values, so if a component
* does not have gridbag constraints associated with
* it, then the component will be assigned a
* copy of the <code>defaultConstraints</code>.
*
* @serial
* @see #getConstraints(Component)
* @see #setConstraints(Component, GridBagConstraints)
* @see #lookupConstraints(Component)
*/
protected
GridBagConstraints defaultConstraints;
/**
* This field holds the layout information
* for the gridbag. The information in this field
* is based on the most recent validation of the
* gridbag.
* If <code>layoutInfo</code> is <code>null</code>
* this indicates that there are no components in
* the gridbag or if there are components, they have
* not yet been validated.
*
* @serial
* @see #getLayoutInfo(Container, int)
*/
protected
GridBagLayoutInfo layoutInfo;
/**
* This field holds the overrides to the column minimum
* width. If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the minimum columns
* widths have been calculated.
* If columnWidths has more elements than the number of
* columns, columns are added to the gridbag to match
* the number of elements in columnWidth.
*
* @serial
* @see #getLayoutDimensions()
*/
public int
columnWidths[];
/**
* This field holds the overrides to the row minimum
* heights. If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the minimum row
* heights have been calculated.
* If <code>rowHeights</code> has more elements than the number of
* rows, rows are added to the gridbag to match
* the number of elements in <code>rowHeights</code>.
*
* @serial
* @see #getLayoutDimensions()
*/
public int
rowHeights[];
/**
* This field holds the overrides to the column weights.
* If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the columns
* weights have been calculated.
* If <code>columnWeights[i]</code> > weight for column i, then
* column i is assigned the weight in <code>columnWeights[i]</code>.
* If <code>columnWeights</code> has more elements than the number
* of columns, the excess elements are ignored - they do
* not cause more columns to be created.
*
* @serial
*/
public double
columnWeights[];
/**
* This field holds the overrides to the row weights.
* If this field is non-<code>null</code> the values are
* applied to the gridbag after all of the rows
* weights have been calculated.
* If <code>rowWeights[i]</code> > weight for row i, then
* row i is assigned the weight in <code>rowWeights[i]</code>.
* If <code>rowWeights</code> has more elements than the number
* of rows, the excess elements are ignored - they do
* not cause more rows to be created.
*
* @serial
*/
public double
rowWeights[];
/**
* The component being positioned. This is set before calling into
* <code>adjustForGravity</code>.
*/
private
Component componentAdjusting;
/**
* Creates a grid bag layout manager.
*/
public
GridBagLayout () {
comptable = new
Hashtable<
Component,
GridBagConstraints>();
defaultConstraints = new
GridBagConstraints();
}
/**
* Sets the constraints for the specified component in this layout.
* @param comp the component to be modified
* @param constraints the constraints to be applied
*/
public void
setConstraints(
Component comp,
GridBagConstraints constraints) {
comptable.
put(
comp, (
GridBagConstraints)
constraints.
clone());
}
/**
* Gets the constraints for the specified component. A copy of
* the actual <code>GridBagConstraints</code> object is returned.
* @param comp the component to be queried
* @return the constraint for the specified component in this
* grid bag layout; a copy of the actual constraint
* object is returned
*/
public
GridBagConstraints getConstraints(
Component comp) {
GridBagConstraints constraints =
comptable.
get(
comp);
if (
constraints == null) {
setConstraints(
comp,
defaultConstraints);
constraints =
comptable.
get(
comp);
}
return (
GridBagConstraints)
constraints.
clone();
}
/**
* Retrieves the constraints for the specified component.
* The return value is not a copy, but is the actual
* <code>GridBagConstraints</code> object used by the layout mechanism.
* <p>
* If <code>comp</code> is not in the <code>GridBagLayout</code>,
* a set of default <code>GridBagConstraints</code> are returned.
* A <code>comp</code> value of <code>null</code> is invalid
* and returns <code>null</code>.
*
* @param comp the component to be queried
* @return the constraints for the specified component
*/
protected
GridBagConstraints lookupConstraints(
Component comp) {
GridBagConstraints constraints =
comptable.
get(
comp);
if (
constraints == null) {
setConstraints(
comp,
defaultConstraints);
constraints =
comptable.
get(
comp);
}
return
constraints;
}
/**
* Removes the constraints for the specified component in this layout
* @param comp the component to be modified
*/
private void
removeConstraints(
Component comp) {
comptable.
remove(
comp);
}
/**
* Determines the origin of the layout area, in the graphics coordinate
* space of the target container. This value represents the pixel
* coordinates of the top-left corner of the layout area regardless of
* the <code>ComponentOrientation</code> value of the container. This
* is distinct from the grid origin given by the cell coordinates (0,0).
* Most applications do not call this method directly.
* @return the graphics origin of the cell in the top-left
* corner of the layout grid
* @see java.awt.ComponentOrientation
* @since JDK1.1
*/
public
Point getLayoutOrigin () {
Point origin = new
Point(0,0);
if (
layoutInfo != null) {
origin.
x =
layoutInfo.
startx;
origin.
y =
layoutInfo.
starty;
}
return
origin;
}
/**
* Determines column widths and row heights for the layout grid.
* <p>
* Most applications do not call this method directly.
* @return an array of two arrays, containing the widths
* of the layout columns and
* the heights of the layout rows
* @since JDK1.1
*/
public int [][]
getLayoutDimensions () {
if (
layoutInfo == null)
return new int[2][0];
int
dim[][] = new int [2][];
dim[0] = new int[
layoutInfo.
width];
dim[1] = new int[
layoutInfo.
height];
System.
arraycopy(
layoutInfo.
minWidth, 0,
dim[0], 0,
layoutInfo.
width);
System.
arraycopy(
layoutInfo.
minHeight, 0,
dim[1], 0,
layoutInfo.
height);
return
dim;
}
/**
* Determines the weights of the layout grid's columns and rows.
* Weights are used to calculate how much a given column or row
* stretches beyond its preferred size, if the layout has extra
* room to fill.
* <p>
* Most applications do not call this method directly.
* @return an array of two arrays, representing the
* horizontal weights of the layout columns
* and the vertical weights of the layout rows
* @since JDK1.1
*/
public double [][]
getLayoutWeights () {
if (
layoutInfo == null)
return new double[2][0];
double
weights[][] = new double [2][];
weights[0] = new double[
layoutInfo.
width];
weights[1] = new double[
layoutInfo.
height];
System.
arraycopy(
layoutInfo.
weightX, 0,
weights[0], 0,
layoutInfo.
width);
System.
arraycopy(
layoutInfo.
weightY, 0,
weights[1], 0,
layoutInfo.
height);
return
weights;
}
/**
* Determines which cell in the layout grid contains the point
* specified by <code>(x, y)</code>. Each cell is identified
* by its column index (ranging from 0 to the number of columns
* minus 1) and its row index (ranging from 0 to the number of
* rows minus 1).
* <p>
* If the <code>(x, y)</code> point lies
* outside the grid, the following rules are used.
* The column index is returned as zero if <code>x</code> lies to the
* left of the layout for a left-to-right container or to the right of
* the layout for a right-to-left container. The column index is returned
* as the number of columns if <code>x</code> lies
* to the right of the layout in a left-to-right container or to the left
* in a right-to-left container.
* The row index is returned as zero if <code>y</code> lies above the
* layout, and as the number of rows if <code>y</code> lies
* below the layout. The orientation of a container is determined by its
* <code>ComponentOrientation</code> property.
* @param x the <i>x</i> coordinate of a point
* @param y the <i>y</i> coordinate of a point
* @return an ordered pair of indexes that indicate which cell
* in the layout grid contains the point
* (<i>x</i>, <i>y</i>).
* @see java.awt.ComponentOrientation
* @since JDK1.1
*/
public
Point location(int
x, int
y) {
Point loc = new
Point(0,0);
int
i,
d;
if (
layoutInfo == null)
return
loc;
d =
layoutInfo.
startx;
if (!
rightToLeft) {
for (
i=0;
i<
layoutInfo.
width;
i++) {
d +=
layoutInfo.
minWidth[
i];
if (
d >
x)
break;
}
} else {
for (
i=
layoutInfo.
width-1;
i>=0;
i--) {
if (
d >
x)
break;
d +=
layoutInfo.
minWidth[
i];
}
i++;
}
loc.
x =
i;
d =
layoutInfo.
starty;
for (
i=0;
i<
layoutInfo.
height;
i++) {
d +=
layoutInfo.
minHeight[
i];
if (
d >
y)
break;
}
loc.
y =
i;
return
loc;
}
/**
* Has no effect, since this layout manager does not use a per-component string.
*/
public void
addLayoutComponent(
String name,
Component comp) {
}
/**
* Adds the specified component to the layout, using the specified
* <code>constraints</code> object. Note that constraints
* are mutable and are, therefore, cloned when cached.
*
* @param comp the component to be added
* @param constraints an object that determines how
* the component is added to the layout
* @exception IllegalArgumentException if <code>constraints</code>
* is not a <code>GridBagConstraint</code>
*/
public void
addLayoutComponent(
Component comp,
Object constraints) {
if (
constraints instanceof
GridBagConstraints) {
setConstraints(
comp, (
GridBagConstraints)
constraints);
} else if (
constraints != null) {
throw new
IllegalArgumentException("cannot add to layout: constraints must be a GridBagConstraint");
}
}
/**
* Removes the specified component from this layout.
* <p>
* 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) {
removeConstraints(
comp);
}
/**
* Determines the preferred size of the <code>parent</code>
* container using this grid bag layout.
* <p>
* Most applications do not call this method directly.
*
* @param parent the container in which to do the layout
* @see java.awt.Container#getPreferredSize
* @return the preferred size of the <code>parent</code>
* container
*/
public
Dimension preferredLayoutSize(
Container parent) {
GridBagLayoutInfo info =
getLayoutInfo(
parent,
PREFERREDSIZE);
return
getMinSize(
parent,
info);
}
/**
* Determines the minimum size of the <code>parent</code> container
* using this grid bag layout.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container#doLayout
* @return the minimum size of the <code>parent</code> container
*/
public
Dimension minimumLayoutSize(
Container parent) {
GridBagLayoutInfo info =
getLayoutInfo(
parent,
MINSIZE);
return
getMinSize(
parent,
info);
}
/**
* Returns the maximum dimensions for this layout given the components
* in the specified target container.
* @param target the container which needs to be laid out
* @see Container
* @see #minimumLayoutSize(Container)
* @see #preferredLayoutSize(Container)
* @return the maximum dimensions for this layout
*/
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.
* <p>
* @return the value <code>0.5f</code> to indicate centered
*/
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.
* <p>
* @return the value <code>0.5f</code> to indicate centered
*/
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 specified container using this grid bag layout.
* This method reshapes components in the specified container in
* order to satisfy the constraints of this <code>GridBagLayout</code>
* object.
* <p>
* Most applications do not call this method directly.
* @param parent the container in which to do the layout
* @see java.awt.Container
* @see java.awt.Container#doLayout
*/
public void
layoutContainer(
Container parent) {
arrangeGrid(
parent);
}
/**
* Returns a string representation of this grid bag layout's values.
* @return a string representation of this grid bag layout.
*/
public
String toString() {
return
getClass().
getName();
}
/**
* Print the layout information. Useful for debugging.
*/
/* DEBUG
*
* protected void dumpLayoutInfo(GridBagLayoutInfo s) {
* int x;
*
* System.out.println("Col\tWidth\tWeight");
* for (x=0; x<s.width; x++) {
* System.out.println(x + "\t" +
* s.minWidth[x] + "\t" +
* s.weightX[x]);
* }
* System.out.println("Row\tHeight\tWeight");
* for (x=0; x<s.height; x++) {
* System.out.println(x + "\t" +
* s.minHeight[x] + "\t" +
* s.weightY[x]);
* }
* }
*/
/**
* Print the layout constraints. Useful for debugging.
*/
/* DEBUG
*
* protected void dumpConstraints(GridBagConstraints constraints) {
* System.out.println(
* "wt " +
* constraints.weightx +
* " " +
* constraints.weighty +
* ", " +
*
* "box " +
* constraints.gridx +
* " " +
* constraints.gridy +
* " " +
* constraints.gridwidth +
* " " +
* constraints.gridheight +
* ", " +
*
* "min " +
* constraints.minWidth +
* " " +
* constraints.minHeight +
* ", " +
*
* "pad " +
* constraints.insets.bottom +
* " " +
* constraints.insets.left +
* " " +
* constraints.insets.right +
* " " +
* constraints.insets.top +
* " " +
* constraints.ipadx +
* " " +
* constraints.ipady);
* }
*/
/**
* Fills in an instance of <code>GridBagLayoutInfo</code> for the
* current set of managed children. This requires three passes through the
* set of children:
*
* <ol>
* <li>Figure out the dimensions of the layout grid.
* <li>Determine which cells the components occupy.
* <li>Distribute the weights and min sizes among the rows/columns.
* </ol>
*
* This also caches the minsizes for all the children when they are
* first encountered (so subsequent loops don't need to ask again).
* <p>
* This method should only be used internally by
* <code>GridBagLayout</code>.
*
* @param parent the layout container
* @param sizeflag either <code>PREFERREDSIZE</code> or
* <code>MINSIZE</code>
* @return the <code>GridBagLayoutInfo</code> for the set of children
* @since 1.4
*/
protected
GridBagLayoutInfo getLayoutInfo(
Container parent, int
sizeflag) {
return
GetLayoutInfo(
parent,
sizeflag);
}
/*
* Calculate maximum array sizes to allocate arrays without ensureCapacity
* we may use preCalculated sizes in whole class because of upper estimation of
* maximumArrayXIndex and maximumArrayYIndex.
*/
private long[]
preInitMaximumArraySizes(
Container parent){
Component components[] =
parent.
getComponents();
Component comp;
GridBagConstraints constraints;
int
curX,
curY;
int
curWidth,
curHeight;
int
preMaximumArrayXIndex = 0;
int
preMaximumArrayYIndex = 0;
long []
returnArray = new long[2];
for (int
compId = 0 ;
compId <
components.length ;
compId++) {
comp =
components[
compId];
if (!
comp.
isVisible()) {
continue;
}
constraints =
lookupConstraints(
comp);
curX =
constraints.
gridx;
curY =
constraints.
gridy;
curWidth =
constraints.
gridwidth;
curHeight =
constraints.
gridheight;
// -1==RELATIVE, means that column|row equals to previously added component,
// since each next Component with gridx|gridy == RELATIVE starts from
// previous position, so we should start from previous component which
// already used in maximumArray[X|Y]Index calculation. We could just increase
// maximum by 1 to handle situation when component with gridx=-1 was added.
if (
curX < 0){
curX = ++
preMaximumArrayYIndex;
}
if (
curY < 0){
curY = ++
preMaximumArrayXIndex;
}
// gridwidth|gridheight may be equal to RELATIVE (-1) or REMAINDER (0)
// in any case using 1 instead of 0 or -1 should be sufficient to for
// correct maximumArraySizes calculation
if (
curWidth <= 0){
curWidth = 1;
}
if (
curHeight <= 0){
curHeight = 1;
}
preMaximumArrayXIndex =
Math.
max(
curY +
curHeight,
preMaximumArrayXIndex);
preMaximumArrayYIndex =
Math.
max(
curX +
curWidth,
preMaximumArrayYIndex);
} //for (components) loop
// Must specify index++ to allocate well-working arrays.
/* fix for 4623196.
* now return long array instead of Point
*/
returnArray[0] =
preMaximumArrayXIndex;
returnArray[1] =
preMaximumArrayYIndex;
return
returnArray;
} //PreInitMaximumSizes
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #getLayoutInfo(java.awt.Container, int) getLayoutInfo} instead.
* This method is the same as <code>getLayoutInfo</code>;
* refer to <code>getLayoutInfo</code> for details on parameters
* and return value.
*/
protected
GridBagLayoutInfo GetLayoutInfo(
Container parent, int
sizeflag) {
synchronized (
parent.
getTreeLock()) {
GridBagLayoutInfo r;
Component comp;
GridBagConstraints constraints;
Dimension d;
Component components[] =
parent.
getComponents();
// Code below will address index curX+curWidth in the case of yMaxArray, weightY
// ( respectively curY+curHeight for xMaxArray, weightX ) where
// curX in 0 to preInitMaximumArraySizes.y
// Thus, the maximum index that could
// be calculated in the following code is curX+curX.
// EmpericMultier equals 2 because of this.
int
layoutWidth,
layoutHeight;
int []
xMaxArray;
int []
yMaxArray;
int
compindex,
i,
k,
px,
py,
pixels_diff,
nextSize;
int
curX = 0; // constraints.gridx
int
curY = 0; // constraints.gridy
int
curWidth = 1; // constraints.gridwidth
int
curHeight = 1; // constraints.gridheight
int
curRow,
curCol;
double
weight_diff,
weight;
int
maximumArrayXIndex = 0;
int
maximumArrayYIndex = 0;
int
anchor;
/*
* Pass #1
*
* Figure out the dimensions of the layout grid (use a value of 1 for
* zero or negative widths and heights).
*/
layoutWidth =
layoutHeight = 0;
curRow =
curCol = -1;
long []
arraySizes =
preInitMaximumArraySizes(
parent);
/* fix for 4623196.
* If user try to create a very big grid we can
* get NegativeArraySizeException because of integer value
* overflow (EMPIRICMULTIPLIER*gridSize might be more then Integer.MAX_VALUE).
* We need to detect this situation and try to create a
* grid with Integer.MAX_VALUE size instead.
*/
maximumArrayXIndex = (
EMPIRICMULTIPLIER *
arraySizes[0] >
Integer.
MAX_VALUE )?
Integer.
MAX_VALUE :
EMPIRICMULTIPLIER*(int)
arraySizes[0];
maximumArrayYIndex = (
EMPIRICMULTIPLIER *
arraySizes[1] >
Integer.
MAX_VALUE )?
Integer.
MAX_VALUE :
EMPIRICMULTIPLIER*(int)
arraySizes[1];
if (
rowHeights != null){
maximumArrayXIndex =
Math.
max(
maximumArrayXIndex,
rowHeights.length);
}
if (
columnWidths != null){
maximumArrayYIndex =
Math.
max(
maximumArrayYIndex,
columnWidths.length);
}
xMaxArray = new int[
maximumArrayXIndex];
yMaxArray = new int[
maximumArrayYIndex];
boolean
hasBaseline = false;
for (
compindex = 0 ;
compindex <
components.length ;
compindex++) {
comp =
components[
compindex];
if (!
comp.
isVisible())
continue;
constraints =
lookupConstraints(
comp);
curX =
constraints.
gridx;
curY =
constraints.
gridy;
curWidth =
constraints.
gridwidth;
if (
curWidth <= 0)
curWidth = 1;
curHeight =
constraints.
gridheight;
if (
curHeight <= 0)
curHeight = 1;
/* If x or y is negative, then use relative positioning: */
if (
curX < 0 &&
curY < 0) {
if (
curRow >= 0)
curY =
curRow;
else if (
curCol >= 0)
curX =
curCol;
else
curY = 0;
}
if (
curX < 0) {
px = 0;
for (
i =
curY;
i < (
curY +
curHeight);
i++) {
px =
Math.
max(
px,
xMaxArray[
i]);
}
curX =
px -
curX - 1;
if(
curX < 0)
curX = 0;
}
else if (
curY < 0) {
py = 0;
for (
i =
curX;
i < (
curX +
curWidth);
i++) {
py =
Math.
max(
py,
yMaxArray[
i]);
}
curY =
py -
curY - 1;
if(
curY < 0)
curY = 0;
}
/* Adjust the grid width and height
* fix for 5005945: unneccessary loops removed
*/
px =
curX +
curWidth;
if (
layoutWidth <
px) {
layoutWidth =
px;
}
py =
curY +
curHeight;
if (
layoutHeight <
py) {
layoutHeight =
py;
}
/* Adjust xMaxArray and yMaxArray */
for (
i =
curX;
i < (
curX +
curWidth);
i++) {
yMaxArray[
i] =
py;
}
for (
i =
curY;
i < (
curY +
curHeight);
i++) {
xMaxArray[
i] =
px;
}
/* Cache the current slave's size. */
if (
sizeflag ==
PREFERREDSIZE)
d =
comp.
getPreferredSize();
else
d =
comp.
getMinimumSize();
constraints.
minWidth =
d.
width;
constraints.
minHeight =
d.
height;
if (
calculateBaseline(
comp,
constraints,
d)) {
hasBaseline = true;
}
/* Zero width and height must mean that this is the last item (or
* else something is wrong). */
if (
constraints.
gridheight == 0 &&
constraints.
gridwidth == 0)
curRow =
curCol = -1;
/* Zero width starts a new row */
if (
constraints.
gridheight == 0 &&
curRow < 0)
curCol =
curX +
curWidth;
/* Zero height starts a new column */
else if (
constraints.
gridwidth == 0 &&
curCol < 0)
curRow =
curY +
curHeight;
} //for (components) loop
/*
* Apply minimum row/column dimensions
*/
if (
columnWidths != null &&
layoutWidth <
columnWidths.length)
layoutWidth =
columnWidths.length;
if (
rowHeights != null &&
layoutHeight <
rowHeights.length)
layoutHeight =
rowHeights.length;
r = new
GridBagLayoutInfo(
layoutWidth,
layoutHeight);
/*
* Pass #2
*
* Negative values for gridX are filled in with the current x value.
* Negative values for gridY are filled in with the current y value.
* Negative or zero values for gridWidth and gridHeight end the current
* row or column, respectively.
*/
curRow =
curCol = -1;
Arrays.
fill(
xMaxArray, 0);
Arrays.
fill(
yMaxArray, 0);
int[]
maxAscent = null;
int[]
maxDescent = null;
short[]
baselineType = null;
if (
hasBaseline) {
r.
maxAscent =
maxAscent = new int[
layoutHeight];
r.
maxDescent =
maxDescent = new int[
layoutHeight];
r.
baselineType =
baselineType = new short[
layoutHeight];
r.
hasBaseline = true;
}
for (
compindex = 0 ;
compindex <
components.length ;
compindex++) {
comp =
components[
compindex];
if (!
comp.
isVisible())
continue;
constraints =
lookupConstraints(
comp);
curX =
constraints.
gridx;
curY =
constraints.
gridy;
curWidth =
constraints.
gridwidth;
curHeight =
constraints.
gridheight;
/* If x or y is negative, then use relative positioning: */
if (
curX < 0 &&
curY < 0) {
if(
curRow >= 0)
curY =
curRow;
else if(
curCol >= 0)
curX =
curCol;
else
curY = 0;
}
if (
curX < 0) {
if (
curHeight <= 0) {
curHeight +=
r.
height -
curY;
if (
curHeight < 1)
curHeight = 1;
}
px = 0;
for (
i =
curY;
i < (
curY +
curHeight);
i++)
px =
Math.
max(
px,
xMaxArray[
i]);
curX =
px -
curX - 1;
if(
curX < 0)
curX = 0;
}
else if (
curY < 0) {
if (
curWidth <= 0) {
curWidth +=
r.
width -
curX;
if (
curWidth < 1)
curWidth = 1;
}
py = 0;
for (
i =
curX;
i < (
curX +
curWidth);
i++){
py =
Math.
max(
py,
yMaxArray[
i]);
}
curY =
py -
curY - 1;
if(
curY < 0)
curY = 0;
}
if (
curWidth <= 0) {
curWidth +=
r.
width -
curX;
if (
curWidth < 1)
curWidth = 1;
}
if (
curHeight <= 0) {
curHeight +=
r.
height -
curY;
if (
curHeight < 1)
curHeight = 1;
}
px =
curX +
curWidth;
py =
curY +
curHeight;
for (
i =
curX;
i < (
curX +
curWidth);
i++) {
yMaxArray[
i] =
py; }
for (
i =
curY;
i < (
curY +
curHeight);
i++) {
xMaxArray[
i] =
px; }
/* Make negative sizes start a new row/column */
if (
constraints.
gridheight == 0 &&
constraints.
gridwidth == 0)
curRow =
curCol = -1;
if (
constraints.
gridheight == 0 &&
curRow < 0)
curCol =
curX +
curWidth;
else if (
constraints.
gridwidth == 0 &&
curCol < 0)
curRow =
curY +
curHeight;
/* Assign the new values to the gridbag slave */
constraints.
tempX =
curX;
constraints.
tempY =
curY;
constraints.
tempWidth =
curWidth;
constraints.
tempHeight =
curHeight;
anchor =
constraints.
anchor;
if (
hasBaseline) {
switch(
anchor) {
case
GridBagConstraints.
BASELINE:
case
GridBagConstraints.
BASELINE_LEADING:
case
GridBagConstraints.
BASELINE_TRAILING:
if (
constraints.
ascent >= 0) {
if (
curHeight == 1) {
maxAscent[
curY] =
Math.
max(
maxAscent[
curY],
constraints.
ascent);
maxDescent[
curY] =
Math.
max(
maxDescent[
curY],
constraints.
descent);
}
else {
if (
constraints.
baselineResizeBehavior ==
Component.
BaselineResizeBehavior.
CONSTANT_DESCENT) {
maxDescent[
curY +
curHeight - 1] =
Math.
max(
maxDescent[
curY +
curHeight
- 1],
constraints.
descent);
}
else {
maxAscent[
curY] =
Math.
max(
maxAscent[
curY],
constraints.
ascent);
}
}
if (
constraints.
baselineResizeBehavior ==
Component.
BaselineResizeBehavior.
CONSTANT_DESCENT) {
baselineType[
curY +
curHeight - 1] |=
(1 <<
constraints.
baselineResizeBehavior.
ordinal());
}
else {
baselineType[
curY] |= (1 <<
constraints.
baselineResizeBehavior.
ordinal());
}
}
break;
case
GridBagConstraints.
ABOVE_BASELINE:
case
GridBagConstraints.
ABOVE_BASELINE_LEADING:
case
GridBagConstraints.
ABOVE_BASELINE_TRAILING:
// Component positioned above the baseline.
// To make the bottom edge of the component aligned
// with the baseline the bottom inset is
// added to the descent, the rest to the ascent.
pixels_diff =
constraints.
minHeight +
constraints.
insets.
top +
constraints.
ipady;
maxAscent[
curY] =
Math.
max(
maxAscent[
curY],
pixels_diff);
maxDescent[
curY] =
Math.
max(
maxDescent[
curY],
constraints.
insets.
bottom);
break;
case
GridBagConstraints.
BELOW_BASELINE:
case
GridBagConstraints.
BELOW_BASELINE_LEADING:
case
GridBagConstraints.
BELOW_BASELINE_TRAILING:
// Component positioned below the baseline.
// To make the top edge of the component aligned
// with the baseline the top inset is
// added to the ascent, the rest to the descent.
pixels_diff =
constraints.
minHeight +
constraints.
insets.
bottom +
constraints.
ipady;
maxDescent[
curY] =
Math.
max(
maxDescent[
curY],
pixels_diff);
maxAscent[
curY] =
Math.
max(
maxAscent[
curY],
constraints.
insets.
top);
break;
}
}
}
r.
weightX = new double[
maximumArrayYIndex];
r.
weightY = new double[
maximumArrayXIndex];
r.
minWidth = new int[
maximumArrayYIndex];
r.
minHeight = new int[
maximumArrayXIndex];
/*
* Apply minimum row/column dimensions and weights
*/
if (
columnWidths != null)
System.
arraycopy(
columnWidths, 0,
r.
minWidth, 0,
columnWidths.length);
if (
rowHeights != null)
System.
arraycopy(
rowHeights, 0,
r.
minHeight, 0,
rowHeights.length);
if (
columnWeights != null)
System.
arraycopy(
columnWeights, 0,
r.
weightX, 0,
Math.
min(
r.
weightX.length,
columnWeights.length));
if (
rowWeights != null)
System.
arraycopy(
rowWeights, 0,
r.
weightY, 0,
Math.
min(
r.
weightY.length,
rowWeights.length));
/*
* Pass #3
*
* Distribute the minimun widths and weights:
*/
nextSize =
Integer.
MAX_VALUE;
for (
i = 1;
i !=
Integer.
MAX_VALUE;
i =
nextSize,
nextSize =
Integer.
MAX_VALUE) {
for (
compindex = 0 ;
compindex <
components.length ;
compindex++) {
comp =
components[
compindex];
if (!
comp.
isVisible())
continue;
constraints =
lookupConstraints(
comp);
if (
constraints.
tempWidth ==
i) {
px =
constraints.
tempX +
constraints.
tempWidth; /* right column */
/*
* Figure out if we should use this slave\'s weight. If the weight
* is less than the total weight spanned by the width of the cell,
* then discard the weight. Otherwise split the difference
* according to the existing weights.
*/
weight_diff =
constraints.
weightx;
for (
k =
constraints.
tempX;
k <
px;
k++)
weight_diff -=
r.
weightX[
k];
if (
weight_diff > 0.0) {
weight = 0.0;
for (
k =
constraints.
tempX;
k <
px;
k++)
weight +=
r.
weightX[
k];
for (
k =
constraints.
tempX;
weight > 0.0 &&
k <
px;
k++) {
double
wt =
r.
weightX[
k];
double
dx = (
wt *
weight_diff) /
weight;
r.
weightX[
k] +=
dx;
weight_diff -=
dx;
weight -=
wt;
}
/* Assign the remainder to the rightmost cell */
r.
weightX[
px-1] +=
weight_diff;
}
/*
* Calculate the minWidth array values.
* First, figure out how wide the current slave needs to be.
* Then, see if it will fit within the current minWidth values.
* If it will not fit, add the difference according to the
* weightX array.
*/
pixels_diff =
constraints.
minWidth +
constraints.
ipadx +
constraints.
insets.
left +
constraints.
insets.
right;
for (
k =
constraints.
tempX;
k <
px;
k++)
pixels_diff -=
r.
minWidth[
k];
if (
pixels_diff > 0) {
weight = 0.0;
for (
k =
constraints.
tempX;
k <
px;
k++)
weight +=
r.
weightX[
k];
for (
k =
constraints.
tempX;
weight > 0.0 &&
k <
px;
k++) {
double
wt =
r.
weightX[
k];
int
dx = (int)((
wt * ((double)
pixels_diff)) /
weight);
r.
minWidth[
k] +=
dx;
pixels_diff -=
dx;
weight -=
wt;
}
/* Any leftovers go into the rightmost cell */
r.
minWidth[
px-1] +=
pixels_diff;
}
}
else if (
constraints.
tempWidth >
i &&
constraints.
tempWidth <
nextSize)
nextSize =
constraints.
tempWidth;
if (
constraints.
tempHeight ==
i) {
py =
constraints.
tempY +
constraints.
tempHeight; /* bottom row */
/*
* Figure out if we should use this slave's weight. If the weight
* is less than the total weight spanned by the height of the cell,
* then discard the weight. Otherwise split it the difference
* according to the existing weights.
*/
weight_diff =
constraints.
weighty;
for (
k =
constraints.
tempY;
k <
py;
k++)
weight_diff -=
r.
weightY[
k];
if (
weight_diff > 0.0) {
weight = 0.0;
for (
k =
constraints.
tempY;
k <
py;
k++)
weight +=
r.
weightY[
k];
for (
k =
constraints.
tempY;
weight > 0.0 &&
k <
py;
k++) {
double
wt =
r.
weightY[
k];
double
dy = (
wt *
weight_diff) /
weight;
r.
weightY[
k] +=
dy;
weight_diff -=
dy;
weight -=
wt;
}
/* Assign the remainder to the bottom cell */
r.
weightY[
py-1] +=
weight_diff;
}
/*
* Calculate the minHeight array values.
* First, figure out how tall the current slave needs to be.
* Then, see if it will fit within the current minHeight values.
* If it will not fit, add the difference according to the
* weightY array.
*/
pixels_diff = -1;
if (
hasBaseline) {
switch(
constraints.
anchor) {
case
GridBagConstraints.
BASELINE:
case
GridBagConstraints.
BASELINE_LEADING:
case
GridBagConstraints.
BASELINE_TRAILING:
if (
constraints.
ascent >= 0) {
if (
constraints.
tempHeight == 1) {
pixels_diff =
maxAscent[
constraints.
tempY] +
maxDescent[
constraints.
tempY];
}
else if (
constraints.
baselineResizeBehavior !=
Component.
BaselineResizeBehavior.
CONSTANT_DESCENT) {
pixels_diff =
maxAscent[
constraints.
tempY] +
constraints.
descent;
}
else {
pixels_diff =
constraints.
ascent +
maxDescent[
constraints.
tempY +
constraints.
tempHeight - 1];
}
}
break;
case
GridBagConstraints.
ABOVE_BASELINE:
case
GridBagConstraints.
ABOVE_BASELINE_LEADING:
case
GridBagConstraints.
ABOVE_BASELINE_TRAILING:
pixels_diff =
constraints.
insets.
top +
constraints.
minHeight +
constraints.
ipady +
maxDescent[
constraints.
tempY];
break;
case
GridBagConstraints.
BELOW_BASELINE:
case
GridBagConstraints.
BELOW_BASELINE_LEADING:
case
GridBagConstraints.
BELOW_BASELINE_TRAILING:
pixels_diff =
maxAscent[
constraints.
tempY] +
constraints.
minHeight +
constraints.
insets.
bottom +
constraints.
ipady;
break;
}
}
if (
pixels_diff == -1) {
pixels_diff =
constraints.
minHeight +
constraints.
ipady +
constraints.
insets.
top +
constraints.
insets.
bottom;
}
for (
k =
constraints.
tempY;
k <
py;
k++)
pixels_diff -=
r.
minHeight[
k];
if (
pixels_diff > 0) {
weight = 0.0;
for (
k =
constraints.
tempY;
k <
py;
k++)
weight +=
r.
weightY[
k];
for (
k =
constraints.
tempY;
weight > 0.0 &&
k <
py;
k++) {
double
wt =
r.
weightY[
k];
int
dy = (int)((
wt * ((double)
pixels_diff)) /
weight);
r.
minHeight[
k] +=
dy;
pixels_diff -=
dy;
weight -=
wt;
}
/* Any leftovers go into the bottom cell */
r.
minHeight[
py-1] +=
pixels_diff;
}
}
else if (
constraints.
tempHeight >
i &&
constraints.
tempHeight <
nextSize)
nextSize =
constraints.
tempHeight;
}
}
return
r;
}
} //getLayoutInfo()
/**
* Calculate the baseline for the specified component.
* If {@code c} is positioned along it's baseline, the baseline is
* obtained and the {@code constraints} ascent, descent and
* baseline resize behavior are set from the component; and true is
* returned. Otherwise false is returned.
*/
private boolean
calculateBaseline(
Component c,
GridBagConstraints constraints,
Dimension size) {
int
anchor =
constraints.
anchor;
if (
anchor ==
GridBagConstraints.
BASELINE ||
anchor ==
GridBagConstraints.
BASELINE_LEADING ||
anchor ==
GridBagConstraints.
BASELINE_TRAILING) {
// Apply the padding to the component, then ask for the baseline.
int
w =
size.
width +
constraints.
ipadx;
int
h =
size.
height +
constraints.
ipady;
constraints.
ascent =
c.
getBaseline(
w,
h);
if (
constraints.
ascent >= 0) {
// Component has a baseline
int
baseline =
constraints.
ascent;
// Adjust the ascent and descent to include the insets.
constraints.
descent =
h -
constraints.
ascent +
constraints.
insets.
bottom;
constraints.
ascent +=
constraints.
insets.
top;
constraints.
baselineResizeBehavior =
c.
getBaselineResizeBehavior();
constraints.
centerPadding = 0;
if (
constraints.
baselineResizeBehavior ==
Component.
BaselineResizeBehavior.
CENTER_OFFSET) {
// Component has a baseline resize behavior of
// CENTER_OFFSET, calculate centerPadding and
// centerOffset (see the description of
// CENTER_OFFSET in the enum for detais on this
// algorithm).
int
nextBaseline =
c.
getBaseline(
w,
h + 1);
constraints.
centerOffset =
baseline -
h / 2;
if (
h % 2 == 0) {
if (
baseline !=
nextBaseline) {
constraints.
centerPadding = 1;
}
}
else if (
baseline ==
nextBaseline){
constraints.
centerOffset--;
constraints.
centerPadding = 1;
}
}
}
return true;
}
else {
constraints.
ascent = -1;
return false;
}
}
/**
* Adjusts the x, y, width, and height fields to the correct
* values depending on the constraint geometry and pads.
* This method should only be used internally by
* <code>GridBagLayout</code>.
*
* @param constraints the constraints to be applied
* @param r the <code>Rectangle</code> to be adjusted
* @since 1.4
*/
protected void
adjustForGravity(
GridBagConstraints constraints,
Rectangle r) {
AdjustForGravity(
constraints,
r);
}
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #adjustForGravity(java.awt.GridBagConstraints, java.awt.Rectangle)
* adjustForGravity} instead.
* This method is the same as <code>adjustForGravity</code>;
* refer to <code>adjustForGravity</code> for details
* on parameters.
*/
protected void
AdjustForGravity(
GridBagConstraints constraints,
Rectangle r) {
int
diffx,
diffy;
int
cellY =
r.
y;
int
cellHeight =
r.
height;
if (!
rightToLeft) {
r.
x +=
constraints.
insets.
left;
} else {
r.
x -=
r.
width -
constraints.
insets.
right;
}
r.
width -= (
constraints.
insets.
left +
constraints.
insets.
right);
r.
y +=
constraints.
insets.
top;
r.
height -= (
constraints.
insets.
top +
constraints.
insets.
bottom);
diffx = 0;
if ((
constraints.
fill !=
GridBagConstraints.
HORIZONTAL &&
constraints.
fill !=
GridBagConstraints.
BOTH)
&& (
r.
width > (
constraints.
minWidth +
constraints.
ipadx))) {
diffx =
r.
width - (
constraints.
minWidth +
constraints.
ipadx);
r.
width =
constraints.
minWidth +
constraints.
ipadx;
}
diffy = 0;
if ((
constraints.
fill !=
GridBagConstraints.
VERTICAL &&
constraints.
fill !=
GridBagConstraints.
BOTH)
&& (
r.
height > (
constraints.
minHeight +
constraints.
ipady))) {
diffy =
r.
height - (
constraints.
minHeight +
constraints.
ipady);
r.
height =
constraints.
minHeight +
constraints.
ipady;
}
switch (
constraints.
anchor) {
case
GridBagConstraints.
BASELINE:
r.
x +=
diffx/2;
alignOnBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
BASELINE_LEADING:
if (
rightToLeft) {
r.
x +=
diffx;
}
alignOnBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
BASELINE_TRAILING:
if (!
rightToLeft) {
r.
x +=
diffx;
}
alignOnBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
ABOVE_BASELINE:
r.
x +=
diffx/2;
alignAboveBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
ABOVE_BASELINE_LEADING:
if (
rightToLeft) {
r.
x +=
diffx;
}
alignAboveBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
ABOVE_BASELINE_TRAILING:
if (!
rightToLeft) {
r.
x +=
diffx;
}
alignAboveBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
BELOW_BASELINE:
r.
x +=
diffx/2;
alignBelowBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
BELOW_BASELINE_LEADING:
if (
rightToLeft) {
r.
x +=
diffx;
}
alignBelowBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
BELOW_BASELINE_TRAILING:
if (!
rightToLeft) {
r.
x +=
diffx;
}
alignBelowBaseline(
constraints,
r,
cellY,
cellHeight);
break;
case
GridBagConstraints.
CENTER:
r.
x +=
diffx/2;
r.
y +=
diffy/2;
break;
case
GridBagConstraints.
PAGE_START:
case
GridBagConstraints.
NORTH:
r.
x +=
diffx/2;
break;
case
GridBagConstraints.
NORTHEAST:
r.
x +=
diffx;
break;
case
GridBagConstraints.
EAST:
r.
x +=
diffx;
r.
y +=
diffy/2;
break;
case
GridBagConstraints.
SOUTHEAST:
r.
x +=
diffx;
r.
y +=
diffy;
break;
case
GridBagConstraints.
PAGE_END:
case
GridBagConstraints.
SOUTH:
r.
x +=
diffx/2;
r.
y +=
diffy;
break;
case
GridBagConstraints.
SOUTHWEST:
r.
y +=
diffy;
break;
case
GridBagConstraints.
WEST:
r.
y +=
diffy/2;
break;
case
GridBagConstraints.
NORTHWEST:
break;
case
GridBagConstraints.
LINE_START:
if (
rightToLeft) {
r.
x +=
diffx;
}
r.
y +=
diffy/2;
break;
case
GridBagConstraints.
LINE_END:
if (!
rightToLeft) {
r.
x +=
diffx;
}
r.
y +=
diffy/2;
break;
case
GridBagConstraints.
FIRST_LINE_START:
if (
rightToLeft) {
r.
x +=
diffx;
}
break;
case
GridBagConstraints.
FIRST_LINE_END:
if (!
rightToLeft) {
r.
x +=
diffx;
}
break;
case
GridBagConstraints.
LAST_LINE_START:
if (
rightToLeft) {
r.
x +=
diffx;
}
r.
y +=
diffy;
break;
case
GridBagConstraints.
LAST_LINE_END:
if (!
rightToLeft) {
r.
x +=
diffx;
}
r.
y +=
diffy;
break;
default:
throw new
IllegalArgumentException("illegal anchor value");
}
}
/**
* Positions on the baseline.
*
* @param cellY the location of the row, does not include insets
* @param cellHeight the height of the row, does not take into account
* insets
* @param r available bounds for the component, is padded by insets and
* ipady
*/
private void
alignOnBaseline(
GridBagConstraints cons,
Rectangle r,
int
cellY, int
cellHeight) {
if (
cons.
ascent >= 0) {
if (
cons.
baselineResizeBehavior ==
Component.
BaselineResizeBehavior.
CONSTANT_DESCENT) {
// Anchor to the bottom.
// Baseline is at (cellY + cellHeight - maxDescent).
// Bottom of component (maxY) is at baseline + descent
// of component. We need to subtract the bottom inset here
// as the descent in the constraints object includes the
// bottom inset.
int
maxY =
cellY +
cellHeight -
layoutInfo.
maxDescent[
cons.
tempY +
cons.
tempHeight - 1] +
cons.
descent -
cons.
insets.
bottom;
if (!
cons.
isVerticallyResizable()) {
// Component not resizable, calculate y location
// from maxY - height.
r.
y =
maxY -
cons.
minHeight;
r.
height =
cons.
minHeight;
} else {
// Component is resizable. As brb is constant descent,
// can expand component to fill region above baseline.
// Subtract out the top inset so that components insets
// are honored.
r.
height =
maxY -
cellY -
cons.
insets.
top;
}
}
else {
// BRB is not constant_descent
int
baseline; // baseline for the row, relative to cellY
// Component baseline, includes insets.top
int
ascent =
cons.
ascent;
if (
layoutInfo.
hasConstantDescent(
cons.
tempY)) {
// Mixed ascent/descent in same row, calculate position
// off maxDescent
baseline =
cellHeight -
layoutInfo.
maxDescent[
cons.
tempY];
}
else {
// Only ascents/unknown in this row, anchor to top
baseline =
layoutInfo.
maxAscent[
cons.
tempY];
}
if (
cons.
baselineResizeBehavior ==
Component.
BaselineResizeBehavior.
OTHER) {
// BRB is other, which means we can only determine
// the baseline by asking for it again giving the
// size we plan on using for the component.
boolean
fits = false;
ascent =
componentAdjusting.
getBaseline(
r.
width,
r.
height);
if (
ascent >= 0) {
// Component has a baseline, pad with top inset
// (this follows from calculateBaseline which
// does the same).
ascent +=
cons.
insets.
top;
}
if (
ascent >= 0 &&
ascent <=
baseline) {
// Components baseline fits within rows baseline.
// Make sure the descent fits within the space as well.
if (
baseline + (
r.
height -
ascent -
cons.
insets.
top) <=
cellHeight -
cons.
insets.
bottom) {
// It fits, we're good.
fits = true;
}
else if (
cons.
isVerticallyResizable()) {
// Doesn't fit, but it's resizable. Try
// again assuming we'll get ascent again.
int
ascent2 =
componentAdjusting.
getBaseline(
r.
width,
cellHeight -
cons.
insets.
bottom -
baseline +
ascent);
if (
ascent2 >= 0) {
ascent2 +=
cons.
insets.
top;
}
if (
ascent2 >= 0 &&
ascent2 <=
ascent) {
// It'll fit
r.
height =
cellHeight -
cons.
insets.
bottom -
baseline +
ascent;
ascent =
ascent2;
fits = true;
}
}
}
if (!
fits) {
// Doesn't fit, use min size and original ascent
ascent =
cons.
ascent;
r.
width =
cons.
minWidth;
r.
height =
cons.
minHeight;
}
}
// Reset the components y location based on
// components ascent and baseline for row. Because ascent
// includes the baseline
r.
y =
cellY +
baseline -
ascent +
cons.
insets.
top;
if (
cons.
isVerticallyResizable()) {
switch(
cons.
baselineResizeBehavior) {
case
CONSTANT_ASCENT:
r.
height =
Math.
max(
cons.
minHeight,
cellY +
cellHeight -
r.
y -
cons.
insets.
bottom);
break;
case
CENTER_OFFSET:
{
int
upper =
r.
y -
cellY -
cons.
insets.
top;
int
lower =
cellY +
cellHeight -
r.
y -
cons.
minHeight -
cons.
insets.
bottom;
int
delta =
Math.
min(
upper,
lower);
delta +=
delta;
if (
delta > 0 &&
(
cons.
minHeight +
cons.
centerPadding +
delta) / 2 +
cons.
centerOffset !=
baseline) {
// Off by 1
delta--;
}
r.
height =
cons.
minHeight +
delta;
r.
y =
cellY +
baseline -
(
r.
height +
cons.
centerPadding) / 2 -
cons.
centerOffset;
}
break;
case
OTHER:
// Handled above
break;
default:
break;
}
}
}
}
else {
centerVertically(
cons,
r,
cellHeight);
}
}
/**
* Positions the specified component above the baseline. That is
* the bottom edge of the component will be aligned along the baseline.
* If the row does not have a baseline, this centers the component.
*/
private void
alignAboveBaseline(
GridBagConstraints cons,
Rectangle r,
int
cellY, int
cellHeight) {
if (
layoutInfo.
hasBaseline(
cons.
tempY)) {
int
maxY; // Baseline for the row
if (
layoutInfo.
hasConstantDescent(
cons.
tempY)) {
// Prefer descent
maxY =
cellY +
cellHeight -
layoutInfo.
maxDescent[
cons.
tempY];
}
else {
// Prefer ascent
maxY =
cellY +
layoutInfo.
maxAscent[
cons.
tempY];
}
if (
cons.
isVerticallyResizable()) {
// Component is resizable. Top edge is offset by top
// inset, bottom edge on baseline.
r.
y =
cellY +
cons.
insets.
top;
r.
height =
maxY -
r.
y;
}
else {
// Not resizable.
r.
height =
cons.
minHeight +
cons.
ipady;
r.
y =
maxY -
r.
height;
}
}
else {
centerVertically(
cons,
r,
cellHeight);
}
}
/**
* Positions below the baseline.
*/
private void
alignBelowBaseline(
GridBagConstraints cons,
Rectangle r,
int
cellY, int
cellHeight) {
if (
layoutInfo.
hasBaseline(
cons.
tempY)) {
if (
layoutInfo.
hasConstantDescent(
cons.
tempY)) {
// Prefer descent
r.
y =
cellY +
cellHeight -
layoutInfo.
maxDescent[
cons.
tempY];
}
else {
// Prefer ascent
r.
y =
cellY +
layoutInfo.
maxAscent[
cons.
tempY];
}
if (
cons.
isVerticallyResizable()) {
r.
height =
cellY +
cellHeight -
r.
y -
cons.
insets.
bottom;
}
}
else {
centerVertically(
cons,
r,
cellHeight);
}
}
private void
centerVertically(
GridBagConstraints cons,
Rectangle r,
int
cellHeight) {
if (!
cons.
isVerticallyResizable()) {
r.
y +=
Math.
max(0, (
cellHeight -
cons.
insets.
top -
cons.
insets.
bottom -
cons.
minHeight -
cons.
ipady) / 2);
}
}
/**
* Figures out the minimum size of the
* master based on the information from <code>getLayoutInfo</code>.
* This method should only be used internally by
* <code>GridBagLayout</code>.
*
* @param parent the layout container
* @param info the layout info for this parent
* @return a <code>Dimension</code> object containing the
* minimum size
* @since 1.4
*/
protected
Dimension getMinSize(
Container parent,
GridBagLayoutInfo info) {
return
GetMinSize(
parent,
info);
}
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #getMinSize(java.awt.Container, GridBagLayoutInfo) getMinSize} instead.
* This method is the same as <code>getMinSize</code>;
* refer to <code>getMinSize</code> for details on parameters
* and return value.
*/
protected
Dimension GetMinSize(
Container parent,
GridBagLayoutInfo info) {
Dimension d = new
Dimension();
int
i,
t;
Insets insets =
parent.
getInsets();
t = 0;
for(
i = 0;
i <
info.
width;
i++)
t +=
info.
minWidth[
i];
d.
width =
t +
insets.
left +
insets.
right;
t = 0;
for(
i = 0;
i <
info.
height;
i++)
t +=
info.
minHeight[
i];
d.
height =
t +
insets.
top +
insets.
bottom;
return
d;
}
transient boolean
rightToLeft = false;
/**
* Lays out the grid.
* This method should only be used internally by
* <code>GridBagLayout</code>.
*
* @param parent the layout container
* @since 1.4
*/
protected void
arrangeGrid(
Container parent) {
ArrangeGrid(
parent);
}
/**
* This method is obsolete and supplied for backwards
* compatibility only; new code should call {@link
* #arrangeGrid(Container) arrangeGrid} instead.
* This method is the same as <code>arrangeGrid</code>;
* refer to <code>arrangeGrid</code> for details on the
* parameter.
*/
protected void
ArrangeGrid(
Container parent) {
Component comp;
int
compindex;
GridBagConstraints constraints;
Insets insets =
parent.
getInsets();
Component components[] =
parent.
getComponents();
Dimension d;
Rectangle r = new
Rectangle();
int
i,
diffw,
diffh;
double
weight;
GridBagLayoutInfo info;
rightToLeft = !
parent.
getComponentOrientation().
isLeftToRight();
/*
* If the parent has no slaves anymore, then don't do anything
* at all: just leave the parent's size as-is.
*/
if (
components.length == 0 &&
(
columnWidths == null ||
columnWidths.length == 0) &&
(
rowHeights == null ||
rowHeights.length == 0)) {
return;
}
/*
* Pass #1: scan all the slaves to figure out the total amount
* of space needed.
*/
info =
getLayoutInfo(
parent,
PREFERREDSIZE);
d =
getMinSize(
parent,
info);
if (
parent.
width <
d.
width ||
parent.
height <
d.
height) {
info =
getLayoutInfo(
parent,
MINSIZE);
d =
getMinSize(
parent,
info);
}
layoutInfo =
info;
r.
width =
d.
width;
r.
height =
d.
height;
/*
* DEBUG
*
* DumpLayoutInfo(info);
* for (compindex = 0 ; compindex < components.length ; compindex++) {
* comp = components[compindex];
* if (!comp.isVisible())
* continue;
* constraints = lookupConstraints(comp);
* DumpConstraints(constraints);
* }
* System.out.println("minSize " + r.width + " " + r.height);
*/
/*
* If the current dimensions of the window don't match the desired
* dimensions, then adjust the minWidth and minHeight arrays
* according to the weights.
*/
diffw =
parent.
width -
r.
width;
if (
diffw != 0) {
weight = 0.0;
for (
i = 0;
i <
info.
width;
i++)
weight +=
info.
weightX[
i];
if (
weight > 0.0) {
for (
i = 0;
i <
info.
width;
i++) {
int
dx = (int)(( ((double)
diffw) *
info.
weightX[
i]) /
weight);
info.
minWidth[
i] +=
dx;
r.
width +=
dx;
if (
info.
minWidth[
i] < 0) {
r.
width -=
info.
minWidth[
i];
info.
minWidth[
i] = 0;
}
}
}
diffw =
parent.
width -
r.
width;
}
else {
diffw = 0;
}
diffh =
parent.
height -
r.
height;
if (
diffh != 0) {
weight = 0.0;
for (
i = 0;
i <
info.
height;
i++)
weight +=
info.
weightY[
i];
if (
weight > 0.0) {
for (
i = 0;
i <
info.
height;
i++) {
int
dy = (int)(( ((double)
diffh) *
info.
weightY[
i]) /
weight);
info.
minHeight[
i] +=
dy;
r.
height +=
dy;
if (
info.
minHeight[
i] < 0) {
r.
height -=
info.
minHeight[
i];
info.
minHeight[
i] = 0;
}
}
}
diffh =
parent.
height -
r.
height;
}
else {
diffh = 0;
}
/*
* DEBUG
*
* System.out.println("Re-adjusted:");
* DumpLayoutInfo(info);
*/
/*
* Now do the actual layout of the slaves using the layout information
* that has been collected.
*/
info.
startx =
diffw/2 +
insets.
left;
info.
starty =
diffh/2 +
insets.
top;
for (
compindex = 0 ;
compindex <
components.length ;
compindex++) {
comp =
components[
compindex];
if (!
comp.
isVisible()){
continue;
}
constraints =
lookupConstraints(
comp);
if (!
rightToLeft) {
r.
x =
info.
startx;
for(
i = 0;
i <
constraints.
tempX;
i++)
r.
x +=
info.
minWidth[
i];
} else {
r.
x =
parent.
width - (
diffw/2 +
insets.
right);
for(
i = 0;
i <
constraints.
tempX;
i++)
r.
x -=
info.
minWidth[
i];
}
r.
y =
info.
starty;
for(
i = 0;
i <
constraints.
tempY;
i++)
r.
y +=
info.
minHeight[
i];
r.
width = 0;
for(
i =
constraints.
tempX;
i < (
constraints.
tempX +
constraints.
tempWidth);
i++) {
r.
width +=
info.
minWidth[
i];
}
r.
height = 0;
for(
i =
constraints.
tempY;
i < (
constraints.
tempY +
constraints.
tempHeight);
i++) {
r.
height +=
info.
minHeight[
i];
}
componentAdjusting =
comp;
adjustForGravity(
constraints,
r);
/* fix for 4408108 - components were being created outside of the container */
/* fix for 4969409 "-" replaced by "+" */
if (
r.
x < 0) {
r.
width +=
r.
x;
r.
x = 0;
}
if (
r.
y < 0) {
r.
height +=
r.
y;
r.
y = 0;
}
/*
* If the window is too small to be interesting then
* unmap it. Otherwise configure it and then make sure
* it's mapped.
*/
if ((
r.
width <= 0) || (
r.
height <= 0)) {
comp.
setBounds(0, 0, 0, 0);
}
else {
if (
comp.
x !=
r.
x ||
comp.
y !=
r.
y ||
comp.
width !=
r.
width ||
comp.
height !=
r.
height) {
comp.
setBounds(
r.
x,
r.
y,
r.
width,
r.
height);
}
}
}
}
// Added for serial backwards compatibility (4348425)
static final long
serialVersionUID = 8838754796412211005L;
}