home *** CD-ROM | disk | FTP | other *** search
/ PC Pro 1999 April / DPPCPRO0499.ISO / April / Notes / 50b2wic.exe / DATA1.CAB / NotesProgramFilesJavaSupport / rt.jar / java / awt / GridBagLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-04-23  |  10.0 KB  |  702 lines
  1. package java.awt;
  2.  
  3. import java.io.Serializable;
  4. import java.util.Hashtable;
  5.  
  6. public class GridBagLayout implements LayoutManager2, Serializable {
  7.    protected static final int MAXGRIDSIZE = 512;
  8.    protected static final int MINSIZE = 1;
  9.    protected static final int PREFERREDSIZE = 2;
  10.    protected Hashtable comptable = new Hashtable();
  11.    protected GridBagConstraints defaultConstraints = new GridBagConstraints();
  12.    protected GridBagLayoutInfo layoutInfo;
  13.    public int[] columnWidths;
  14.    public int[] rowHeights;
  15.    public double[] columnWeights;
  16.    public double[] rowWeights;
  17.  
  18.    public void setConstraints(Component var1, GridBagConstraints var2) {
  19.       this.comptable.put(var1, var2.clone());
  20.    }
  21.  
  22.    public GridBagConstraints getConstraints(Component var1) {
  23.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  24.       if (var2 == null) {
  25.          this.setConstraints(var1, this.defaultConstraints);
  26.          var2 = (GridBagConstraints)this.comptable.get(var1);
  27.       }
  28.  
  29.       return (GridBagConstraints)var2.clone();
  30.    }
  31.  
  32.    protected GridBagConstraints lookupConstraints(Component var1) {
  33.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  34.       if (var2 == null) {
  35.          this.setConstraints(var1, this.defaultConstraints);
  36.          var2 = (GridBagConstraints)this.comptable.get(var1);
  37.       }
  38.  
  39.       return var2;
  40.    }
  41.  
  42.    public Point getLayoutOrigin() {
  43.       Point var1 = new Point(0, 0);
  44.       if (this.layoutInfo != null) {
  45.          var1.x = this.layoutInfo.startx;
  46.          var1.y = this.layoutInfo.starty;
  47.       }
  48.  
  49.       return var1;
  50.    }
  51.  
  52.    public int[][] getLayoutDimensions() {
  53.       if (this.layoutInfo == null) {
  54.          return new int[2][0];
  55.       } else {
  56.          int[][] var1 = new int[][]{new int[this.layoutInfo.width], new int[this.layoutInfo.height]};
  57.          System.arraycopy(this.layoutInfo.minWidth, 0, var1[0], 0, this.layoutInfo.width);
  58.          System.arraycopy(this.layoutInfo.minHeight, 0, var1[1], 0, this.layoutInfo.height);
  59.          return var1;
  60.       }
  61.    }
  62.  
  63.    public double[][] getLayoutWeights() {
  64.       if (this.layoutInfo == null) {
  65.          return new double[2][0];
  66.       } else {
  67.          double[][] var1 = new double[][]{new double[this.layoutInfo.width], new double[this.layoutInfo.height]};
  68.          System.arraycopy(this.layoutInfo.weightX, 0, var1[0], 0, this.layoutInfo.width);
  69.          System.arraycopy(this.layoutInfo.weightY, 0, var1[1], 0, this.layoutInfo.height);
  70.          return var1;
  71.       }
  72.    }
  73.  
  74.    public Point location(int var1, int var2) {
  75.       Point var3 = new Point(0, 0);
  76.       if (this.layoutInfo == null) {
  77.          return var3;
  78.       } else {
  79.          int var5 = this.layoutInfo.startx;
  80.  
  81.          int var4;
  82.          for(var4 = 0; var4 < this.layoutInfo.width; ++var4) {
  83.             var5 += this.layoutInfo.minWidth[var4];
  84.             if (var5 > var1) {
  85.                break;
  86.             }
  87.          }
  88.  
  89.          var3.x = var4;
  90.          var5 = this.layoutInfo.starty;
  91.  
  92.          for(var4 = 0; var4 < this.layoutInfo.height; ++var4) {
  93.             var5 += this.layoutInfo.minHeight[var4];
  94.             if (var5 > var2) {
  95.                break;
  96.             }
  97.          }
  98.  
  99.          var3.y = var4;
  100.          return var3;
  101.       }
  102.    }
  103.  
  104.    public void addLayoutComponent(String var1, Component var2) {
  105.    }
  106.  
  107.    public void addLayoutComponent(Component var1, Object var2) {
  108.       if (var2 instanceof GridBagConstraints) {
  109.          this.setConstraints(var1, (GridBagConstraints)var2);
  110.       } else if (!(var2 instanceof String) && var2 != null) {
  111.          throw new IllegalArgumentException("cannot add to layout: constraint must be a GridBagConstraint");
  112.       }
  113.    }
  114.  
  115.    public void removeLayoutComponent(Component var1) {
  116.    }
  117.  
  118.    public Dimension preferredLayoutSize(Container var1) {
  119.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 2);
  120.       return this.GetMinSize(var1, var2);
  121.    }
  122.  
  123.    public Dimension minimumLayoutSize(Container var1) {
  124.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 1);
  125.       return this.GetMinSize(var1, var2);
  126.    }
  127.  
  128.    public Dimension maximumLayoutSize(Container var1) {
  129.       return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  130.    }
  131.  
  132.    public float getLayoutAlignmentX(Container var1) {
  133.       return 0.5F;
  134.    }
  135.  
  136.    public float getLayoutAlignmentY(Container var1) {
  137.       return 0.5F;
  138.    }
  139.  
  140.    public void invalidateLayout(Container var1) {
  141.    }
  142.  
  143.    public void layoutContainer(Container var1) {
  144.       this.ArrangeGrid(var1);
  145.    }
  146.  
  147.    public String toString() {
  148.       return this.getClass().getName();
  149.    }
  150.  
  151.    protected GridBagLayoutInfo GetLayoutInfo(Container var1, int var2) {
  152.       Object var4 = ((Component)var1).getTreeLock();
  153.       synchronized(var4){}
  154.  
  155.       GridBagLayoutInfo var3;
  156.       try {
  157.          GridBagLayoutInfo var6 = new GridBagLayoutInfo();
  158.          Component[] var10 = var1.getComponents();
  159.          var6.width = var6.height = 0;
  160.          int var23 = -1;
  161.          int var22 = -1;
  162.          int[] var28 = new int[512];
  163.          int[] var29 = new int[512];
  164.  
  165.          for(int var11 = 0; var11 < var10.length; ++var11) {
  166.             Component var7 = var10[var11];
  167.             if (var7.isVisible()) {
  168.                GridBagConstraints var8 = this.lookupConstraints(var7);
  169.                int var18 = var8.gridx;
  170.                int var19 = var8.gridy;
  171.                int var20 = var8.gridwidth;
  172.                if (var20 <= 0) {
  173.                   var20 = 1;
  174.                }
  175.  
  176.                int var21 = var8.gridheight;
  177.                if (var21 <= 0) {
  178.                   var21 = 1;
  179.                }
  180.  
  181.                if (var18 < 0 && var19 < 0) {
  182.                   if (var22 >= 0) {
  183.                      var19 = var22;
  184.                   } else if (var23 >= 0) {
  185.                      var18 = var23;
  186.                   } else {
  187.                      var19 = 0;
  188.                   }
  189.                }
  190.  
  191.                if (var18 < 0) {
  192.                   int var14 = 0;
  193.  
  194.                   for(int var42 = var19; var42 < var19 + var21; ++var42) {
  195.                      var14 = Math.max(var14, var28[var42]);
  196.                   }
  197.  
  198.                   var18 = var14 - var18 - 1;
  199.                   if (var18 < 0) {
  200.                      var18 = 0;
  201.                   }
  202.                } else if (var19 < 0) {
  203.                   int var15 = 0;
  204.  
  205.                   for(int var12 = var18; var12 < var18 + var20; ++var12) {
  206.                      var15 = Math.max(var15, var29[var12]);
  207.                   }
  208.  
  209.                   var19 = var15 - var19 - 1;
  210.                   if (var19 < 0) {
  211.                      var19 = 0;
  212.                   }
  213.                }
  214.  
  215.                int var61;
  216.                for(var61 = var18 + var20; var6.width < var61; ++var6.width) {
  217.                }
  218.  
  219.                int var65;
  220.                for(var65 = var19 + var21; var6.height < var65; ++var6.height) {
  221.                }
  222.  
  223.                for(int var43 = var18; var43 < var18 + var20; ++var43) {
  224.                   var29[var43] = var65;
  225.                }
  226.  
  227.                for(int var44 = var19; var44 < var19 + var21; ++var44) {
  228.                   var28[var44] = var61;
  229.                }
  230.  
  231.                Dimension var9;
  232.                if (var2 == 2) {
  233.                   var9 = var7.getPreferredSize();
  234.                } else {
  235.                   var9 = var7.getMinimumSize();
  236.                }
  237.  
  238.                var8.minWidth = var9.width;
  239.                var8.minHeight = var9.height;
  240.                if (var8.gridheight == 0 && var8.gridwidth == 0) {
  241.                   var23 = -1;
  242.                   var22 = -1;
  243.                }
  244.  
  245.                if (var8.gridheight == 0 && var22 < 0) {
  246.                   var23 = var18 + var20;
  247.                } else if (var8.gridwidth == 0 && var23 < 0) {
  248.                   var22 = var19 + var21;
  249.                }
  250.             }
  251.          }
  252.  
  253.          if (this.columnWidths != null && var6.width < this.columnWidths.length) {
  254.             var6.width = this.columnWidths.length;
  255.          }
  256.  
  257.          if (this.rowHeights != null && var6.height < this.rowHeights.length) {
  258.             var6.height = this.rowHeights.length;
  259.          }
  260.  
  261.          var23 = -1;
  262.          var22 = -1;
  263.          var28 = new int[512];
  264.          var29 = new int[512];
  265.  
  266.          for(int var40 = 0; var40 < var10.length; ++var40) {
  267.             Component var36 = var10[var40];
  268.             if (var36.isVisible()) {
  269.                GridBagConstraints var38 = this.lookupConstraints(var36);
  270.                int var70 = var38.gridx;
  271.                int var71 = var38.gridy;
  272.                int var72 = var38.gridwidth;
  273.                int var73 = var38.gridheight;
  274.                if (var70 < 0 && var71 < 0) {
  275.                   if (var22 >= 0) {
  276.                      var71 = var22;
  277.                   } else if (var23 >= 0) {
  278.                      var70 = var23;
  279.                   } else {
  280.                      var71 = 0;
  281.                   }
  282.                }
  283.  
  284.                if (var70 < 0) {
  285.                   if (var73 <= 0) {
  286.                      var73 += var6.height - var71;
  287.                      if (var73 < 1) {
  288.                         var73 = 1;
  289.                      }
  290.                   }
  291.  
  292.                   int var62 = 0;
  293.  
  294.                   for(int var46 = var71; var46 < var71 + var73; ++var46) {
  295.                      var62 = Math.max(var62, var28[var46]);
  296.                   }
  297.  
  298.                   var70 = var62 - var70 - 1;
  299.                   if (var70 < 0) {
  300.                      var70 = 0;
  301.                   }
  302.                } else if (var71 < 0) {
  303.                   if (var72 <= 0) {
  304.                      var72 += var6.width - var70;
  305.                      if (var72 < 1) {
  306.                         var72 = 1;
  307.                      }
  308.                   }
  309.  
  310.                   int var66 = 0;
  311.  
  312.                   for(int var45 = var70; var45 < var70 + var72; ++var45) {
  313.                      var66 = Math.max(var66, var29[var45]);
  314.                   }
  315.  
  316.                   var71 = var66 - var71 - 1;
  317.                   if (var71 < 0) {
  318.                      var71 = 0;
  319.                   }
  320.                }
  321.  
  322.                if (var72 <= 0) {
  323.                   var72 += var6.width - var70;
  324.                   if (var72 < 1) {
  325.                      var72 = 1;
  326.                   }
  327.                }
  328.  
  329.                if (var73 <= 0) {
  330.                   var73 += var6.height - var71;
  331.                   if (var73 < 1) {
  332.                      var73 = 1;
  333.                   }
  334.                }
  335.  
  336.                int var63 = var70 + var72;
  337.                int var67 = var71 + var73;
  338.  
  339.                for(int var47 = var70; var47 < var70 + var72; ++var47) {
  340.                   var29[var47] = var67;
  341.                }
  342.  
  343.                for(int var48 = var71; var48 < var71 + var73; ++var48) {
  344.                   var28[var48] = var63;
  345.                }
  346.  
  347.                if (var38.gridheight == 0 && var38.gridwidth == 0) {
  348.                   var23 = -1;
  349.                   var22 = -1;
  350.                }
  351.  
  352.                if (var38.gridheight == 0 && var22 < 0) {
  353.                   var23 = var70 + var72;
  354.                } else if (var38.gridwidth == 0 && var23 < 0) {
  355.                   var22 = var71 + var73;
  356.                }
  357.  
  358.                var38.tempX = var70;
  359.                var38.tempY = var71;
  360.                var38.tempWidth = var72;
  361.                var38.tempHeight = var73;
  362.             }
  363.          }
  364.  
  365.          if (this.columnWidths != null) {
  366.             System.arraycopy(this.columnWidths, 0, var6.minWidth, 0, this.columnWidths.length);
  367.          }
  368.  
  369.          if (this.rowHeights != null) {
  370.             System.arraycopy(this.rowHeights, 0, var6.minHeight, 0, this.rowHeights.length);
  371.          }
  372.  
  373.          if (this.columnWeights != null) {
  374.             System.arraycopy(this.columnWeights, 0, var6.weightX, 0, this.columnWeights.length);
  375.          }
  376.  
  377.          if (this.rowWeights != null) {
  378.             System.arraycopy(this.rowWeights, 0, var6.weightY, 0, this.rowWeights.length);
  379.          }
  380.  
  381.          int var17 = Integer.MAX_VALUE;
  382.  
  383.          for(int var49 = 1; var49 != Integer.MAX_VALUE; var17 = Integer.MAX_VALUE) {
  384.             for(int var41 = 0; var41 < var10.length; ++var41) {
  385.                Component var37 = var10[var41];
  386.                if (var37.isVisible()) {
  387.                   GridBagConstraints var39 = this.lookupConstraints(var37);
  388.                   if (var39.tempWidth == var49) {
  389.                      int var64 = var39.tempX + var39.tempWidth;
  390.                      double var24 = var39.weightx;
  391.  
  392.                      for(int var13 = var39.tempX; var13 < var64; ++var13) {
  393.                         var24 -= var6.weightX[var13];
  394.                      }
  395.  
  396.                      if (var24 > (double)0.0F) {
  397.                         double var26 = (double)0.0F;
  398.  
  399.                         for(int var50 = var39.tempX; var50 < var64; ++var50) {
  400.                            var26 += var6.weightX[var50];
  401.                         }
  402.  
  403.                         for(int var51 = var39.tempX; var26 > (double)0.0F && var51 < var64; ++var51) {
  404.                            double var30 = var6.weightX[var51];
  405.                            double var32 = var30 * var24 / var26;
  406.                            double[] var10000 = var6.weightX;
  407.                            var10000[var51] += var32;
  408.                            var24 -= var32;
  409.                            var26 -= var30;
  410.                         }
  411.  
  412.                         double[] var88 = var6.weightX;
  413.                         var88[var64 - 1] += var24;
  414.                      }
  415.  
  416.                      int var16 = var39.minWidth + var39.ipadx + var39.insets.left + var39.insets.right;
  417.  
  418.                      for(int var52 = var39.tempX; var52 < var64; ++var52) {
  419.                         var16 -= var6.minWidth[var52];
  420.                      }
  421.  
  422.                      if (var16 > 0) {
  423.                         double var77 = (double)0.0F;
  424.  
  425.                         for(int var53 = var39.tempX; var53 < var64; ++var53) {
  426.                            var77 += var6.weightX[var53];
  427.                         }
  428.  
  429.                         for(int var54 = var39.tempX; var77 > (double)0.0F && var54 < var64; ++var54) {
  430.                            double var82 = var6.weightX[var54];
  431.                            int var85 = (int)(var82 * (double)var16 / var77);
  432.                            int[] var89 = var6.minWidth;
  433.                            var89[var54] += var85;
  434.                            var16 -= var85;
  435.                            var77 -= var82;
  436.                         }
  437.  
  438.                         int[] var90 = var6.minWidth;
  439.                         var90[var64 - 1] += var16;
  440.                      }
  441.                   } else if (var39.tempWidth > var49 && var39.tempWidth < var17) {
  442.                      var17 = var39.tempWidth;
  443.                   }
  444.  
  445.                   if (var39.tempHeight != var49) {
  446.                      if (var39.tempHeight > var49 && var39.tempHeight < var17) {
  447.                         var17 = var39.tempHeight;
  448.                      }
  449.                   } else {
  450.                      int var68 = var39.tempY + var39.tempHeight;
  451.                      double var76 = var39.weighty;
  452.  
  453.                      for(int var55 = var39.tempY; var55 < var68; ++var55) {
  454.                         var76 -= var6.weightY[var55];
  455.                      }
  456.  
  457.                      if (var76 > (double)0.0F) {
  458.                         double var78 = (double)0.0F;
  459.  
  460.                         for(int var56 = var39.tempY; var56 < var68; ++var56) {
  461.                            var78 += var6.weightY[var56];
  462.                         }
  463.  
  464.                         for(int var57 = var39.tempY; var78 > (double)0.0F && var57 < var68; ++var57) {
  465.                            double var83 = var6.weightY[var57];
  466.                            double var86 = var83 * var76 / var78;
  467.                            double[] var91 = var6.weightY;
  468.                            var91[var57] += var86;
  469.                            var76 -= var86;
  470.                            var78 -= var83;
  471.                         }
  472.  
  473.                         double[] var92 = var6.weightY;
  474.                         var92[var68 - 1] += var76;
  475.                      }
  476.  
  477.                      int var69 = var39.minHeight + var39.ipady + var39.insets.top + var39.insets.bottom;
  478.  
  479.                      for(int var58 = var39.tempY; var58 < var68; ++var58) {
  480.                         var69 -= var6.minHeight[var58];
  481.                      }
  482.  
  483.                      if (var69 > 0) {
  484.                         double var79 = (double)0.0F;
  485.  
  486.                         for(int var59 = var39.tempY; var59 < var68; ++var59) {
  487.                            var79 += var6.weightY[var59];
  488.                         }
  489.  
  490.                         for(int var60 = var39.tempY; var79 > (double)0.0F && var60 < var68; ++var60) {
  491.                            double var84 = var6.weightY[var60];
  492.                            int var87 = (int)(var84 * (double)var69 / var79);
  493.                            int[] var93 = var6.minHeight;
  494.                            var93[var60] += var87;
  495.                            var69 -= var87;
  496.                            var79 -= var84;
  497.                         }
  498.  
  499.                         int[] var94 = var6.minHeight;
  500.                         var94[var68 - 1] += var69;
  501.                      }
  502.                   }
  503.                }
  504.             }
  505.  
  506.             var49 = var17;
  507.          }
  508.  
  509.          var3 = var6;
  510.       } catch (Throwable var35) {
  511.          throw var35;
  512.       }
  513.  
  514.       return var3;
  515.    }
  516.  
  517.    protected void AdjustForGravity(GridBagConstraints var1, Rectangle var2) {
  518.       var2.x += var1.insets.left;
  519.       var2.width -= var1.insets.left + var1.insets.right;
  520.       var2.y += var1.insets.top;
  521.       var2.height -= var1.insets.top + var1.insets.bottom;
  522.       int var3 = 0;
  523.       if (var1.fill != 2 && var1.fill != 1 && var2.width > var1.minWidth + var1.ipadx) {
  524.          var3 = var2.width - (var1.minWidth + var1.ipadx);
  525.          var2.width = var1.minWidth + var1.ipadx;
  526.       }
  527.  
  528.       int var4 = 0;
  529.       if (var1.fill != 3 && var1.fill != 1 && var2.height > var1.minHeight + var1.ipady) {
  530.          var4 = var2.height - (var1.minHeight + var1.ipady);
  531.          var2.height = var1.minHeight + var1.ipady;
  532.       }
  533.  
  534.       switch (var1.anchor) {
  535.          case 10:
  536.             var2.x += var3 / 2;
  537.             var2.y += var4 / 2;
  538.             return;
  539.          case 11:
  540.             var2.x += var3 / 2;
  541.             return;
  542.          case 12:
  543.             var2.x += var3;
  544.             return;
  545.          case 13:
  546.             var2.x += var3;
  547.             var2.y += var4 / 2;
  548.             return;
  549.          case 14:
  550.             var2.x += var3;
  551.             var2.y += var4;
  552.             return;
  553.          case 15:
  554.             var2.x += var3 / 2;
  555.             var2.y += var4;
  556.             return;
  557.          case 16:
  558.             var2.y += var4;
  559.             return;
  560.          case 17:
  561.             var2.y += var4 / 2;
  562.             return;
  563.          case 18:
  564.             return;
  565.          default:
  566.             throw new IllegalArgumentException("illegal anchor value");
  567.       }
  568.    }
  569.  
  570.    protected Dimension GetMinSize(Container var1, GridBagLayoutInfo var2) {
  571.       Dimension var3 = new Dimension();
  572.       Insets var6 = var1.getInsets();
  573.       int var5 = 0;
  574.  
  575.       for(int var4 = 0; var4 < var2.width; ++var4) {
  576.          var5 += var2.minWidth[var4];
  577.       }
  578.  
  579.       var3.width = var5 + var6.left + var6.right;
  580.       var5 = 0;
  581.  
  582.       for(int var7 = 0; var7 < var2.height; ++var7) {
  583.          var5 += var2.minHeight[var7];
  584.       }
  585.  
  586.       var3.height = var5 + var6.top + var6.bottom;
  587.       return var3;
  588.    }
  589.  
  590.    protected void ArrangeGrid(Container var1) {
  591.       Insets var5 = var1.getInsets();
  592.       Component[] var6 = var1.getComponents();
  593.       Rectangle var8 = new Rectangle();
  594.       if (var6.length != 0 || this.columnWidths != null && this.columnWidths.length != 0 || this.rowHeights != null && this.rowHeights.length != 0) {
  595.          GridBagLayoutInfo var14 = this.GetLayoutInfo(var1, 2);
  596.          Dimension var7 = this.GetMinSize(var1, var14);
  597.          if (var1.width < var7.width || var1.height < var7.height) {
  598.             var14 = this.GetLayoutInfo(var1, 1);
  599.             var7 = this.GetMinSize(var1, var14);
  600.          }
  601.  
  602.          this.layoutInfo = var14;
  603.          var8.width = var7.width;
  604.          var8.height = var7.height;
  605.          int var10 = var1.width - var8.width;
  606.          if (var10 != 0) {
  607.             double var12 = (double)0.0F;
  608.  
  609.             for(int var9 = 0; var9 < var14.width; ++var9) {
  610.                var12 += var14.weightX[var9];
  611.             }
  612.  
  613.             if (var12 > (double)0.0F) {
  614.                for(int var16 = 0; var16 < var14.width; ++var16) {
  615.                   int var15 = (int)((double)var10 * var14.weightX[var16] / var12);
  616.                   int[] var10000 = var14.minWidth;
  617.                   var10000[var16] += var15;
  618.                   var8.width += var15;
  619.                   if (var14.minWidth[var16] < 0) {
  620.                      var8.width -= var14.minWidth[var16];
  621.                      var14.minWidth[var16] = 0;
  622.                   }
  623.                }
  624.             }
  625.  
  626.             var10 = var1.width - var8.width;
  627.          } else {
  628.             var10 = 0;
  629.          }
  630.  
  631.          int var11 = var1.height - var8.height;
  632.          if (var11 != 0) {
  633.             double var25 = (double)0.0F;
  634.  
  635.             for(int var17 = 0; var17 < var14.height; ++var17) {
  636.                var25 += var14.weightY[var17];
  637.             }
  638.  
  639.             if (var25 > (double)0.0F) {
  640.                for(int var18 = 0; var18 < var14.height; ++var18) {
  641.                   int var26 = (int)((double)var11 * var14.weightY[var18] / var25);
  642.                   int[] var27 = var14.minHeight;
  643.                   var27[var18] += var26;
  644.                   var8.height += var26;
  645.                   if (var14.minHeight[var18] < 0) {
  646.                      var8.height -= var14.minHeight[var18];
  647.                      var14.minHeight[var18] = 0;
  648.                   }
  649.                }
  650.             }
  651.  
  652.             var11 = var1.height - var8.height;
  653.          } else {
  654.             var11 = 0;
  655.          }
  656.  
  657.          var14.startx = var10 / 2 + var5.left;
  658.          var14.starty = var11 / 2 + var5.top;
  659.  
  660.          for(int var3 = 0; var3 < var6.length; ++var3) {
  661.             Component var2 = var6[var3];
  662.             if (var2.isVisible()) {
  663.                GridBagConstraints var4 = this.lookupConstraints(var2);
  664.                var8.x = var14.startx;
  665.  
  666.                for(int var19 = 0; var19 < var4.tempX; ++var19) {
  667.                   var8.x += var14.minWidth[var19];
  668.                }
  669.  
  670.                var8.y = var14.starty;
  671.  
  672.                for(int var20 = 0; var20 < var4.tempY; ++var20) {
  673.                   var8.y += var14.minHeight[var20];
  674.                }
  675.  
  676.                var8.width = 0;
  677.  
  678.                for(int var21 = var4.tempX; var21 < var4.tempX + var4.tempWidth; ++var21) {
  679.                   var8.width += var14.minWidth[var21];
  680.                }
  681.  
  682.                var8.height = 0;
  683.  
  684.                for(int var22 = var4.tempY; var22 < var4.tempY + var4.tempHeight; ++var22) {
  685.                   var8.height += var14.minHeight[var22];
  686.                }
  687.  
  688.                this.AdjustForGravity(var4, var8);
  689.                if (var8.width > 0 && var8.height > 0) {
  690.                   if (var2.x != var8.x || var2.y != var8.y || var2.width != var8.width || var2.height != var8.height) {
  691.                      var2.setBounds(var8.x, var8.y, var8.width, var8.height);
  692.                   }
  693.                } else {
  694.                   var2.setBounds(0, 0, 0, 0);
  695.                }
  696.             }
  697.          }
  698.  
  699.       }
  700.    }
  701. }
  702.