home *** CD-ROM | disk | FTP | other *** search
/ Chip 2001 June / CHIPHEFT062001.ISO / browser / nc32lyc / comm.z / java40.jar / java / awt / GridBagLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  2000-08-15  |  9.9 KB  |  692 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.       GridBagLayoutInfo var3 = new GridBagLayoutInfo();
  153.       Component[] var7 = var1.getComponents();
  154.       var3.width = var3.height = 0;
  155.       int var20 = -1;
  156.       int var19 = -1;
  157.       int[] var25 = new int[512];
  158.       int[] var26 = new int[512];
  159.  
  160.       for(int var8 = 0; var8 < var7.length; ++var8) {
  161.          Component var4 = var7[var8];
  162.          if (var4.isVisible()) {
  163.             GridBagConstraints var5 = this.lookupConstraints(var4);
  164.             int var15 = var5.gridx;
  165.             int var16 = var5.gridy;
  166.             int var17 = var5.gridwidth;
  167.             if (var17 <= 0) {
  168.                var17 = 1;
  169.             }
  170.  
  171.             int var18 = var5.gridheight;
  172.             if (var18 <= 0) {
  173.                var18 = 1;
  174.             }
  175.  
  176.             if (var15 < 0 && var16 < 0) {
  177.                if (var19 >= 0) {
  178.                   var16 = var19;
  179.                } else if (var20 >= 0) {
  180.                   var15 = var20;
  181.                } else {
  182.                   var16 = 0;
  183.                }
  184.             }
  185.  
  186.             if (var15 < 0) {
  187.                int var11 = 0;
  188.  
  189.                for(int var9 = var16; var9 < var16 + var18; ++var9) {
  190.                   var11 = Math.max(var11, var25[var9]);
  191.                }
  192.  
  193.                var15 = var11 - var15 - 1;
  194.                if (var15 < 0) {
  195.                   var15 = 0;
  196.                }
  197.             } else if (var16 < 0) {
  198.                int var12 = 0;
  199.  
  200.                for(int var37 = var15; var37 < var15 + var17; ++var37) {
  201.                   var12 = Math.max(var12, var26[var37]);
  202.                }
  203.  
  204.                var16 = var12 - var16 - 1;
  205.                if (var16 < 0) {
  206.                   var16 = 0;
  207.                }
  208.             }
  209.  
  210.             int var56;
  211.             for(var56 = var15 + var17; var3.width < var56; ++var3.width) {
  212.             }
  213.  
  214.             int var60;
  215.             for(var60 = var16 + var18; var3.height < var60; ++var3.height) {
  216.             }
  217.  
  218.             for(int var38 = var15; var38 < var15 + var17; ++var38) {
  219.                var26[var38] = var60;
  220.             }
  221.  
  222.             for(int var39 = var16; var39 < var16 + var18; ++var39) {
  223.                var25[var39] = var56;
  224.             }
  225.  
  226.             Dimension var6;
  227.             if (var2 == 2) {
  228.                var6 = var4.getPreferredSize();
  229.             } else {
  230.                var6 = var4.getMinimumSize();
  231.             }
  232.  
  233.             var5.minWidth = var6.width;
  234.             var5.minHeight = var6.height;
  235.             if (var5.gridheight == 0 && var5.gridwidth == 0) {
  236.                var20 = -1;
  237.                var19 = -1;
  238.             }
  239.  
  240.             if (var5.gridheight == 0 && var19 < 0) {
  241.                var20 = var15 + var17;
  242.             } else if (var5.gridwidth == 0 && var20 < 0) {
  243.                var19 = var16 + var18;
  244.             }
  245.          }
  246.       }
  247.  
  248.       if (this.columnWidths != null && var3.width < this.columnWidths.length) {
  249.          var3.width = this.columnWidths.length;
  250.       }
  251.  
  252.       if (this.rowHeights != null && var3.height < this.rowHeights.length) {
  253.          var3.height = this.rowHeights.length;
  254.       }
  255.  
  256.       var20 = -1;
  257.       var19 = -1;
  258.       var25 = new int[512];
  259.       var26 = new int[512];
  260.  
  261.       for(int var35 = 0; var35 < var7.length; ++var35) {
  262.          Component var31 = var7[var35];
  263.          if (var31.isVisible()) {
  264.             GridBagConstraints var33 = this.lookupConstraints(var31);
  265.             int var65 = var33.gridx;
  266.             int var66 = var33.gridy;
  267.             int var67 = var33.gridwidth;
  268.             int var68 = var33.gridheight;
  269.             if (var65 < 0 && var66 < 0) {
  270.                if (var19 >= 0) {
  271.                   var66 = var19;
  272.                } else if (var20 >= 0) {
  273.                   var65 = var20;
  274.                } else {
  275.                   var66 = 0;
  276.                }
  277.             }
  278.  
  279.             if (var65 < 0) {
  280.                if (var68 <= 0) {
  281.                   var68 += var3.height - var66;
  282.                   if (var68 < 1) {
  283.                      var68 = 1;
  284.                   }
  285.                }
  286.  
  287.                int var57 = 0;
  288.  
  289.                for(int var40 = var66; var40 < var66 + var68; ++var40) {
  290.                   var57 = Math.max(var57, var25[var40]);
  291.                }
  292.  
  293.                var65 = var57 - var65 - 1;
  294.                if (var65 < 0) {
  295.                   var65 = 0;
  296.                }
  297.             } else if (var66 < 0) {
  298.                if (var67 <= 0) {
  299.                   var67 += var3.width - var65;
  300.                   if (var67 < 1) {
  301.                      var67 = 1;
  302.                   }
  303.                }
  304.  
  305.                int var61 = 0;
  306.  
  307.                for(int var41 = var65; var41 < var65 + var67; ++var41) {
  308.                   var61 = Math.max(var61, var26[var41]);
  309.                }
  310.  
  311.                var66 = var61 - var66 - 1;
  312.                if (var66 < 0) {
  313.                   var66 = 0;
  314.                }
  315.             }
  316.  
  317.             if (var67 <= 0) {
  318.                var67 += var3.width - var65;
  319.                if (var67 < 1) {
  320.                   var67 = 1;
  321.                }
  322.             }
  323.  
  324.             if (var68 <= 0) {
  325.                var68 += var3.height - var66;
  326.                if (var68 < 1) {
  327.                   var68 = 1;
  328.                }
  329.             }
  330.  
  331.             int var58 = var65 + var67;
  332.             int var62 = var66 + var68;
  333.  
  334.             for(int var42 = var65; var42 < var65 + var67; ++var42) {
  335.                var26[var42] = var62;
  336.             }
  337.  
  338.             for(int var43 = var66; var43 < var66 + var68; ++var43) {
  339.                var25[var43] = var58;
  340.             }
  341.  
  342.             if (var33.gridheight == 0 && var33.gridwidth == 0) {
  343.                var20 = -1;
  344.                var19 = -1;
  345.             }
  346.  
  347.             if (var33.gridheight == 0 && var19 < 0) {
  348.                var20 = var65 + var67;
  349.             } else if (var33.gridwidth == 0 && var20 < 0) {
  350.                var19 = var66 + var68;
  351.             }
  352.  
  353.             var33.tempX = var65;
  354.             var33.tempY = var66;
  355.             var33.tempWidth = var67;
  356.             var33.tempHeight = var68;
  357.          }
  358.       }
  359.  
  360.       if (this.columnWidths != null) {
  361.          System.arraycopy(this.columnWidths, 0, var3.minWidth, 0, this.columnWidths.length);
  362.       }
  363.  
  364.       if (this.rowHeights != null) {
  365.          System.arraycopy(this.rowHeights, 0, var3.minHeight, 0, this.rowHeights.length);
  366.       }
  367.  
  368.       if (this.columnWeights != null) {
  369.          System.arraycopy(this.columnWeights, 0, var3.weightX, 0, this.columnWeights.length);
  370.       }
  371.  
  372.       if (this.rowWeights != null) {
  373.          System.arraycopy(this.rowWeights, 0, var3.weightY, 0, this.rowWeights.length);
  374.       }
  375.  
  376.       int var14 = Integer.MAX_VALUE;
  377.  
  378.       for(int var44 = 1; var44 != Integer.MAX_VALUE; var14 = Integer.MAX_VALUE) {
  379.          for(int var36 = 0; var36 < var7.length; ++var36) {
  380.             Component var32 = var7[var36];
  381.             if (var32.isVisible()) {
  382.                GridBagConstraints var34 = this.lookupConstraints(var32);
  383.                if (var34.tempWidth == var44) {
  384.                   int var59 = var34.tempX + var34.tempWidth;
  385.                   double var21 = var34.weightx;
  386.  
  387.                   for(int var10 = var34.tempX; var10 < var59; ++var10) {
  388.                      var21 -= var3.weightX[var10];
  389.                   }
  390.  
  391.                   if (var21 > (double)0.0F) {
  392.                      double var23 = (double)0.0F;
  393.  
  394.                      for(int var45 = var34.tempX; var45 < var59; ++var45) {
  395.                         var23 += var3.weightX[var45];
  396.                      }
  397.  
  398.                      for(int var46 = var34.tempX; var23 > (double)0.0F && var46 < var59; ++var46) {
  399.                         double var27 = var3.weightX[var46];
  400.                         double var29 = var27 * var21 / var23;
  401.                         double[] var10000 = var3.weightX;
  402.                         var10000[var46] += var29;
  403.                         var21 -= var29;
  404.                         var23 -= var27;
  405.                      }
  406.  
  407.                      double[] var83 = var3.weightX;
  408.                      var83[var59 - 1] += var21;
  409.                   }
  410.  
  411.                   int var13 = var34.minWidth + var34.ipadx + var34.insets.left + var34.insets.right;
  412.  
  413.                   for(int var47 = var34.tempX; var47 < var59; ++var47) {
  414.                      var13 -= var3.minWidth[var47];
  415.                   }
  416.  
  417.                   if (var13 > 0) {
  418.                      double var72 = (double)0.0F;
  419.  
  420.                      for(int var48 = var34.tempX; var48 < var59; ++var48) {
  421.                         var72 += var3.weightX[var48];
  422.                      }
  423.  
  424.                      for(int var49 = var34.tempX; var72 > (double)0.0F && var49 < var59; ++var49) {
  425.                         double var77 = var3.weightX[var49];
  426.                         int var80 = (int)(var77 * (double)var13 / var72);
  427.                         int[] var84 = var3.minWidth;
  428.                         var84[var49] += var80;
  429.                         var13 -= var80;
  430.                         var72 -= var77;
  431.                      }
  432.  
  433.                      int[] var85 = var3.minWidth;
  434.                      var85[var59 - 1] += var13;
  435.                   }
  436.                } else if (var34.tempWidth > var44 && var34.tempWidth < var14) {
  437.                   var14 = var34.tempWidth;
  438.                }
  439.  
  440.                if (var34.tempHeight != var44) {
  441.                   if (var34.tempHeight > var44 && var34.tempHeight < var14) {
  442.                      var14 = var34.tempHeight;
  443.                   }
  444.                } else {
  445.                   int var63 = var34.tempY + var34.tempHeight;
  446.                   double var71 = var34.weighty;
  447.  
  448.                   for(int var50 = var34.tempY; var50 < var63; ++var50) {
  449.                      var71 -= var3.weightY[var50];
  450.                   }
  451.  
  452.                   if (var71 > (double)0.0F) {
  453.                      double var73 = (double)0.0F;
  454.  
  455.                      for(int var51 = var34.tempY; var51 < var63; ++var51) {
  456.                         var73 += var3.weightY[var51];
  457.                      }
  458.  
  459.                      for(int var52 = var34.tempY; var73 > (double)0.0F && var52 < var63; ++var52) {
  460.                         double var78 = var3.weightY[var52];
  461.                         double var81 = var78 * var71 / var73;
  462.                         double[] var86 = var3.weightY;
  463.                         var86[var52] += var81;
  464.                         var71 -= var81;
  465.                         var73 -= var78;
  466.                      }
  467.  
  468.                      double[] var87 = var3.weightY;
  469.                      var87[var63 - 1] += var71;
  470.                   }
  471.  
  472.                   int var64 = var34.minHeight + var34.ipady + var34.insets.top + var34.insets.bottom;
  473.  
  474.                   for(int var53 = var34.tempY; var53 < var63; ++var53) {
  475.                      var64 -= var3.minHeight[var53];
  476.                   }
  477.  
  478.                   if (var64 > 0) {
  479.                      double var74 = (double)0.0F;
  480.  
  481.                      for(int var54 = var34.tempY; var54 < var63; ++var54) {
  482.                         var74 += var3.weightY[var54];
  483.                      }
  484.  
  485.                      for(int var55 = var34.tempY; var74 > (double)0.0F && var55 < var63; ++var55) {
  486.                         double var79 = var3.weightY[var55];
  487.                         int var82 = (int)(var79 * (double)var64 / var74);
  488.                         int[] var88 = var3.minHeight;
  489.                         var88[var55] += var82;
  490.                         var64 -= var82;
  491.                         var74 -= var79;
  492.                      }
  493.  
  494.                      int[] var89 = var3.minHeight;
  495.                      var89[var63 - 1] += var64;
  496.                   }
  497.                }
  498.             }
  499.          }
  500.  
  501.          var44 = var14;
  502.       }
  503.  
  504.       return var3;
  505.    }
  506.  
  507.    protected void AdjustForGravity(GridBagConstraints var1, Rectangle var2) {
  508.       var2.x += var1.insets.left;
  509.       var2.width -= var1.insets.left + var1.insets.right;
  510.       var2.y += var1.insets.top;
  511.       var2.height -= var1.insets.top + var1.insets.bottom;
  512.       int var3 = 0;
  513.       if (var1.fill != 2 && var1.fill != 1 && var2.width > var1.minWidth + var1.ipadx) {
  514.          var3 = var2.width - (var1.minWidth + var1.ipadx);
  515.          var2.width = var1.minWidth + var1.ipadx;
  516.       }
  517.  
  518.       int var4 = 0;
  519.       if (var1.fill != 3 && var1.fill != 1 && var2.height > var1.minHeight + var1.ipady) {
  520.          var4 = var2.height - (var1.minHeight + var1.ipady);
  521.          var2.height = var1.minHeight + var1.ipady;
  522.       }
  523.  
  524.       switch (var1.anchor) {
  525.          case 10:
  526.             var2.x += var3 / 2;
  527.             var2.y += var4 / 2;
  528.             return;
  529.          case 11:
  530.             var2.x += var3 / 2;
  531.             return;
  532.          case 12:
  533.             var2.x += var3;
  534.             return;
  535.          case 13:
  536.             var2.x += var3;
  537.             var2.y += var4 / 2;
  538.             return;
  539.          case 14:
  540.             var2.x += var3;
  541.             var2.y += var4;
  542.             return;
  543.          case 15:
  544.             var2.x += var3 / 2;
  545.             var2.y += var4;
  546.             return;
  547.          case 16:
  548.             var2.y += var4;
  549.             return;
  550.          case 17:
  551.             var2.y += var4 / 2;
  552.             return;
  553.          case 18:
  554.             return;
  555.          default:
  556.             throw new IllegalArgumentException("illegal anchor value");
  557.       }
  558.    }
  559.  
  560.    protected Dimension GetMinSize(Container var1, GridBagLayoutInfo var2) {
  561.       Dimension var3 = new Dimension();
  562.       Insets var6 = var1.getInsets();
  563.       int var5 = 0;
  564.  
  565.       for(int var4 = 0; var4 < var2.width; ++var4) {
  566.          var5 += var2.minWidth[var4];
  567.       }
  568.  
  569.       var3.width = var5 + var6.left + var6.right;
  570.       var5 = 0;
  571.  
  572.       for(int var7 = 0; var7 < var2.height; ++var7) {
  573.          var5 += var2.minHeight[var7];
  574.       }
  575.  
  576.       var3.height = var5 + var6.top + var6.bottom;
  577.       return var3;
  578.    }
  579.  
  580.    protected void ArrangeGrid(Container var1) {
  581.       Insets var5 = var1.getInsets();
  582.       Component[] var6 = var1.getComponents();
  583.       Rectangle var8 = new Rectangle();
  584.       if (var6.length != 0 || this.columnWidths != null && this.columnWidths.length != 0 || this.rowHeights != null && this.rowHeights.length != 0) {
  585.          GridBagLayoutInfo var14 = this.GetLayoutInfo(var1, 2);
  586.          Dimension var7 = this.GetMinSize(var1, var14);
  587.          if (var1.width < var7.width || var1.height < var7.height) {
  588.             var14 = this.GetLayoutInfo(var1, 1);
  589.             var7 = this.GetMinSize(var1, var14);
  590.          }
  591.  
  592.          this.layoutInfo = var14;
  593.          var8.width = var7.width;
  594.          var8.height = var7.height;
  595.          int var10 = var1.width - var8.width;
  596.          if (var10 != 0) {
  597.             double var12 = (double)0.0F;
  598.  
  599.             for(int var9 = 0; var9 < var14.width; ++var9) {
  600.                var12 += var14.weightX[var9];
  601.             }
  602.  
  603.             if (var12 > (double)0.0F) {
  604.                for(int var16 = 0; var16 < var14.width; ++var16) {
  605.                   int var15 = (int)((double)var10 * var14.weightX[var16] / var12);
  606.                   int[] var10000 = var14.minWidth;
  607.                   var10000[var16] += var15;
  608.                   var8.width += var15;
  609.                   if (var14.minWidth[var16] < 0) {
  610.                      var8.width -= var14.minWidth[var16];
  611.                      var14.minWidth[var16] = 0;
  612.                   }
  613.                }
  614.             }
  615.  
  616.             var10 = var1.width - var8.width;
  617.          } else {
  618.             var10 = 0;
  619.          }
  620.  
  621.          int var11 = var1.height - var8.height;
  622.          if (var11 != 0) {
  623.             double var25 = (double)0.0F;
  624.  
  625.             for(int var17 = 0; var17 < var14.height; ++var17) {
  626.                var25 += var14.weightY[var17];
  627.             }
  628.  
  629.             if (var25 > (double)0.0F) {
  630.                for(int var18 = 0; var18 < var14.height; ++var18) {
  631.                   int var26 = (int)((double)var11 * var14.weightY[var18] / var25);
  632.                   int[] var27 = var14.minHeight;
  633.                   var27[var18] += var26;
  634.                   var8.height += var26;
  635.                   if (var14.minHeight[var18] < 0) {
  636.                      var8.height -= var14.minHeight[var18];
  637.                      var14.minHeight[var18] = 0;
  638.                   }
  639.                }
  640.             }
  641.  
  642.             var11 = var1.height - var8.height;
  643.          } else {
  644.             var11 = 0;
  645.          }
  646.  
  647.          var14.startx = var10 / 2 + var5.left;
  648.          var14.starty = var11 / 2 + var5.top;
  649.  
  650.          for(int var3 = 0; var3 < var6.length; ++var3) {
  651.             Component var2 = var6[var3];
  652.             if (var2.isVisible()) {
  653.                GridBagConstraints var4 = this.lookupConstraints(var2);
  654.                var8.x = var14.startx;
  655.  
  656.                for(int var19 = 0; var19 < var4.tempX; ++var19) {
  657.                   var8.x += var14.minWidth[var19];
  658.                }
  659.  
  660.                var8.y = var14.starty;
  661.  
  662.                for(int var20 = 0; var20 < var4.tempY; ++var20) {
  663.                   var8.y += var14.minHeight[var20];
  664.                }
  665.  
  666.                var8.width = 0;
  667.  
  668.                for(int var21 = var4.tempX; var21 < var4.tempX + var4.tempWidth; ++var21) {
  669.                   var8.width += var14.minWidth[var21];
  670.                }
  671.  
  672.                var8.height = 0;
  673.  
  674.                for(int var22 = var4.tempY; var22 < var4.tempY + var4.tempHeight; ++var22) {
  675.                   var8.height += var14.minHeight[var22];
  676.                }
  677.  
  678.                this.AdjustForGravity(var4, var8);
  679.                if (var8.width > 0 && var8.height > 0) {
  680.                   if (var2.x != var8.x || var2.y != var8.y || var2.width != var8.width || var2.height != var8.height) {
  681.                      var2.setBounds(var8.x, var8.y, var8.width, var8.height);
  682.                   }
  683.                } else {
  684.                   var2.setBounds(0, 0, 0, 0);
  685.                }
  686.             }
  687.          }
  688.  
  689.       }
  690.    }
  691. }
  692.