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