| /* GridBagLayout - Layout manager for components according to GridBagConstraints |
| Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath is free software; you can redistribute it and/or modify |
| it under the terms of the GNU General Public License as published by |
| the Free Software Foundation; either version 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| |
| |
| package java.awt; |
| |
| import java.io.Serializable; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| |
| /** |
| * @author Michael Koch (konqueror@gmx.de) |
| * @author Jeroen Frijters (jeroen@frijters.net) |
| * @author Andrew John Hughes (gnu_andrew@member.fsf.org) |
| */ |
| public class GridBagLayout |
| implements Serializable, LayoutManager2 |
| { |
| private static final long serialVersionUID = 8838754796412211005L; |
| |
| protected static final int MINSIZE = 1; |
| protected static final int PREFERREDSIZE = 2; |
| protected static final int MAXGRIDSIZE = 512; |
| |
| // comptable remembers the original contraints given to us. |
| // internalcomptable is used to keep track of modified constraint values |
| // that we calculate, particularly when we are given RELATIVE and |
| // REMAINDER constraints. |
| // Constraints kept in comptable are never modified, and constraints |
| // kept in internalcomptable can be modified internally only. |
| protected Hashtable<Component,GridBagConstraints> comptable; |
| private Hashtable<Component,GridBagConstraints> internalcomptable; |
| protected GridBagLayoutInfo layoutInfo; |
| protected GridBagConstraints defaultConstraints; |
| |
| public double[] columnWeights; |
| public int[] columnWidths; |
| public double[] rowWeights; |
| public int[] rowHeights; |
| |
| public GridBagLayout () |
| { |
| this.comptable = new Hashtable<Component,GridBagConstraints>(); |
| this.internalcomptable = new Hashtable<Component,GridBagConstraints>(); |
| this.defaultConstraints= new GridBagConstraints(); |
| } |
| |
| /** |
| * Helper method to calc the sum of a range of elements in an int array. |
| */ |
| private int sumIntArray (int[] array, int upto) |
| { |
| int result = 0; |
| |
| for (int i = 0; i < upto; i++) |
| result += array [i]; |
| |
| return result; |
| } |
| |
| /** |
| * Helper method to calc the sum of all elements in an int array. |
| */ |
| private int sumIntArray (int[] array) |
| { |
| return sumIntArray(array, array.length); |
| } |
| |
| /** |
| * Helper method to calc the sum of all elements in an double array. |
| */ |
| private double sumDoubleArray (double[] array) |
| { |
| double result = 0; |
| |
| for (int i = 0; i < array.length; i++) |
| result += array [i]; |
| |
| return result; |
| } |
| |
| public void addLayoutComponent (String name, Component component) |
| { |
| // do nothing here. |
| } |
| |
| public void removeLayoutComponent (Component component) |
| { |
| // do nothing here |
| } |
| |
| public void addLayoutComponent (Component component, Object constraints) |
| { |
| if (constraints == null) |
| return; |
| |
| if (!(constraints instanceof GridBagConstraints)) |
| throw new IllegalArgumentException("constraints " |
| + constraints |
| + " are not an instance of GridBagConstraints"); |
| |
| setConstraints (component, (GridBagConstraints) constraints); |
| } |
| |
| public Dimension preferredLayoutSize (Container parent) |
| { |
| if (parent == null) |
| return new Dimension (0, 0); |
| |
| GridBagLayoutInfo li = getLayoutInfo (parent, PREFERREDSIZE); |
| return getMinSize (parent, li); |
| } |
| |
| public Dimension minimumLayoutSize (Container parent) |
| { |
| if (parent == null) |
| return new Dimension (0, 0); |
| |
| GridBagLayoutInfo li = getLayoutInfo (parent, MINSIZE); |
| return getMinSize (parent, li); |
| } |
| |
| public Dimension maximumLayoutSize (Container target) |
| { |
| return new Dimension (Integer.MAX_VALUE, Integer.MAX_VALUE); |
| } |
| |
| public void layoutContainer (Container parent) |
| { |
| arrangeGrid (parent); |
| } |
| |
| public float getLayoutAlignmentX (Container target) |
| { |
| return Component.CENTER_ALIGNMENT; |
| } |
| |
| public float getLayoutAlignmentY (Container target) |
| { |
| return Component.CENTER_ALIGNMENT; |
| } |
| |
| public void invalidateLayout (Container target) |
| { |
| this.layoutInfo = null; |
| } |
| |
| public void setConstraints (Component component, |
| GridBagConstraints constraints) |
| { |
| GridBagConstraints clone = (GridBagConstraints) constraints.clone(); |
| |
| if (clone.gridx < 0) |
| clone.gridx = GridBagConstraints.RELATIVE; |
| |
| if (clone.gridy < 0) |
| clone.gridy = GridBagConstraints.RELATIVE; |
| |
| if (clone.gridwidth == 0) |
| clone.gridwidth = GridBagConstraints.REMAINDER; |
| else if (clone.gridwidth < 0) |
| clone.gridwidth = 1; |
| |
| if (clone.gridheight == 0) |
| clone.gridheight = GridBagConstraints.REMAINDER; |
| else if (clone.gridheight < 0) |
| clone.gridheight = 1; |
| |
| comptable.put (component, clone); |
| } |
| |
| public GridBagConstraints getConstraints (Component component) |
| { |
| return (GridBagConstraints) (lookupConstraints (component).clone()); |
| } |
| |
| protected GridBagConstraints lookupConstraints (Component component) |
| { |
| GridBagConstraints result = comptable.get (component); |
| |
| if (result == null) |
| { |
| setConstraints (component, defaultConstraints); |
| result = comptable.get (component); |
| } |
| |
| return result; |
| } |
| |
| private GridBagConstraints lookupInternalConstraints (Component component) |
| { |
| GridBagConstraints result = internalcomptable.get (component); |
| |
| if (result == null) |
| { |
| result = (GridBagConstraints) lookupConstraints(component).clone(); |
| internalcomptable.put (component, result); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * @since 1.1 |
| */ |
| public Point getLayoutOrigin () |
| { |
| if (layoutInfo == null) |
| return new Point (0, 0); |
| |
| return new Point (layoutInfo.pos_x, layoutInfo.pos_y); |
| } |
| |
| /** |
| * @since 1.1 |
| */ |
| public int[][] getLayoutDimensions () |
| { |
| int[][] result = new int [2][]; |
| if (layoutInfo == null) |
| { |
| result[0] = new int[0]; |
| result[1] = new int[0]; |
| |
| return result; |
| } |
| |
| result [0] = new int [layoutInfo.cols]; |
| System.arraycopy (layoutInfo.colWidths, 0, result [0], 0, layoutInfo.cols); |
| result [1] = new int [layoutInfo.rows]; |
| System.arraycopy (layoutInfo.rowHeights, 0, result [1], 0, layoutInfo.rows); |
| return result; |
| } |
| |
| public double[][] getLayoutWeights () |
| { |
| double[][] result = new double [2][]; |
| if (layoutInfo == null) |
| { |
| result[0] = new double[0]; |
| result[1] = new double[0]; |
| |
| return result; |
| } |
| |
| result [0] = new double [layoutInfo.cols]; |
| System.arraycopy (layoutInfo.colWeights, 0, result [0], 0, layoutInfo.cols); |
| result [1] = new double [layoutInfo.rows]; |
| System.arraycopy (layoutInfo.rowWeights, 0, result [1], 0, layoutInfo.rows); |
| return result; |
| } |
| |
| /** |
| * @since 1.1 |
| */ |
| public Point location (int x, int y) |
| { |
| if (layoutInfo == null) |
| return new Point (0, 0); |
| |
| int col; |
| int row; |
| int pixel_x = layoutInfo.pos_x; |
| int pixel_y = layoutInfo.pos_y; |
| |
| for (col = 0; col < layoutInfo.cols; col++) |
| { |
| int w = layoutInfo.colWidths [col]; |
| if (x < pixel_x + w) |
| break; |
| |
| pixel_x += w; |
| } |
| |
| for (row = 0; row < layoutInfo.rows; row++) |
| { |
| int h = layoutInfo.rowHeights [row]; |
| if (y < pixel_y + h) |
| break; |
| |
| pixel_y += h; |
| } |
| |
| return new Point (col, row); |
| } |
| |
| /** |
| * Return a string representation of this GridBagLayout. |
| * |
| * @return a string representation |
| */ |
| public String toString() |
| { |
| return getClass().getName(); |
| } |
| |
| /** |
| * Move and resize a rectangle according to a set of grid bag |
| * constraints. The x, y, width and height fields of the |
| * rectangle argument are adjusted to the new values. |
| * |
| * @param constraints position and size constraints |
| * @param r rectangle to be moved and resized |
| */ |
| protected void AdjustForGravity (GridBagConstraints constraints, |
| Rectangle r) |
| { |
| Insets insets = constraints.insets; |
| if (insets != null) |
| { |
| r.x += insets.left; |
| r.y += insets.top; |
| r.width -= insets.left + insets.right; |
| r.height -= insets.top + insets.bottom; |
| } |
| } |
| |
| /** |
| * Obsolete. |
| */ |
| protected void ArrangeGrid (Container parent) |
| { |
| Component[] components = parent.getComponents(); |
| |
| if (components.length == 0) |
| return; |
| |
| GridBagLayoutInfo info = getLayoutInfo (parent, PREFERREDSIZE); |
| if (info.cols == 0 && info.rows == 0) |
| return; |
| |
| // DEBUG |
| //dumpLayoutInfo (info); |
| |
| // Calling setBounds on these components causes this layout to |
| // be invalidated, clearing the layout information cache, |
| // layoutInfo. So we wait until after this for loop to set |
| // layoutInfo. |
| Component lastComp = null; |
| |
| Rectangle cell = new Rectangle(); |
| |
| for (int i = 0; i < components.length; i++) |
| { |
| Component component = components[i]; |
| |
| // If component is not visible we dont have to care about it. |
| if (! component.isVisible()) |
| continue; |
| |
| Dimension dim = component.getPreferredSize(); |
| GridBagConstraints constraints = lookupInternalConstraints(component); |
| |
| if (lastComp != null |
| && constraints.gridheight == GridBagConstraints.REMAINDER) |
| cell.y += cell.height; |
| else |
| cell.y = sumIntArray(info.rowHeights, constraints.gridy); |
| |
| if (lastComp != null |
| && constraints.gridwidth == GridBagConstraints.REMAINDER) |
| cell.x += cell.width; |
| else |
| cell.x = sumIntArray(info.colWidths, constraints.gridx); |
| |
| cell.width = sumIntArray(info.colWidths, constraints.gridx |
| + constraints.gridwidth) - cell.x; |
| cell.height = sumIntArray(info.rowHeights, constraints.gridy |
| + constraints.gridheight) - cell.y; |
| |
| // Adjust for insets. |
| AdjustForGravity( constraints, cell ); |
| |
| // Note: Documentation says that padding is added on both sides, but |
| // visual inspection shows that the Sun implementation only adds it |
| // once, so we do the same. |
| dim.width += constraints.ipadx; |
| dim.height += constraints.ipady; |
| |
| switch (constraints.fill) |
| { |
| case GridBagConstraints.HORIZONTAL: |
| dim.width = cell.width; |
| break; |
| case GridBagConstraints.VERTICAL: |
| dim.height = cell.height; |
| break; |
| case GridBagConstraints.BOTH: |
| dim.width = cell.width; |
| dim.height = cell.height; |
| break; |
| } |
| |
| int x = 0; |
| int y = 0; |
| |
| switch (constraints.anchor) |
| { |
| case GridBagConstraints.NORTH: |
| x = cell.x + (cell.width - dim.width) / 2; |
| y = cell.y; |
| break; |
| case GridBagConstraints.SOUTH: |
| x = cell.x + (cell.width - dim.width) / 2; |
| y = cell.y + cell.height - dim.height; |
| break; |
| case GridBagConstraints.WEST: |
| x = cell.x; |
| y = cell.y + (cell.height - dim.height) / 2; |
| break; |
| case GridBagConstraints.EAST: |
| x = cell.x + cell.width - dim.width; |
| y = cell.y + (cell.height - dim.height) / 2; |
| break; |
| case GridBagConstraints.NORTHEAST: |
| x = cell.x + cell.width - dim.width; |
| y = cell.y; |
| break; |
| case GridBagConstraints.NORTHWEST: |
| x = cell.x; |
| y = cell.y; |
| break; |
| case GridBagConstraints.SOUTHEAST: |
| x = cell.x + cell.width - dim.width; |
| y = cell.y + cell.height - dim.height; |
| break; |
| case GridBagConstraints.SOUTHWEST: |
| x = cell.x; |
| y = cell.y + cell.height - dim.height; |
| break; |
| default: |
| x = cell.x + (cell.width - dim.width) / 2; |
| y = cell.y + (cell.height - dim.height) / 2; |
| break; |
| } |
| component.setBounds(info.pos_x + x, info.pos_y + y, dim.width, |
| dim.height); |
| lastComp = component; |
| } |
| |
| // DEBUG |
| //dumpLayoutInfo(info); |
| |
| // Cache layout information. |
| layoutInfo = getLayoutInfo(parent, PREFERREDSIZE); |
| } |
| |
| /** |
| * Obsolete. |
| */ |
| protected GridBagLayoutInfo GetLayoutInfo (Container parent, int sizeflag) |
| { |
| if (sizeflag != MINSIZE && sizeflag != PREFERREDSIZE) |
| throw new IllegalArgumentException(); |
| |
| Dimension parentDim = parent.getSize (); |
| Insets parentInsets = parent.getInsets (); |
| parentDim.width -= parentInsets.left + parentInsets.right; |
| parentDim.height -= parentInsets.top + parentInsets.bottom; |
| |
| int current_y = 0; |
| int max_x = 0; |
| int max_y = 0; |
| |
| // Guaranteed to contain the last component added to the given row |
| // or column, whose gridwidth/height is not REMAINDER. |
| HashMap<Integer,Component> lastInRow = new HashMap<Integer,Component>(); |
| HashMap<Integer,Component> lastInCol = new HashMap<Integer,Component>(); |
| |
| Component[] components = parent.getComponents(); |
| |
| // Components sorted by gridwidths/heights, |
| // smallest to largest, with REMAINDER and RELATIVE at the end. |
| // These are useful when determining sizes and weights. |
| ArrayList<Component> sortedByWidth = |
| new ArrayList<Component>(components.length); |
| ArrayList<Component> sortedByHeight = |
| new ArrayList<Component>(components.length); |
| |
| // STEP 1: first we figure out how many rows/columns |
| for (int i = 0; i < components.length; i++) |
| { |
| Component component = components [i]; |
| // If component is not visible we dont have to care about it. |
| if (!component.isVisible()) |
| continue; |
| |
| // When looking up the constraint for the first time, check the |
| // original unmodified constraint. After the first time, always |
| // refer to the internal modified constraint. |
| GridBagConstraints originalConstraints = lookupConstraints (component); |
| GridBagConstraints constraints = (GridBagConstraints) originalConstraints.clone(); |
| internalcomptable.put(component, constraints); |
| |
| // Cases: |
| // |
| // 1. gridy == RELATIVE, gridx == RELATIVE |
| // |
| // use y as the row number; check for the next |
| // available slot at row y |
| // |
| // 2. only gridx == RELATIVE |
| // |
| // check for the next available slot at row gridy |
| // |
| // 3. only gridy == RELATIVE |
| // |
| // check for the next available slot at column gridx |
| // |
| // 4. neither gridx or gridy == RELATIVE |
| // |
| // nothing to check; just add it |
| |
| // cases 1 and 2 |
| if(constraints.gridx == GridBagConstraints.RELATIVE) |
| { |
| if (constraints.gridy == GridBagConstraints.RELATIVE) |
| constraints.gridy = current_y; |
| |
| int x; |
| |
| // Check the component that occupies the right-most spot in this |
| // row. We want to add this component after it. |
| // If this row is empty, add to the 0 position. |
| if (!lastInRow.containsKey(new Integer(constraints.gridy))) |
| x = 0; |
| else |
| { |
| Component lastComponent = lastInRow.get(new Integer(constraints.gridy)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| x = lastConstraints.gridx + Math.max(1, lastConstraints.gridwidth); |
| } |
| |
| // Determine if this component will fit in the slot vertically. |
| // If not, bump it over to where it does fit. |
| for (int y = constraints.gridy + 1; y < constraints.gridy + Math.max(1, constraints.gridheight); y++) |
| { |
| if (lastInRow.containsKey(new Integer(y))) |
| { |
| Component lastComponent = lastInRow.get(new Integer(y)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| x = Math.max (x, |
| lastConstraints.gridx + Math.max(1, lastConstraints.gridwidth)); |
| } |
| } |
| |
| constraints.gridx = x; |
| } |
| // case 3 |
| else if(constraints.gridy == GridBagConstraints.RELATIVE) |
| { |
| int y; |
| // Check the component that occupies the bottom-most spot in |
| // this column. We want to add this component below it. |
| // If this column is empty, add to the 0 position. |
| if (!lastInCol.containsKey(new Integer(constraints.gridx))) |
| { |
| y = current_y; |
| } |
| else |
| { |
| Component lastComponent = lastInCol.get(new Integer(constraints.gridx)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| y = lastConstraints.gridy + Math.max(1, lastConstraints.gridheight); |
| } |
| |
| // Determine if this component will fit in the slot horizontally. |
| // If not, bump it down to where it does fit. |
| for (int x = constraints.gridx + 1; x < constraints.gridx + Math.max(1, constraints.gridwidth); x++) |
| { |
| if (lastInCol.containsKey(new Integer(x))) |
| { |
| Component lastComponent = lastInCol.get(new Integer(x)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| y = Math.max (y, |
| lastConstraints.gridy + Math.max(1, lastConstraints.gridheight)); |
| } |
| } |
| |
| constraints.gridy = y; |
| } |
| // case 4: do nothing |
| |
| max_x = Math.max(max_x, |
| constraints.gridx + Math.max(1, constraints.gridwidth)); |
| max_y = Math.max(max_y, |
| constraints.gridy + Math.max(1, constraints.gridheight)); |
| |
| sortBySpan(component, constraints.gridwidth, sortedByWidth, true); |
| sortBySpan(component, constraints.gridheight, sortedByHeight, false); |
| |
| // Update our reference points for RELATIVE gridx and gridy. |
| if(constraints.gridwidth == GridBagConstraints.REMAINDER) |
| { |
| current_y = constraints.gridy + Math.max(1, constraints.gridheight); |
| } |
| else if (constraints.gridwidth != GridBagConstraints.REMAINDER) |
| { |
| for (int y = constraints.gridy; y < constraints.gridy + Math.max(1, constraints.gridheight); y++) |
| { |
| if(lastInRow.containsKey(new Integer(y))) |
| { |
| Component lastComponent = lastInRow.get(new Integer(y)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| if (constraints.gridx > lastConstraints.gridx) |
| { |
| lastInRow.put(new Integer(y), component); |
| } |
| } |
| else |
| { |
| lastInRow.put(new Integer(y), component); |
| } |
| } |
| |
| for (int x = constraints.gridx; x < constraints.gridx + Math.max(1, constraints.gridwidth); x++) |
| { |
| if(lastInCol.containsKey(new Integer(x))) |
| { |
| Component lastComponent = lastInCol.get(new Integer(x)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| if (constraints.gridy > lastConstraints.gridy) |
| { |
| lastInCol.put(new Integer(x), component); |
| } |
| } |
| else |
| { |
| lastInCol.put(new Integer(x), component); |
| } |
| } |
| } |
| } // end of STEP 1 |
| |
| GridBagLayoutInfo info = new GridBagLayoutInfo(max_x, max_y); |
| |
| // Check if column widths and row heights are overridden. |
| |
| for (int x = 0; x < max_x; x++) |
| { |
| if(columnWidths != null && columnWidths.length > x) |
| info.colWidths[x] = columnWidths[x]; |
| if(columnWeights != null && columnWeights.length > x) |
| info.colWeights[x] = columnWeights[x]; |
| } |
| |
| for (int y = 0; y < max_y; y++) |
| { |
| if(rowHeights != null && rowHeights.length > y) |
| info.rowHeights[y] = rowHeights[y]; |
| if(rowWeights != null && rowWeights.length > y) |
| info.rowWeights[y] = rowWeights[y]; |
| } |
| |
| // STEP 2: Fix up any cells with width/height as REMAINDER/RELATIVE. |
| for (int i = 0; i < components.length; i++) |
| { |
| Component component = components [i]; |
| |
| // If component is not visible we dont have to care about it. |
| if (!component.isVisible()) |
| continue; |
| |
| GridBagConstraints constraints = lookupInternalConstraints (component); |
| |
| if(constraints.gridwidth == GridBagConstraints.REMAINDER || constraints.gridwidth == GridBagConstraints.RELATIVE) |
| { |
| if(constraints.gridwidth == GridBagConstraints.REMAINDER) |
| { |
| for (int y = constraints.gridy; y < constraints.gridy + Math.max(1, constraints.gridheight); y++) |
| { |
| if (lastInRow.containsKey(new Integer(y))) |
| { |
| Component lastComponent = lastInRow.get(new Integer(y)); |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| |
| if (lastConstraints.gridwidth == GridBagConstraints.RELATIVE) |
| { |
| constraints.gridx = max_x - 1; |
| break; |
| } |
| else |
| { |
| constraints.gridx = Math.max (constraints.gridx, |
| lastConstraints.gridx + Math.max (1, lastConstraints.gridwidth)); |
| } |
| } |
| } |
| constraints.gridwidth = max_x - constraints.gridx; |
| } |
| else if (constraints.gridwidth == GridBagConstraints.RELATIVE) |
| { |
| constraints.gridwidth = max_x - constraints.gridx - 1; |
| } |
| |
| // Re-sort |
| sortedByWidth.remove(sortedByWidth.indexOf(component)); |
| sortBySpan(component, constraints.gridwidth, sortedByWidth, true); |
| } |
| |
| if(constraints.gridheight == GridBagConstraints.REMAINDER || constraints.gridheight == GridBagConstraints.RELATIVE) |
| { |
| if(constraints.gridheight == GridBagConstraints.REMAINDER) |
| { |
| for (int x = constraints.gridx; x < constraints.gridx + Math.max(1, constraints.gridwidth); x++) |
| { |
| if (lastInCol.containsKey(new Integer(x))) |
| { |
| Component lastComponent = lastInRow.get(new Integer(x)); |
| if (lastComponent != null) |
| { |
| GridBagConstraints lastConstraints = lookupInternalConstraints(lastComponent); |
| |
| if (lastConstraints.gridheight == GridBagConstraints.RELATIVE) |
| { |
| constraints.gridy = max_y - 1; |
| break; |
| } |
| else |
| { |
| constraints.gridy = Math.max (constraints.gridy, |
| lastConstraints.gridy + Math.max (1, lastConstraints.gridheight)); |
| } |
| } |
| } |
| } |
| constraints.gridheight = max_y - constraints.gridy; |
| } |
| else if (constraints.gridheight == GridBagConstraints.RELATIVE) |
| { |
| constraints.gridheight = max_y - constraints.gridy - 1; |
| } |
| |
| // Re-sort |
| sortedByHeight.remove(sortedByHeight.indexOf(component)); |
| sortBySpan(component, constraints.gridheight, sortedByHeight, false); |
| } |
| } // end of STEP 2 |
| |
| // STEP 3: Determine sizes and weights for columns. |
| for (int i = 0; i < sortedByWidth.size(); i++) |
| { |
| Component component = sortedByWidth.get(i); |
| |
| // If component is not visible we dont have to care about it. |
| if (!component.isVisible()) |
| continue; |
| |
| GridBagConstraints constraints = lookupInternalConstraints (component); |
| |
| int width = (sizeflag == PREFERREDSIZE) ? |
| component.getPreferredSize().width : |
| component.getMinimumSize().width; |
| |
| if(constraints.insets != null) |
| width += constraints.insets.left + constraints.insets.right; |
| |
| width += constraints.ipadx; |
| |
| distributeSizeAndWeight(width, |
| constraints.weightx, |
| constraints.gridx, |
| constraints.gridwidth, |
| info.colWidths, |
| info.colWeights); |
| } // end of STEP 3 |
| |
| // STEP 4: Determine sizes and weights for rows. |
| for (int i = 0; i < sortedByHeight.size(); i++) |
| { |
| Component component = sortedByHeight.get(i); |
| |
| // If component is not visible we dont have to care about it. |
| if (!component.isVisible()) |
| continue; |
| |
| GridBagConstraints constraints = lookupInternalConstraints (component); |
| |
| int height = (sizeflag == PREFERREDSIZE) ? |
| component.getPreferredSize().height : |
| component.getMinimumSize().height; |
| |
| if(constraints.insets != null) |
| height += constraints.insets.top + constraints.insets.bottom; |
| |
| height += constraints.ipady; |
| |
| distributeSizeAndWeight(height, |
| constraints.weighty, |
| constraints.gridy, |
| constraints.gridheight, |
| info.rowHeights, |
| info.rowWeights); |
| } // end of STEP 4 |
| |
| // Adjust cell sizes iff parent size not zero. |
| if (parentDim.width > 0 && parentDim.height > 0) |
| { |
| calcCellSizes (info.colWidths, info.colWeights, parentDim.width); |
| calcCellSizes (info.rowHeights, info.rowWeights, parentDim.height); |
| } |
| |
| int totalWidth = sumIntArray(info.colWidths); |
| int totalHeight = sumIntArray(info.rowHeights); |
| |
| // Make sure pos_x and pos_y are never negative. |
| if (totalWidth >= parentDim.width) |
| info.pos_x = parentInsets.left; |
| else |
| info.pos_x = parentInsets.left + (parentDim.width - totalWidth) / 2; |
| |
| if (totalHeight >= parentDim.height) |
| info.pos_y = parentInsets.top; |
| else |
| info.pos_y = parentInsets.top + (parentDim.height - totalHeight) / 2; |
| |
| // DEBUG |
| //dumpLayoutInfo (info); |
| |
| return info; |
| } |
| |
| /** |
| * Obsolete. |
| */ |
| protected Dimension GetMinSize (Container parent, GridBagLayoutInfo info) |
| { |
| if (parent == null || info == null) |
| return new Dimension (0, 0); |
| |
| Insets insets = parent.getInsets(); |
| int width = sumIntArray (info.colWidths) + insets.left + insets.right; |
| int height = sumIntArray (info.rowHeights) + insets.top + insets.bottom; |
| return new Dimension (width, height); |
| } |
| |
| /** |
| * @since 1.4 |
| */ |
| protected Dimension getMinSize (Container parent, GridBagLayoutInfo info) |
| { |
| return GetMinSize (parent, info); |
| } |
| |
| /** |
| * Helper method used by GetLayoutInfo to keep components sorted, either |
| * by gridwidth or gridheight. |
| * |
| * @param component Component to add to the sorted list. |
| * @param span Either the component's gridwidth or gridheight. |
| * @param list <code>ArrayList</code> of components, sorted by |
| * their span. |
| * @param sortByWidth Flag indicating sorting index. If true, sort by |
| * width. Otherwise, sort by height. |
| * FIXME: Use a better sorting algorithm. |
| */ |
| private void sortBySpan (Component component, int span, |
| ArrayList<Component> list, boolean sortByWidth) |
| { |
| if (span == GridBagConstraints.REMAINDER |
| || span == GridBagConstraints.RELATIVE) |
| { |
| // Put all RELATIVE and REMAINDER components at the end. |
| list.add(component); |
| } |
| else |
| { |
| int i = 0; |
| if (list.size() > 0) |
| { |
| GridBagConstraints gbc = lookupInternalConstraints(list.get(i)); |
| int otherspan = sortByWidth ? |
| gbc.gridwidth : |
| gbc.gridheight; |
| while (otherspan != GridBagConstraints.REMAINDER |
| && otherspan != GridBagConstraints.RELATIVE |
| && span >= otherspan) |
| { |
| i++; |
| if (i < list.size()) |
| { |
| gbc = lookupInternalConstraints(list.get(i)); |
| otherspan = sortByWidth ? |
| gbc.gridwidth : |
| gbc.gridheight; |
| } |
| else |
| break; |
| } |
| } |
| list.add(i, component); |
| } |
| } |
| |
| /** |
| * Helper method used by GetLayoutInfo to distribute a component's size |
| * and weight. |
| * |
| * @param size Preferred size of component, with inset and padding |
| * already added. |
| * @param weight Weight of component. |
| * @param start Starting position of component. Either |
| * constraints.gridx or gridy. |
| * @param span Span of component. either contraints.gridwidth or |
| * gridheight. |
| * @param sizes Sizes of rows or columns. |
| * @param weights Weights of rows or columns. |
| */ |
| private void distributeSizeAndWeight (int size, double weight, |
| int start, int span, |
| int[] sizes, double[] weights) |
| { |
| if (span == 1) |
| { |
| sizes[start] = Math.max(sizes[start], size); |
| weights[start] = Math.max(weights[start], weight); |
| } |
| else |
| { |
| int numOccupied = span; |
| int lastOccupied = -1; |
| |
| for(int i = start; i < start + span; i++) |
| { |
| if (sizes[i] == 0.0) |
| numOccupied--; |
| else |
| { |
| size -= sizes[i]; |
| lastOccupied = i; |
| } |
| } |
| |
| // A component needs to occupy at least one row. |
| if(numOccupied == 0) |
| sizes[start + span - 1] = size; |
| else if (size > 0) |
| sizes[lastOccupied] += size; |
| |
| calcCellWeights(weight, weights, start, span); |
| } |
| } |
| |
| /** |
| * Helper method used by GetLayoutInfo to calculate weight distribution. |
| * @param weight Weight of component. |
| * @param weights Weights of rows/columns. |
| * @param start Starting position of component in grid (gridx/gridy). |
| * @param span Span of component (gridwidth/gridheight). |
| */ |
| private void calcCellWeights (double weight, double[] weights, int start, int span) |
| { |
| double totalWeight = 0.0; |
| for(int k = start; k < start + span; k++) |
| totalWeight += weights[k]; |
| |
| if(weight > totalWeight) |
| { |
| if (totalWeight == 0.0) |
| { |
| weights[start + span - 1] += weight; |
| } |
| else |
| { |
| double diff = weight - totalWeight ; |
| double remaining = diff; |
| |
| for(int k = start; k < start + span; k++) |
| { |
| double extraWeight = diff * weights[k] / totalWeight; |
| weights[k] += extraWeight; |
| remaining -= extraWeight; |
| } |
| |
| if (remaining > 0.0 && weights[start + span - 1] != 0.0) |
| { |
| weights[start + span - 1] += remaining; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Helper method used by GetLayoutInfo to distribute extra space |
| * based on weight distribution. |
| * |
| * @param sizes Sizes of rows/columns. |
| * @param weights Weights of rows/columns. |
| * @param range Dimension of container. |
| */ |
| private void calcCellSizes (int[] sizes, double[] weights, int range) |
| { |
| int totalSize = sumIntArray (sizes); |
| double totalWeight = sumDoubleArray (weights); |
| |
| int diff = range - totalSize; |
| |
| if (diff == 0) |
| return; |
| |
| for (int i = 0; i < sizes.length; i++) |
| { |
| int newsize = (int) (sizes[i] + (((double) diff) * weights [i] / totalWeight )); |
| |
| if (newsize > 0) |
| sizes[i] = newsize; |
| } |
| } |
| |
| private void dumpLayoutInfo (GridBagLayoutInfo info) |
| { |
| System.out.println ("GridBagLayoutInfo:"); |
| System.out.println ("cols: " + info.cols + ", rows: " + info.rows); |
| System.out.print ("colWidths: "); |
| dumpArray(info.colWidths); |
| System.out.print ("rowHeights: "); |
| dumpArray(info.rowHeights); |
| System.out.print ("colWeights: "); |
| dumpArray(info.colWeights); |
| System.out.print ("rowWeights: "); |
| dumpArray(info.rowWeights); |
| } |
| |
| private void dumpArray(int[] array) |
| { |
| String sep = ""; |
| for(int i = 0; i < array.length; i++) |
| { |
| System.out.print(sep); |
| System.out.print(array[i]); |
| sep = ", "; |
| } |
| System.out.println(); |
| } |
| |
| private void dumpArray(double[] array) |
| { |
| String sep = ""; |
| for(int i = 0; i < array.length; i++) |
| { |
| System.out.print(sep); |
| System.out.print(array[i]); |
| sep = ", "; |
| } |
| System.out.println(); |
| } |
| |
| /** |
| * @since 1.4 |
| */ |
| protected void arrangeGrid (Container parent) |
| { |
| ArrangeGrid (parent); |
| } |
| |
| /** |
| * @since 1.4 |
| */ |
| protected GridBagLayoutInfo getLayoutInfo (Container parent, int sizeflag) |
| { |
| return GetLayoutInfo (parent, sizeflag); |
| } |
| |
| /** |
| * Move and resize a rectangle according to a set of grid bag |
| * constraints. The x, y, width and height fields of the |
| * rectangle argument are adjusted to the new values. |
| * |
| * @param constraints position and size constraints |
| * @param r rectangle to be moved and resized |
| * |
| * @since 1.4 |
| */ |
| protected void adjustForGravity (GridBagConstraints constraints, |
| Rectangle r) |
| { |
| AdjustForGravity (constraints, r); |
| } |
| } |
