y = 0;
{ y = current_y; }
    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 lastInRow = new HashMap();      HashMap lastInCol = new HashMap();      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 sortedByWidth = new ArrayList(components.length);      ArrayList sortedByHeight = new ArrayList(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 = (Component) 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 = (Component) 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 = 0;              else                {                  Component lastComponent = (Component)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 = (Component) 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 = (Component) 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 = (Component) 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 = (Component) 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 = (Component) 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 = (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 = (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;    }