obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 1114 insertions, 0 deletions

diff --git a/libjava/classpath/java/awt/GridBagLayout.java b/libjava/classpath/java/awt/GridBagLayout.java
new file mode 100644
index 000000000..224d53ff2
--- /dev/null
+++ b/libjava/classpath/java/awt/GridBagLayout.java
@@ -0,0 +1,1114 @@
+/* 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);
+    }
+}