< prev index next >

src/java.desktop/share/classes/java/awt/GridBagLayout.java

Print this page

        

*** 26,47 **** 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 --- 26,47 ---- import java.util.Hashtable; import java.util.Arrays; /** ! * The {@code GridBagLayout} 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} 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} 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} 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
*** 50,61 **** * 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} --- 50,61 ---- * 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} objects that are associated ! * with its components. You customize a {@code GridBagConstraints} * object by setting one or more of its instance variables: * * <dl> * <dt>{@link GridBagConstraints#gridx}, * {@link GridBagConstraints#gridy}
*** 63,126 **** * display area, where the cell at the origin of the grid has address * <code>gridx&nbsp;=&nbsp;0</code>, * <code>gridy&nbsp;=&nbsp;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"> --- 63,126 ---- * display area, where the cell at the origin of the grid has address * <code>gridx&nbsp;=&nbsp;0</code>, * <code>gridy&nbsp;=&nbsp;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} (the default value) * to specify that the component be placed immediately following ! * (along the x axis for {@code gridx} or the y axis for ! * {@code gridy}) 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}) ! * or column (for {@code gridheight}) * in the component's display area. * The default value is 1. ! * Use {@code GridBagConstraints.REMAINDER} to specify ! * that the component's display area will be from {@code gridx} ! * to the last cell in the row (for {@code gridwidth}) ! * or from {@code gridy} to the last cell in the column ! * (for {@code gridheight}). ! * ! * Use {@code GridBagConstraints.RELATIVE} to specify ! * that the component's display area will be from {@code gridx} ! * to the next to the last cell in its row (for {@code gridwidth} ! * or from {@code gridy} to the next to the last cell in its ! * column (for {@code gridheight}). * * <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} (the default), ! * {@code GridBagConstraints.HORIZONTAL} * (make the component wide enough to fill its display area * horizontally, but don't change its height), ! * {@code GridBagConstraints.VERTICAL} * (make the component tall enough to fill its display area * vertically, but don't change its width), and ! * {@code GridBagConstraints.BOTH} * (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} pixels. Similarly, the height of * the component will be at least the minimum height plus ! * {@code ipady} 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} 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">
*** 130,186 **** * <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 --- 130,186 ---- * <th><P style="text-align:left">Baseline Relative Values</th> * </tr> * <tr> * <td> * <ul style="list-style-type:none"> ! * <li>{@code GridBagConstraints.NORTH}</li> ! * <li>{@code GridBagConstraints.SOUTH}</li> ! * <li>{@code GridBagConstraints.WEST}</li> ! * <li>{@code GridBagConstraints.EAST}</li> ! * <li>{@code GridBagConstraints.NORTHWEST}</li> ! * <li>{@code GridBagConstraints.NORTHEAST}</li> ! * <li>{@code GridBagConstraints.SOUTHWEST}</li> ! * <li>{@code GridBagConstraints.SOUTHEAST}</li> ! * <li>{@code GridBagConstraints.CENTER} (the default)</li> * </ul> * </td> * <td> * <ul style="list-style-type:none"> ! * <li>{@code GridBagConstraints.PAGE_START}</li> ! * <li>{@code GridBagConstraints.PAGE_END}</li> ! * <li>{@code GridBagConstraints.LINE_START}</li> ! * <li>{@code GridBagConstraints.LINE_END}</li> ! * <li>{@code GridBagConstraints.FIRST_LINE_START}</li> ! * <li>{@code GridBagConstraints.FIRST_LINE_END}</li> ! * <li>{@code GridBagConstraints.LAST_LINE_START}</li> ! * <li>{@code GridBagConstraints.LAST_LINE_END}</li> * </ul> * </td> * <td> * <ul style="list-style-type:none"> ! * <li>{@code GridBagConstraints.BASELINE}</li> ! * <li>{@code GridBagConstraints.BASELINE_LEADING}</li> ! * <li>{@code GridBagConstraints.BASELINE_TRAILING}</li> ! * <li>{@code GridBagConstraints.ABOVE_BASELINE}</li> ! * <li>{@code GridBagConstraints.ABOVE_BASELINE_LEADING}</li> ! * <li>{@code GridBagConstraints.ABOVE_BASELINE_TRAILING}</li> ! * <li>{@code GridBagConstraints.BELOW_BASELINE}</li> ! * <li>{@code GridBagConstraints.BELOW_BASELINE_LEADING}</li> ! * <li>{@code GridBagConstraints.BELOW_BASELINE_TRAILING}</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}) and column ({@code weighty}), * all the components clump together in the center of their container. * This is because when the weight is zero (the default), ! * the {@code GridBagLayout} 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
*** 204,229 **** * 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 --- 204,229 ---- * 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} and has ! * an anchor of {@code BASELINE}. As the baseline-resize behavior ! * is {@code CONSTANT_DESCENT} the prevailing row for the panel is * row 1. * <li>Two buttons, each with a baseline-resize behavior of ! * {@code CENTER_OFFSET} and an anchor of {@code BASELINE}. * </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}, * 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
*** 231,246 **** * 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 --- 231,246 ---- * 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} 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} * 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
*** 264,276 **** * <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&nbsp;=&nbsp;1.0</code> * <li>Button4: <code>weightx&nbsp;=&nbsp;1.0</code>, --- 264,276 ---- * <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} field ! * of its associated {@code GridBagConstraints} object ! * set to {@code GridBagConstraints.BOTH}. * In addition, the components have the following non-default constraints: * * <ul> * <li>Button1, Button2, Button3: <code>weightx&nbsp;=&nbsp;1.0</code> * <li>Button4: <code>weightx&nbsp;=&nbsp;1.0</code>,
*** 385,396 **** 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; --- 385,396 ---- protected static final int PREFERREDSIZE = 2; /** * This hashtable maintains the association between * a component and its gridbag constraints. ! * The Keys in {@code comptable} are the components and the ! * values are the instances of {@code GridBagConstraints}. * * @serial * @see java.awt.GridBagConstraints */ protected Hashtable<Component,GridBagConstraints> comptable;
*** 398,408 **** /** * 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) --- 398,408 ---- /** * 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}. * * @serial * @see #getConstraints(Component) * @see #setConstraints(Component, GridBagConstraints) * @see #lookupConstraints(Component)
*** 412,422 **** /** * 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 --- 412,422 ---- /** * 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} is {@code null} * this indicates that there are no components in * the gridbag or if there are components, they have * not yet been validated. * * @serial
*** 424,434 **** */ 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. --- 424,434 ---- */ protected GridBagLayoutInfo layoutInfo; /** * This field holds the overrides to the column minimum ! * width. If this field is non-{@code null} 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.
*** 438,492 **** */ 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> &gt; 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> &gt; 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. --- 438,492 ---- */ public int columnWidths[]; /** * This field holds the overrides to the row minimum ! * heights. If this field is non-{@code null} the values are * applied to the gridbag after all of the minimum row * heights have been calculated. ! * If {@code rowHeights} has more elements than the number of * rows, rows are added to the gridbag to match ! * the number of elements in {@code rowHeights}. * * @serial * @see #getLayoutDimensions() */ public int rowHeights[]; /** * This field holds the overrides to the column weights. ! * If this field is non-{@code null} the values are * applied to the gridbag after all of the columns * weights have been calculated. ! * If {@code columnWeights[i] >} weight for column i, then ! * column i is assigned the weight in {@code columnWeights[i]}. ! * If {@code columnWeights} 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} the values are * applied to the gridbag after all of the rows * weights have been calculated. ! * If {@code rowWeights[i] > } weight for row i, then ! * row i is assigned the weight in {@code rowWeights[i]}. ! * If {@code rowWeights} 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}. */ private Component componentAdjusting; /** * Creates a grid bag layout manager.
*** 505,515 **** 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 */ --- 505,515 ---- comptable.put(comp, (GridBagConstraints)constraints.clone()); } /** * Gets the constraints for the specified component. A copy of ! * the actual {@code GridBagConstraints} 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 */
*** 523,538 **** } /** * 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) { --- 523,538 ---- } /** * Retrieves the constraints for the specified component. * The return value is not a copy, but is the actual ! * {@code GridBagConstraints} object used by the layout mechanism. * <p> ! * If {@code comp} is not in the {@code GridBagLayout}, ! * a set of default {@code GridBagConstraints} are returned. ! * A {@code comp} value of {@code null} is invalid ! * and returns {@code null}. * * @param comp the component to be queried * @return the constraints for the specified component */ protected GridBagConstraints lookupConstraints(Component comp) {
*** 554,564 **** /** * 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 --- 554,564 ---- /** * 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} 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
*** 629,648 **** * minus 1) and its row index (ranging from 0 to the number of * rows minus 1). * <p> * If the <code>(x,&nbsp;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>,&nbsp;<i>y</i>). --- 629,648 ---- * minus 1) and its row index (ranging from 0 to the number of * rows minus 1). * <p> * If the <code>(x,&nbsp;y)</code> point lies * outside the grid, the following rules are used. ! * The column index is returned as zero if {@code x} 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} 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} lies above the ! * layout, and as the number of rows if {@code y} lies * below the layout. The orientation of a container is determined by its ! * {@code ComponentOrientation} 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>,&nbsp;<i>y</i>).
*** 690,707 **** 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) { --- 690,707 ---- public void addLayoutComponent(String name, Component comp) { } /** * Adds the specified component to the layout, using the specified ! * {@code constraints} 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} ! * is not a {@code GridBagConstraint} */ public void addLayoutComponent(Component comp, Object constraints) { if (constraints instanceof GridBagConstraints) { setConstraints(comp, (GridBagConstraints)constraints); } else if (constraints != null) {
*** 720,752 **** 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); } --- 720,752 ---- public void removeLayoutComponent(Component comp) { removeConstraints(comp); } /** ! * Determines the preferred size of the {@code parent} * 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} * container */ public Dimension preferredLayoutSize(Container parent) { GridBagLayoutInfo info = getLayoutInfo(parent, PREFERREDSIZE); return getMinSize(parent, info); } /** ! * Determines the minimum size of the {@code parent} 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} container */ public Dimension minimumLayoutSize(Container parent) { GridBagLayoutInfo info = getLayoutInfo(parent, MINSIZE); return getMinSize(parent, info); }
*** 769,779 **** * 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. * ! * @return the value <code>0.5f</code> to indicate centered */ public float getLayoutAlignmentX(Container parent) { return 0.5f; } --- 769,779 ---- * 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. * ! * @return the value {@code 0.5f} to indicate centered */ public float getLayoutAlignmentX(Container parent) { return 0.5f; }
*** 782,792 **** * 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. * ! * @return the value <code>0.5f</code> to indicate centered */ public float getLayoutAlignmentY(Container parent) { return 0.5f; } --- 782,792 ---- * 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. * ! * @return the value {@code 0.5f} to indicate centered */ public float getLayoutAlignmentY(Container parent) { return 0.5f; }
*** 798,808 **** } /** * 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 --- 798,808 ---- } /** * 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} * object. * <p> * Most applications do not call this method directly. * @param parent the container in which to do the layout * @see java.awt.Container
*** 888,898 **** * 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. --- 888,898 ---- * constraints.ipady); * } */ /** ! * Fills in an instance of {@code GridBagLayoutInfo} 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.
*** 902,917 **** * * 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); } --- 902,917 ---- * * 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}. * * @param parent the layout container ! * @param sizeflag either {@code PREFERREDSIZE} or ! * {@code MINSIZE} ! * @return the {@code GridBagLayoutInfo} for the set of children * @since 1.4 */ protected GridBagLayoutInfo getLayoutInfo(Container parent, int sizeflag) { return GetLayoutInfo(parent, sizeflag); }
*** 1603,1616 **** /** * 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); --- 1603,1616 ---- /** * 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}. * * @param constraints the constraints to be applied ! * @param r the {@code Rectangle} to be adjusted * @since 1.4 */ protected void adjustForGravity(GridBagConstraints constraints, Rectangle r) { AdjustForGravity(constraints, r);
*** 1622,1632 **** * <p> * 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> * * @param constraints the constraints to be applied * @param r the {@code Rectangle} to be adjusted */ protected void AdjustForGravity(GridBagConstraints constraints, --- 1622,1632 ---- * <p> * 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} * * @param constraints the constraints to be applied * @param r the {@code Rectangle} to be adjusted */ protected void AdjustForGravity(GridBagConstraints constraints,
*** 1985,2001 **** } } /** * 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); --- 1985,2001 ---- } } /** * Figures out the minimum size of the ! * master based on the information from {@code getLayoutInfo}. * This method should only be used internally by ! * {@code GridBagLayout}. * * @param parent the layout container * @param info the layout info for this parent ! * @return a {@code Dimension} object containing the * minimum size * @since 1.4 */ protected Dimension getMinSize(Container parent, GridBagLayoutInfo info) { return GetMinSize(parent, info);
*** 2003,2017 **** /** * 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> * * @param parent the layout container * @param info the layout info for this parent ! * @return a <code>Dimension</code> object containing the * minimum size */ protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info) { Dimension d = new Dimension(); int i, t; --- 2003,2017 ---- /** * 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} * * @param parent the layout container * @param info the layout info for this parent ! * @return a {@code Dimension} object containing the * minimum size */ protected Dimension GetMinSize(Container parent, GridBagLayoutInfo info) { Dimension d = new Dimension(); int i, t;
*** 2033,2043 **** 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) { --- 2033,2043 ---- transient boolean rightToLeft = false; /** * Lays out the grid. * This method should only be used internally by ! * {@code GridBagLayout}. * * @param parent the layout container * @since 1.4 */ protected void arrangeGrid(Container parent) {
*** 2046,2056 **** /** * 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> * * @param parent the layout container */ protected void ArrangeGrid(Container parent) { Component comp; --- 2046,2056 ---- /** * 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} * * @param parent the layout container */ protected void ArrangeGrid(Container parent) { Component comp;
< prev index next >