/java-1.7.0-openjdk/openjdk/jdk/src/share/classes/java/awt/GridBagLayout.java
Java | 2228 lines | 1060 code | 158 blank | 1010 comment | 290 complexity | 01afadfc037ebcf45c372cbd58dca85b MD5 | raw file
Possible License(s): GPL-2.0, BSD-3-Clause-No-Nuclear-License-2014, LGPL-3.0, LGPL-2.0
Large files files are truncated, but you can click here to view the full file
- /*
- * Copyright (c) 1995, 2006, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
- 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:
- * <p>
- * <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:</dd>
- * <p>
- * <center><table BORDER=0 COLS=3 WIDTH=800
- * SUMMARY="absolute, relative and baseline values as described above">
- * <tr>
- * <th><P ALIGN="LEFT">Absolute Values</th>
- * <th><P ALIGN="LEFT">Orientation Relative Values</th>
- * <th><P ALIGN="LEFT">Baseline Relative Values</th>
- * </tr>
- * <tr>
- * <td>
- * <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>
- * </td>
- * <td>
- * <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>
- * </td>
- * <td>
- * <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>
- * </td>
- * </tr>
- * </table></center><p>
- * <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)." ALIGN=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.
- * <p>
- * <center><table COLS=2 WIDTH=600 summary="layout">
- * <tr ALIGN=CENTER>
- * <td>
- * <img src="doc-files/GridBagLayout-1.gif" alt="The preceeding text describes this graphic (Figure 1)." ALIGN=center HSPACE=10 VSPACE=7>
- * </td>
- * <td>
- * <img src="doc-files/GridBagLayout-2.gif" alt="The preceeding text describes this graphic (Figure 2)." ALIGN=center HSPACE=10 VSPACE=7>
- * </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:
- * <p>
- * <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:
- * <p>
- * <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 keeped 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, rowa 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 contraints 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 contraints 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 amoung 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
- * compatability 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)…
Large files files are truncated, but you can click here to view the full file