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.
2235 lines
88 KiB
2235 lines
88 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;
|
|
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;
|
|
}
|