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