home *** CD-ROM | disk | FTP | other *** search
/ Sky at Night 2007 June / SAN CD 6-2007 CD-ROM 25.iso / pc / Software / AstroGrav_Win / Java / jre1.6.0 / lib / rt.jar / java / awt / GridBagLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  2006-11-29  |  13.0 KB  |  1,155 lines
  1. package java.awt;
  2.  
  3. import java.awt.Component.BaselineResizeBehavior;
  4. import java.awt.GridBagLayout.1;
  5. import java.io.Serializable;
  6. import java.util.Arrays;
  7. import java.util.Hashtable;
  8.  
  9. public class GridBagLayout implements LayoutManager2, Serializable {
  10.    static final int EMPIRICMULTIPLIER = 2;
  11.    protected static final int MAXGRIDSIZE = 512;
  12.    protected static final int MINSIZE = 1;
  13.    protected static final int PREFERREDSIZE = 2;
  14.    protected Hashtable<Component, GridBagConstraints> comptable = new Hashtable();
  15.    protected GridBagConstraints defaultConstraints = new GridBagConstraints();
  16.    protected GridBagLayoutInfo layoutInfo;
  17.    public int[] columnWidths;
  18.    public int[] rowHeights;
  19.    public double[] columnWeights;
  20.    public double[] rowWeights;
  21.    private Component componentAdjusting;
  22.    transient boolean rightToLeft = false;
  23.    static final long serialVersionUID = 8838754796412211005L;
  24.  
  25.    public void setConstraints(Component var1, GridBagConstraints var2) {
  26.       this.comptable.put(var1, (GridBagConstraints)var2.clone());
  27.    }
  28.  
  29.    public GridBagConstraints getConstraints(Component var1) {
  30.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  31.       if (var2 == null) {
  32.          this.setConstraints(var1, this.defaultConstraints);
  33.          var2 = (GridBagConstraints)this.comptable.get(var1);
  34.       }
  35.  
  36.       return (GridBagConstraints)var2.clone();
  37.    }
  38.  
  39.    protected GridBagConstraints lookupConstraints(Component var1) {
  40.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  41.       if (var2 == null) {
  42.          this.setConstraints(var1, this.defaultConstraints);
  43.          var2 = (GridBagConstraints)this.comptable.get(var1);
  44.       }
  45.  
  46.       return var2;
  47.    }
  48.  
  49.    private void removeConstraints(Component var1) {
  50.       this.comptable.remove(var1);
  51.    }
  52.  
  53.    public Point getLayoutOrigin() {
  54.       Point var1 = new Point(0, 0);
  55.       if (this.layoutInfo != null) {
  56.          var1.x = this.layoutInfo.startx;
  57.          var1.y = this.layoutInfo.starty;
  58.       }
  59.  
  60.       return var1;
  61.    }
  62.  
  63.    public int[][] getLayoutDimensions() {
  64.       if (this.layoutInfo == null) {
  65.          return new int[2][0];
  66.       } else {
  67.          int[][] var1 = new int[][]{new int[this.layoutInfo.width], new int[this.layoutInfo.height]};
  68.          System.arraycopy(this.layoutInfo.minWidth, 0, var1[0], 0, this.layoutInfo.width);
  69.          System.arraycopy(this.layoutInfo.minHeight, 0, var1[1], 0, this.layoutInfo.height);
  70.          return var1;
  71.       }
  72.    }
  73.  
  74.    public double[][] getLayoutWeights() {
  75.       if (this.layoutInfo == null) {
  76.          return new double[2][0];
  77.       } else {
  78.          double[][] var1 = new double[][]{new double[this.layoutInfo.width], new double[this.layoutInfo.height]};
  79.          System.arraycopy(this.layoutInfo.weightX, 0, var1[0], 0, this.layoutInfo.width);
  80.          System.arraycopy(this.layoutInfo.weightY, 0, var1[1], 0, this.layoutInfo.height);
  81.          return var1;
  82.       }
  83.    }
  84.  
  85.    public Point location(int var1, int var2) {
  86.       Point var3 = new Point(0, 0);
  87.       if (this.layoutInfo == null) {
  88.          return var3;
  89.       } else {
  90.          int var5 = this.layoutInfo.startx;
  91.          int var6;
  92.          if (!this.rightToLeft) {
  93.             for(var6 = 0; var6 < this.layoutInfo.width; ++var6) {
  94.                var5 += this.layoutInfo.minWidth[var6];
  95.                if (var5 > var1) {
  96.                   break;
  97.                }
  98.             }
  99.          } else {
  100.             for(var6 = this.layoutInfo.width - 1; var6 >= 0 && var5 <= var1; --var6) {
  101.                var5 += this.layoutInfo.minWidth[var6];
  102.             }
  103.  
  104.             ++var6;
  105.          }
  106.  
  107.          var3.x = var6;
  108.          var5 = this.layoutInfo.starty;
  109.  
  110.          for(var6 = 0; var6 < this.layoutInfo.height; ++var6) {
  111.             var5 += this.layoutInfo.minHeight[var6];
  112.             if (var5 > var2) {
  113.                break;
  114.             }
  115.          }
  116.  
  117.          var3.y = var6;
  118.          return var3;
  119.       }
  120.    }
  121.  
  122.    public void addLayoutComponent(String var1, Component var2) {
  123.    }
  124.  
  125.    public void addLayoutComponent(Component var1, Object var2) {
  126.       if (var2 instanceof GridBagConstraints) {
  127.          this.setConstraints(var1, (GridBagConstraints)var2);
  128.       } else if (var2 != null) {
  129.          throw new IllegalArgumentException("cannot add to layout: constraints must be a GridBagConstraint");
  130.       }
  131.  
  132.    }
  133.  
  134.    public void removeLayoutComponent(Component var1) {
  135.       this.removeConstraints(var1);
  136.    }
  137.  
  138.    public Dimension preferredLayoutSize(Container var1) {
  139.       GridBagLayoutInfo var2 = this.getLayoutInfo(var1, 2);
  140.       return this.getMinSize(var1, var2);
  141.    }
  142.  
  143.    public Dimension minimumLayoutSize(Container var1) {
  144.       GridBagLayoutInfo var2 = this.getLayoutInfo(var1, 1);
  145.       return this.getMinSize(var1, var2);
  146.    }
  147.  
  148.    public Dimension maximumLayoutSize(Container var1) {
  149.       return new Dimension(Integer.MAX_VALUE, Integer.MAX_VALUE);
  150.    }
  151.  
  152.    public float getLayoutAlignmentX(Container var1) {
  153.       return 0.5F;
  154.    }
  155.  
  156.    public float getLayoutAlignmentY(Container var1) {
  157.       return 0.5F;
  158.    }
  159.  
  160.    public void invalidateLayout(Container var1) {
  161.    }
  162.  
  163.    public void layoutContainer(Container var1) {
  164.       this.arrangeGrid(var1);
  165.    }
  166.  
  167.    public String toString() {
  168.       return this.getClass().getName();
  169.    }
  170.  
  171.    protected GridBagLayoutInfo getLayoutInfo(Container var1, int var2) {
  172.       return this.GetLayoutInfo(var1, var2);
  173.    }
  174.  
  175.    private long[] preInitMaximumArraySizes(Container var1) {
  176.       Component[] var2 = var1.getComponents();
  177.       int var9 = 0;
  178.       int var10 = 0;
  179.       long[] var11 = new long[2];
  180.  
  181.       for(int var12 = 0; var12 < var2.length; ++var12) {
  182.          Component var3 = var2[var12];
  183.          if (var3.isVisible()) {
  184.             GridBagConstraints var4 = this.lookupConstraints(var3);
  185.             int var5 = var4.gridx;
  186.             int var6 = var4.gridy;
  187.             int var7 = var4.gridwidth;
  188.             int var8 = var4.gridheight;
  189.             if (var5 < 0) {
  190.                ++var10;
  191.                var5 = var10;
  192.             }
  193.  
  194.             if (var6 < 0) {
  195.                ++var9;
  196.                var6 = var9;
  197.             }
  198.  
  199.             if (var7 <= 0) {
  200.                var7 = 1;
  201.             }
  202.  
  203.             if (var8 <= 0) {
  204.                var8 = 1;
  205.             }
  206.  
  207.             var9 = Math.max(var6 + var8, var9);
  208.             var10 = Math.max(var5 + var7, var10);
  209.          }
  210.       }
  211.  
  212.       var11[0] = (long)var9;
  213.       var11[1] = (long)var10;
  214.       return var11;
  215.    }
  216.  
  217.    protected GridBagLayoutInfo GetLayoutInfo(Container var1, int var2) {
  218.       synchronized(var1.getTreeLock()) {
  219.          Component[] var8 = var1.getComponents();
  220.          int var20 = 0;
  221.          int var21 = 0;
  222.          int var22 = 1;
  223.          int var23 = 1;
  224.          int var30 = 0;
  225.          int var31 = 0;
  226.          int var10 = 0;
  227.          int var9 = 0;
  228.          int var25 = -1;
  229.          int var24 = -1;
  230.          long[] var33 = this.preInitMaximumArraySizes(var1);
  231.          var30 = 2L * var33[0] > 2147483647L ? Integer.MAX_VALUE : 2 * (int)var33[0];
  232.          var31 = 2L * var33[1] > 2147483647L ? Integer.MAX_VALUE : 2 * (int)var33[1];
  233.          if (this.rowHeights != null) {
  234.             var30 = Math.max(var30, this.rowHeights.length);
  235.          }
  236.  
  237.          if (this.columnWidths != null) {
  238.             var31 = Math.max(var31, this.columnWidths.length);
  239.          }
  240.  
  241.          int[] var11 = new int[var30];
  242.          int[] var12 = new int[var31];
  243.          boolean var34 = false;
  244.  
  245.          for(int var13 = 0; var13 < var8.length; ++var13) {
  246.             Component var5 = var8[var13];
  247.             if (var5.isVisible()) {
  248.                GridBagConstraints var6 = this.lookupConstraints(var5);
  249.                var20 = var6.gridx;
  250.                var21 = var6.gridy;
  251.                var22 = var6.gridwidth;
  252.                if (var22 <= 0) {
  253.                   var22 = 1;
  254.                }
  255.  
  256.                var23 = var6.gridheight;
  257.                if (var23 <= 0) {
  258.                   var23 = 1;
  259.                }
  260.  
  261.                if (var20 < 0 && var21 < 0) {
  262.                   if (var24 >= 0) {
  263.                      var21 = var24;
  264.                   } else if (var25 >= 0) {
  265.                      var20 = var25;
  266.                   } else {
  267.                      var21 = 0;
  268.                   }
  269.                }
  270.  
  271.                if (var20 < 0) {
  272.                   int var16 = 0;
  273.  
  274.                   for(int var14 = var21; var14 < var21 + var23; ++var14) {
  275.                      var16 = Math.max(var16, var11[var14]);
  276.                   }
  277.  
  278.                   var20 = var16 - var20 - 1;
  279.                   if (var20 < 0) {
  280.                      var20 = 0;
  281.                   }
  282.                } else if (var21 < 0) {
  283.                   int var17 = 0;
  284.  
  285.                   for(int var50 = var20; var50 < var20 + var22; ++var50) {
  286.                      var17 = Math.max(var17, var12[var50]);
  287.                   }
  288.  
  289.                   var21 = var17 - var21 - 1;
  290.                   if (var21 < 0) {
  291.                      var21 = 0;
  292.                   }
  293.                }
  294.  
  295.                int var69 = var20 + var22;
  296.                if (var9 < var69) {
  297.                   var9 = var69;
  298.                }
  299.  
  300.                int var73 = var21 + var23;
  301.                if (var10 < var73) {
  302.                   var10 = var73;
  303.                }
  304.  
  305.                for(int var51 = var20; var51 < var20 + var22; ++var51) {
  306.                   var12[var51] = var73;
  307.                }
  308.  
  309.                for(int var52 = var21; var52 < var21 + var23; ++var52) {
  310.                   var11[var52] = var69;
  311.                }
  312.  
  313.                Dimension var7;
  314.                if (var2 == 2) {
  315.                   var7 = var5.getPreferredSize();
  316.                } else {
  317.                   var7 = var5.getMinimumSize();
  318.                }
  319.  
  320.                var6.minWidth = var7.width;
  321.                var6.minHeight = var7.height;
  322.                if (this.calculateBaseline(var5, var6, var7)) {
  323.                   var34 = true;
  324.                }
  325.  
  326.                if (var6.gridheight == 0 && var6.gridwidth == 0) {
  327.                   var25 = -1;
  328.                   var24 = -1;
  329.                }
  330.  
  331.                if (var6.gridheight == 0 && var24 < 0) {
  332.                   var25 = var20 + var22;
  333.                } else if (var6.gridwidth == 0 && var25 < 0) {
  334.                   var24 = var21 + var23;
  335.                }
  336.             }
  337.          }
  338.  
  339.          if (this.columnWidths != null && var9 < this.columnWidths.length) {
  340.             var9 = this.columnWidths.length;
  341.          }
  342.  
  343.          if (this.rowHeights != null && var10 < this.rowHeights.length) {
  344.             var10 = this.rowHeights.length;
  345.          }
  346.  
  347.          GridBagLayoutInfo var4 = new GridBagLayoutInfo(var9, var10);
  348.          var25 = -1;
  349.          var24 = -1;
  350.          Arrays.fill(var11, 0);
  351.          Arrays.fill(var12, 0);
  352.          int[] var35 = null;
  353.          int[] var36 = null;
  354.          short[] var37 = null;
  355.          if (var34) {
  356.             var4.maxAscent = var35 = new int[var10];
  357.             var4.maxDescent = var36 = new int[var10];
  358.             var4.baselineType = var37 = new short[var10];
  359.             var4.hasBaseline = true;
  360.          }
  361.  
  362.          for(int var48 = 0; var48 < var8.length; ++var48) {
  363.             Component var44 = var8[var48];
  364.             if (var44.isVisible()) {
  365.                GridBagConstraints var46 = this.lookupConstraints(var44);
  366.                var20 = var46.gridx;
  367.                var21 = var46.gridy;
  368.                var22 = var46.gridwidth;
  369.                var23 = var46.gridheight;
  370.                if (var20 < 0 && var21 < 0) {
  371.                   if (var24 >= 0) {
  372.                      var21 = var24;
  373.                   } else if (var25 >= 0) {
  374.                      var20 = var25;
  375.                   } else {
  376.                      var21 = 0;
  377.                   }
  378.                }
  379.  
  380.                if (var20 < 0) {
  381.                   if (var23 <= 0) {
  382.                      var23 += var4.height - var21;
  383.                      if (var23 < 1) {
  384.                         var23 = 1;
  385.                      }
  386.                   }
  387.  
  388.                   int var70 = 0;
  389.  
  390.                   for(int var53 = var21; var53 < var21 + var23; ++var53) {
  391.                      var70 = Math.max(var70, var11[var53]);
  392.                   }
  393.  
  394.                   var20 = var70 - var20 - 1;
  395.                   if (var20 < 0) {
  396.                      var20 = 0;
  397.                   }
  398.                } else if (var21 < 0) {
  399.                   if (var22 <= 0) {
  400.                      var22 += var4.width - var20;
  401.                      if (var22 < 1) {
  402.                         var22 = 1;
  403.                      }
  404.                   }
  405.  
  406.                   int var74 = 0;
  407.  
  408.                   for(int var54 = var20; var54 < var20 + var22; ++var54) {
  409.                      var74 = Math.max(var74, var12[var54]);
  410.                   }
  411.  
  412.                   var21 = var74 - var21 - 1;
  413.                   if (var21 < 0) {
  414.                      var21 = 0;
  415.                   }
  416.                }
  417.  
  418.                if (var22 <= 0) {
  419.                   var22 += var4.width - var20;
  420.                   if (var22 < 1) {
  421.                      var22 = 1;
  422.                   }
  423.                }
  424.  
  425.                if (var23 <= 0) {
  426.                   var23 += var4.height - var21;
  427.                   if (var23 < 1) {
  428.                      var23 = 1;
  429.                   }
  430.                }
  431.  
  432.                int var71 = var20 + var22;
  433.                int var75 = var21 + var23;
  434.  
  435.                for(int var55 = var20; var55 < var20 + var22; ++var55) {
  436.                   var12[var55] = var75;
  437.                }
  438.  
  439.                for(int var56 = var21; var56 < var21 + var23; ++var56) {
  440.                   var11[var56] = var71;
  441.                }
  442.  
  443.                if (var46.gridheight == 0 && var46.gridwidth == 0) {
  444.                   var25 = -1;
  445.                   var24 = -1;
  446.                }
  447.  
  448.                if (var46.gridheight == 0 && var24 < 0) {
  449.                   var25 = var20 + var22;
  450.                } else if (var46.gridwidth == 0 && var25 < 0) {
  451.                   var24 = var21 + var23;
  452.                }
  453.  
  454.                var46.tempX = var20;
  455.                var46.tempY = var21;
  456.                var46.tempWidth = var22;
  457.                var46.tempHeight = var23;
  458.                int var32 = var46.anchor;
  459.                if (var34) {
  460.                   switch (var32) {
  461.                      case 256:
  462.                      case 512:
  463.                      case 768:
  464.                         if (var46.ascent >= 0) {
  465.                            if (var23 == 1) {
  466.                               var35[var21] = Math.max(var35[var21], var46.ascent);
  467.                               var36[var21] = Math.max(var36[var21], var46.descent);
  468.                            } else if (var46.baselineResizeBehavior == BaselineResizeBehavior.CONSTANT_DESCENT) {
  469.                               var36[var21 + var23 - 1] = Math.max(var36[var21 + var23 - 1], var46.descent);
  470.                            } else {
  471.                               var35[var21] = Math.max(var35[var21], var46.ascent);
  472.                            }
  473.  
  474.                            if (var46.baselineResizeBehavior == BaselineResizeBehavior.CONSTANT_DESCENT) {
  475.                               var37[var21 + var23 - 1] = (short)(var37[var21 + var23 - 1] | 1 << var46.baselineResizeBehavior.ordinal());
  476.                            } else {
  477.                               var37[var21] = (short)(var37[var21] | 1 << var46.baselineResizeBehavior.ordinal());
  478.                            }
  479.                         }
  480.                         break;
  481.                      case 1024:
  482.                      case 1280:
  483.                      case 1536:
  484.                         int var77 = var46.minHeight + var46.insets.top + var46.ipady;
  485.                         var35[var21] = Math.max(var35[var21], var77);
  486.                         var36[var21] = Math.max(var36[var21], var46.insets.bottom);
  487.                         break;
  488.                      case 1792:
  489.                      case 2048:
  490.                      case 2304:
  491.                         int var18 = var46.minHeight + var46.insets.bottom + var46.ipady;
  492.                         var36[var21] = Math.max(var36[var21], var18);
  493.                         var35[var21] = Math.max(var35[var21], var46.insets.top);
  494.                   }
  495.                }
  496.             }
  497.          }
  498.  
  499.          var4.weightX = new double[var31];
  500.          var4.weightY = new double[var30];
  501.          var4.minWidth = new int[var31];
  502.          var4.minHeight = new int[var30];
  503.          if (this.columnWidths != null) {
  504.             System.arraycopy(this.columnWidths, 0, var4.minWidth, 0, this.columnWidths.length);
  505.          }
  506.  
  507.          if (this.rowHeights != null) {
  508.             System.arraycopy(this.rowHeights, 0, var4.minHeight, 0, this.rowHeights.length);
  509.          }
  510.  
  511.          if (this.columnWeights != null) {
  512.             System.arraycopy(this.columnWeights, 0, var4.weightX, 0, Math.min(var4.weightX.length, this.columnWeights.length));
  513.          }
  514.  
  515.          if (this.rowWeights != null) {
  516.             System.arraycopy(this.rowWeights, 0, var4.weightY, 0, Math.min(var4.weightY.length, this.rowWeights.length));
  517.          }
  518.  
  519.          int var19 = Integer.MAX_VALUE;
  520.  
  521.          for(int var57 = 1; var57 != Integer.MAX_VALUE; var19 = Integer.MAX_VALUE) {
  522.             for(int var49 = 0; var49 < var8.length; ++var49) {
  523.                Component var45 = var8[var49];
  524.                if (var45.isVisible()) {
  525.                   GridBagConstraints var47 = this.lookupConstraints(var45);
  526.                   if (var47.tempWidth == var57) {
  527.                      int var72 = var47.tempX + var47.tempWidth;
  528.                      double var26 = var47.weightx;
  529.  
  530.                      for(int var15 = var47.tempX; var15 < var72; ++var15) {
  531.                         var26 -= var4.weightX[var15];
  532.                      }
  533.  
  534.                      if (var26 > (double)0.0F) {
  535.                         double var28 = (double)0.0F;
  536.  
  537.                         for(int var58 = var47.tempX; var58 < var72; ++var58) {
  538.                            var28 += var4.weightX[var58];
  539.                         }
  540.  
  541.                         for(int var59 = var47.tempX; var28 > (double)0.0F && var59 < var72; ++var59) {
  542.                            double var38 = var4.weightX[var59];
  543.                            double var40 = var38 * var26 / var28;
  544.                            double[] var10000 = var4.weightX;
  545.                            var10000[var59] += var40;
  546.                            var26 -= var40;
  547.                            var28 -= var38;
  548.                         }
  549.  
  550.                         double[] var102 = var4.weightX;
  551.                         var102[var72 - 1] += var26;
  552.                      }
  553.  
  554.                      int var78 = var47.minWidth + var47.ipadx + var47.insets.left + var47.insets.right;
  555.  
  556.                      for(int var60 = var47.tempX; var60 < var72; ++var60) {
  557.                         var78 -= var4.minWidth[var60];
  558.                      }
  559.  
  560.                      if (var78 > 0) {
  561.                         double var91 = (double)0.0F;
  562.  
  563.                         for(int var61 = var47.tempX; var61 < var72; ++var61) {
  564.                            var91 += var4.weightX[var61];
  565.                         }
  566.  
  567.                         for(int var62 = var47.tempX; var91 > (double)0.0F && var62 < var72; ++var62) {
  568.                            double var96 = var4.weightX[var62];
  569.                            int var99 = (int)(var96 * (double)var78 / var91);
  570.                            int[] var103 = var4.minWidth;
  571.                            var103[var62] += var99;
  572.                            var78 -= var99;
  573.                            var91 -= var96;
  574.                         }
  575.  
  576.                         int[] var104 = var4.minWidth;
  577.                         var104[var72 - 1] += var78;
  578.                      }
  579.                   } else if (var47.tempWidth > var57 && var47.tempWidth < var19) {
  580.                      var19 = var47.tempWidth;
  581.                   }
  582.  
  583.                   if (var47.tempHeight != var57) {
  584.                      if (var47.tempHeight > var57 && var47.tempHeight < var19) {
  585.                         var19 = var47.tempHeight;
  586.                      }
  587.                   } else {
  588.                      int var76 = var47.tempY + var47.tempHeight;
  589.                      double var90 = var47.weighty;
  590.  
  591.                      for(int var63 = var47.tempY; var63 < var76; ++var63) {
  592.                         var90 -= var4.weightY[var63];
  593.                      }
  594.  
  595.                      if (var90 > (double)0.0F) {
  596.                         double var92 = (double)0.0F;
  597.  
  598.                         for(int var64 = var47.tempY; var64 < var76; ++var64) {
  599.                            var92 += var4.weightY[var64];
  600.                         }
  601.  
  602.                         for(int var65 = var47.tempY; var92 > (double)0.0F && var65 < var76; ++var65) {
  603.                            double var97 = var4.weightY[var65];
  604.                            double var100 = var97 * var90 / var92;
  605.                            double[] var105 = var4.weightY;
  606.                            var105[var65] += var100;
  607.                            var90 -= var100;
  608.                            var92 -= var97;
  609.                         }
  610.  
  611.                         double[] var106 = var4.weightY;
  612.                         var106[var76 - 1] += var90;
  613.                      }
  614.  
  615.                      int var79 = -1;
  616.                      if (var34) {
  617.                         switch (var47.anchor) {
  618.                            case 256:
  619.                            case 512:
  620.                            case 768:
  621.                               if (var47.ascent >= 0) {
  622.                                  if (var47.tempHeight == 1) {
  623.                                     var79 = var35[var47.tempY] + var36[var47.tempY];
  624.                                  } else if (var47.baselineResizeBehavior != BaselineResizeBehavior.CONSTANT_DESCENT) {
  625.                                     var79 = var35[var47.tempY] + var47.descent;
  626.                                  } else {
  627.                                     var79 = var47.ascent + var36[var47.tempY + var47.tempHeight - 1];
  628.                                  }
  629.                               }
  630.                               break;
  631.                            case 1024:
  632.                            case 1280:
  633.                            case 1536:
  634.                               var79 = var47.insets.top + var47.minHeight + var47.ipady + var36[var47.tempY];
  635.                               break;
  636.                            case 1792:
  637.                            case 2048:
  638.                            case 2304:
  639.                               var79 = var35[var47.tempY] + var47.minHeight + var47.insets.bottom + var47.ipady;
  640.                         }
  641.                      }
  642.  
  643.                      if (var79 == -1) {
  644.                         var79 = var47.minHeight + var47.ipady + var47.insets.top + var47.insets.bottom;
  645.                      }
  646.  
  647.                      for(int var66 = var47.tempY; var66 < var76; ++var66) {
  648.                         var79 -= var4.minHeight[var66];
  649.                      }
  650.  
  651.                      if (var79 > 0) {
  652.                         double var93 = (double)0.0F;
  653.  
  654.                         for(int var67 = var47.tempY; var67 < var76; ++var67) {
  655.                            var93 += var4.weightY[var67];
  656.                         }
  657.  
  658.                         for(int var68 = var47.tempY; var93 > (double)0.0F && var68 < var76; ++var68) {
  659.                            double var98 = var4.weightY[var68];
  660.                            int var101 = (int)(var98 * (double)var79 / var93);
  661.                            int[] var107 = var4.minHeight;
  662.                            var107[var68] += var101;
  663.                            var79 -= var101;
  664.                            var93 -= var98;
  665.                         }
  666.  
  667.                         int[] var108 = var4.minHeight;
  668.                         var108[var76 - 1] += var79;
  669.                      }
  670.                   }
  671.                }
  672.             }
  673.  
  674.             var57 = var19;
  675.          }
  676.  
  677.          return var4;
  678.       }
  679.    }
  680.  
  681.    private boolean calculateBaseline(Component var1, GridBagConstraints var2, Dimension var3) {
  682.       int var4 = var2.anchor;
  683.       if (var4 != 256 && var4 != 512 && var4 != 768) {
  684.          var2.ascent = -1;
  685.          return false;
  686.       } else {
  687.          int var5 = var3.width + var2.ipadx;
  688.          int var6 = var3.height + var2.ipady;
  689.          var2.ascent = var1.getBaseline(var5, var6);
  690.          if (var2.ascent >= 0) {
  691.             int var7 = var2.ascent;
  692.             var2.descent = var6 - var2.ascent + var2.insets.bottom;
  693.             var2.ascent += var2.insets.top;
  694.             var2.baselineResizeBehavior = var1.getBaselineResizeBehavior();
  695.             var2.centerPadding = 0;
  696.             if (var2.baselineResizeBehavior == BaselineResizeBehavior.CENTER_OFFSET) {
  697.                int var8 = var1.getBaseline(var5, var6 + 1);
  698.                var2.centerOffset = var7 - var6 / 2;
  699.                if (var6 % 2 == 0) {
  700.                   if (var7 != var8) {
  701.                      var2.centerPadding = 1;
  702.                   }
  703.                } else if (var7 == var8) {
  704.                   --var2.centerOffset;
  705.                   var2.centerPadding = 1;
  706.                }
  707.             }
  708.          }
  709.  
  710.          return true;
  711.       }
  712.    }
  713.  
  714.    protected void adjustForGravity(GridBagConstraints var1, Rectangle var2) {
  715.       this.AdjustForGravity(var1, var2);
  716.    }
  717.  
  718.    protected void AdjustForGravity(GridBagConstraints var1, Rectangle var2) {
  719.       int var5 = var2.y;
  720.       int var6 = var2.height;
  721.       if (!this.rightToLeft) {
  722.          var2.x += var1.insets.left;
  723.       } else {
  724.          var2.x -= var2.width - var1.insets.right;
  725.       }
  726.  
  727.       var2.width -= var1.insets.left + var1.insets.right;
  728.       var2.y += var1.insets.top;
  729.       var2.height -= var1.insets.top + var1.insets.bottom;
  730.       int var3 = 0;
  731.       if (var1.fill != 2 && var1.fill != 1 && var2.width > var1.minWidth + var1.ipadx) {
  732.          var3 = var2.width - (var1.minWidth + var1.ipadx);
  733.          var2.width = var1.minWidth + var1.ipadx;
  734.       }
  735.  
  736.       int var4 = 0;
  737.       if (var1.fill != 3 && var1.fill != 1 && var2.height > var1.minHeight + var1.ipady) {
  738.          var4 = var2.height - (var1.minHeight + var1.ipady);
  739.          var2.height = var1.minHeight + var1.ipady;
  740.       }
  741.  
  742.       switch (var1.anchor) {
  743.          case 10:
  744.             var2.x += var3 / 2;
  745.             var2.y += var4 / 2;
  746.             break;
  747.          case 11:
  748.          case 19:
  749.             var2.x += var3 / 2;
  750.             break;
  751.          case 12:
  752.             var2.x += var3;
  753.             break;
  754.          case 13:
  755.             var2.x += var3;
  756.             var2.y += var4 / 2;
  757.             break;
  758.          case 14:
  759.             var2.x += var3;
  760.             var2.y += var4;
  761.             break;
  762.          case 15:
  763.          case 20:
  764.             var2.x += var3 / 2;
  765.             var2.y += var4;
  766.             break;
  767.          case 16:
  768.             var2.y += var4;
  769.             break;
  770.          case 17:
  771.             var2.y += var4 / 2;
  772.          case 18:
  773.             break;
  774.          case 21:
  775.             if (this.rightToLeft) {
  776.                var2.x += var3;
  777.             }
  778.  
  779.             var2.y += var4 / 2;
  780.             break;
  781.          case 22:
  782.             if (!this.rightToLeft) {
  783.                var2.x += var3;
  784.             }
  785.  
  786.             var2.y += var4 / 2;
  787.             break;
  788.          case 23:
  789.             if (this.rightToLeft) {
  790.                var2.x += var3;
  791.             }
  792.             break;
  793.          case 24:
  794.             if (!this.rightToLeft) {
  795.                var2.x += var3;
  796.             }
  797.             break;
  798.          case 25:
  799.             if (this.rightToLeft) {
  800.                var2.x += var3;
  801.             }
  802.  
  803.             var2.y += var4;
  804.             break;
  805.          case 26:
  806.             if (!this.rightToLeft) {
  807.                var2.x += var3;
  808.             }
  809.  
  810.             var2.y += var4;
  811.             break;
  812.          case 256:
  813.             var2.x += var3 / 2;
  814.             this.alignOnBaseline(var1, var2, var5, var6);
  815.             break;
  816.          case 512:
  817.             if (this.rightToLeft) {
  818.                var2.x += var3;
  819.             }
  820.  
  821.             this.alignOnBaseline(var1, var2, var5, var6);
  822.             break;
  823.          case 768:
  824.             if (!this.rightToLeft) {
  825.                var2.x += var3;
  826.             }
  827.  
  828.             this.alignOnBaseline(var1, var2, var5, var6);
  829.             break;
  830.          case 1024:
  831.             var2.x += var3 / 2;
  832.             this.alignAboveBaseline(var1, var2, var5, var6);
  833.             break;
  834.          case 1280:
  835.             if (this.rightToLeft) {
  836.                var2.x += var3;
  837.             }
  838.  
  839.             this.alignAboveBaseline(var1, var2, var5, var6);
  840.             break;
  841.          case 1536:
  842.             if (!this.rightToLeft) {
  843.                var2.x += var3;
  844.             }
  845.  
  846.             this.alignAboveBaseline(var1, var2, var5, var6);
  847.             break;
  848.          case 1792:
  849.             var2.x += var3 / 2;
  850.             this.alignBelowBaseline(var1, var2, var5, var6);
  851.             break;
  852.          case 2048:
  853.             if (this.rightToLeft) {
  854.                var2.x += var3;
  855.             }
  856.  
  857.             this.alignBelowBaseline(var1, var2, var5, var6);
  858.             break;
  859.          case 2304:
  860.             if (!this.rightToLeft) {
  861.                var2.x += var3;
  862.             }
  863.  
  864.             this.alignBelowBaseline(var1, var2, var5, var6);
  865.             break;
  866.          default:
  867.             throw new IllegalArgumentException("illegal anchor value");
  868.       }
  869.  
  870.    }
  871.  
  872.    private void alignOnBaseline(GridBagConstraints var1, Rectangle var2, int var3, int var4) {
  873.       if (var1.ascent >= 0) {
  874.          if (var1.baselineResizeBehavior == BaselineResizeBehavior.CONSTANT_DESCENT) {
  875.             int var5 = var3 + var4 - this.layoutInfo.maxDescent[var1.tempY + var1.tempHeight - 1] + var1.descent - var1.insets.bottom;
  876.             if (!var1.isVerticallyResizable()) {
  877.                var2.y = var5 - var1.minHeight;
  878.                var2.height = var1.minHeight;
  879.             } else {
  880.                var2.height = var5 - var3 - var1.insets.top;
  881.             }
  882.          } else {
  883.             int var6 = var1.ascent;
  884.             int var10;
  885.             if (this.layoutInfo.hasConstantDescent(var1.tempY)) {
  886.                var10 = var4 - this.layoutInfo.maxDescent[var1.tempY];
  887.             } else {
  888.                var10 = this.layoutInfo.maxAscent[var1.tempY];
  889.             }
  890.  
  891.             if (var1.baselineResizeBehavior == BaselineResizeBehavior.OTHER) {
  892.                boolean var7 = false;
  893.                var6 = this.componentAdjusting.getBaseline(var2.width, var2.height);
  894.                if (var6 >= 0) {
  895.                   var6 += var1.insets.top;
  896.                }
  897.  
  898.                if (var6 >= 0 && var6 <= var10) {
  899.                   if (var10 + (var2.height - var6 - var1.insets.top) <= var4 - var1.insets.bottom) {
  900.                      var7 = true;
  901.                   } else if (var1.isVerticallyResizable()) {
  902.                      int var8 = this.componentAdjusting.getBaseline(var2.width, var4 - var1.insets.bottom - var10 + var6);
  903.                      if (var8 >= 0) {
  904.                         var8 += var1.insets.top;
  905.                      }
  906.  
  907.                      if (var8 >= 0 && var8 <= var6) {
  908.                         var2.height = var4 - var1.insets.bottom - var10 + var6;
  909.                         var6 = var8;
  910.                         var7 = true;
  911.                      }
  912.                   }
  913.                }
  914.  
  915.                if (!var7) {
  916.                   var6 = var1.ascent;
  917.                   var2.width = var1.minWidth;
  918.                   var2.height = var1.minHeight;
  919.                }
  920.             }
  921.  
  922.             var2.y = var3 + var10 - var6 + var1.insets.top;
  923.             if (var1.isVerticallyResizable()) {
  924.                switch (1.$SwitchMap$java$awt$Component$BaselineResizeBehavior[var1.baselineResizeBehavior.ordinal()]) {
  925.                   case 1:
  926.                      var2.height = Math.max(var1.minHeight, var3 + var4 - var2.y - var1.insets.bottom);
  927.                      break;
  928.                   case 2:
  929.                      int var11 = var2.y - var3 - var1.insets.top;
  930.                      int var12 = var3 + var4 - var2.y - var1.minHeight - var1.insets.bottom;
  931.                      int var9 = Math.min(var11, var12);
  932.                      var9 += var9;
  933.                      if (var9 > 0 && (var1.minHeight + var1.centerPadding + var9) / 2 + var1.centerOffset != var10) {
  934.                         --var9;
  935.                      }
  936.  
  937.                      var2.height = var1.minHeight + var9;
  938.                      var2.y = var3 + var10 - (var2.height + var1.centerPadding) / 2 - var1.centerOffset;
  939.                   case 3:
  940.                }
  941.             }
  942.          }
  943.       } else {
  944.          this.centerVertically(var1, var2, var4);
  945.       }
  946.  
  947.    }
  948.  
  949.    private void alignAboveBaseline(GridBagConstraints var1, Rectangle var2, int var3, int var4) {
  950.       if (this.layoutInfo.hasBaseline(var1.tempY)) {
  951.          int var5;
  952.          if (this.layoutInfo.hasConstantDescent(var1.tempY)) {
  953.             var5 = var3 + var4 - this.layoutInfo.maxDescent[var1.tempY];
  954.          } else {
  955.             var5 = var3 + this.layoutInfo.maxAscent[var1.tempY];
  956.          }
  957.  
  958.          if (var1.isVerticallyResizable()) {
  959.             var2.y = var3 + var1.insets.top;
  960.             var2.height = var5 - var2.y;
  961.          } else {
  962.             var2.height = var1.minHeight + var1.ipady;
  963.             var2.y = var5 - var2.height;
  964.          }
  965.       } else {
  966.          this.centerVertically(var1, var2, var4);
  967.       }
  968.  
  969.    }
  970.  
  971.    private void alignBelowBaseline(GridBagConstraints var1, Rectangle var2, int var3, int var4) {
  972.       if (this.layoutInfo.hasBaseline(var1.tempY)) {
  973.          if (this.layoutInfo.hasConstantDescent(var1.tempY)) {
  974.             var2.y = var3 + var4 - this.layoutInfo.maxDescent[var1.tempY];
  975.          } else {
  976.             var2.y = var3 + this.layoutInfo.maxAscent[var1.tempY];
  977.          }
  978.  
  979.          if (var1.isVerticallyResizable()) {
  980.             var2.height = var3 + var4 - var2.y - var1.insets.bottom;
  981.          }
  982.       } else {
  983.          this.centerVertically(var1, var2, var4);
  984.       }
  985.  
  986.    }
  987.  
  988.    private void centerVertically(GridBagConstraints var1, Rectangle var2, int var3) {
  989.       if (!var1.isVerticallyResizable()) {
  990.          var2.y += Math.max(0, (var3 - var1.insets.top - var1.insets.bottom - var1.minHeight - var1.ipady) / 2);
  991.       }
  992.  
  993.    }
  994.  
  995.    protected Dimension getMinSize(Container var1, GridBagLayoutInfo var2) {
  996.       return this.GetMinSize(var1, var2);
  997.    }
  998.  
  999.    protected Dimension GetMinSize(Container var1, GridBagLayoutInfo var2) {
  1000.       Dimension var3 = new Dimension();
  1001.       Insets var6 = var1.getInsets();
  1002.       int var5 = 0;
  1003.  
  1004.       for(int var4 = 0; var4 < var2.width; ++var4) {
  1005.          var5 += var2.minWidth[var4];
  1006.       }
  1007.  
  1008.       var3.width = var5 + var6.left + var6.right;
  1009.       var5 = 0;
  1010.  
  1011.       for(int var7 = 0; var7 < var2.height; ++var7) {
  1012.          var5 += var2.minHeight[var7];
  1013.       }
  1014.  
  1015.       var3.height = var5 + var6.top + var6.bottom;
  1016.       return var3;
  1017.    }
  1018.  
  1019.    protected void arrangeGrid(Container var1) {
  1020.       this.ArrangeGrid(var1);
  1021.    }
  1022.  
  1023.    protected void ArrangeGrid(Container var1) {
  1024.       Insets var5 = var1.getInsets();
  1025.       Component[] var6 = var1.getComponents();
  1026.       Rectangle var8 = new Rectangle();
  1027.       this.rightToLeft = !var1.getComponentOrientation().isLeftToRight();
  1028.       if (var6.length != 0 || this.columnWidths != null && this.columnWidths.length != 0 || this.rowHeights != null && this.rowHeights.length != 0) {
  1029.          GridBagLayoutInfo var14 = this.getLayoutInfo(var1, 2);
  1030.          Dimension var7 = this.getMinSize(var1, var14);
  1031.          if (var1.width < var7.width || var1.height < var7.height) {
  1032.             var14 = this.getLayoutInfo(var1, 1);
  1033.             var7 = this.getMinSize(var1, var14);
  1034.          }
  1035.  
  1036.          this.layoutInfo = var14;
  1037.          var8.width = var7.width;
  1038.          var8.height = var7.height;
  1039.          int var10 = var1.width - var8.width;
  1040.          if (var10 != 0) {
  1041.             double var12 = (double)0.0F;
  1042.  
  1043.             for(int var9 = 0; var9 < var14.width; ++var9) {
  1044.                var12 += var14.weightX[var9];
  1045.             }
  1046.  
  1047.             if (var12 > (double)0.0F) {
  1048.                for(int var16 = 0; var16 < var14.width; ++var16) {
  1049.                   int var15 = (int)((double)var10 * var14.weightX[var16] / var12);
  1050.                   int[] var10000 = var14.minWidth;
  1051.                   var10000[var16] += var15;
  1052.                   var8.width += var15;
  1053.                   if (var14.minWidth[var16] < 0) {
  1054.                      var8.width -= var14.minWidth[var16];
  1055.                      var14.minWidth[var16] = 0;
  1056.                   }
  1057.                }
  1058.             }
  1059.  
  1060.             var10 = var1.width - var8.width;
  1061.          } else {
  1062.             var10 = 0;
  1063.          }
  1064.  
  1065.          int var11 = var1.height - var8.height;
  1066.          if (var11 != 0) {
  1067.             double var26 = (double)0.0F;
  1068.  
  1069.             for(int var17 = 0; var17 < var14.height; ++var17) {
  1070.                var26 += var14.weightY[var17];
  1071.             }
  1072.  
  1073.             if (var26 > (double)0.0F) {
  1074.                for(int var18 = 0; var18 < var14.height; ++var18) {
  1075.                   int var27 = (int)((double)var11 * var14.weightY[var18] / var26);
  1076.                   int[] var28 = var14.minHeight;
  1077.                   var28[var18] += var27;
  1078.                   var8.height += var27;
  1079.                   if (var14.minHeight[var18] < 0) {
  1080.                      var8.height -= var14.minHeight[var18];
  1081.                      var14.minHeight[var18] = 0;
  1082.                   }
  1083.                }
  1084.             }
  1085.  
  1086.             var11 = var1.height - var8.height;
  1087.          } else {
  1088.             var11 = 0;
  1089.          }
  1090.  
  1091.          var14.startx = var10 / 2 + var5.left;
  1092.          var14.starty = var11 / 2 + var5.top;
  1093.  
  1094.          for(int var3 = 0; var3 < var6.length; ++var3) {
  1095.             Component var2 = var6[var3];
  1096.             if (var2.isVisible()) {
  1097.                GridBagConstraints var4 = this.lookupConstraints(var2);
  1098.                if (!this.rightToLeft) {
  1099.                   var8.x = var14.startx;
  1100.  
  1101.                   for(int var19 = 0; var19 < var4.tempX; ++var19) {
  1102.                      var8.x += var14.minWidth[var19];
  1103.                   }
  1104.                } else {
  1105.                   var8.x = var1.width - (var10 / 2 + var5.right);
  1106.  
  1107.                   for(int var20 = 0; var20 < var4.tempX; ++var20) {
  1108.                      var8.x -= var14.minWidth[var20];
  1109.                   }
  1110.                }
  1111.  
  1112.                var8.y = var14.starty;
  1113.  
  1114.                for(int var21 = 0; var21 < var4.tempY; ++var21) {
  1115.                   var8.y += var14.minHeight[var21];
  1116.                }
  1117.  
  1118.                var8.width = 0;
  1119.  
  1120.                for(int var22 = var4.tempX; var22 < var4.tempX + var4.tempWidth; ++var22) {
  1121.                   var8.width += var14.minWidth[var22];
  1122.                }
  1123.  
  1124.                var8.height = 0;
  1125.  
  1126.                for(int var23 = var4.tempY; var23 < var4.tempY + var4.tempHeight; ++var23) {
  1127.                   var8.height += var14.minHeight[var23];
  1128.                }
  1129.  
  1130.                this.componentAdjusting = var2;
  1131.                this.adjustForGravity(var4, var8);
  1132.                if (var8.x < 0) {
  1133.                   var8.width += var8.x;
  1134.                   var8.x = 0;
  1135.                }
  1136.  
  1137.                if (var8.y < 0) {
  1138.                   var8.height += var8.y;
  1139.                   var8.y = 0;
  1140.                }
  1141.  
  1142.                if (var8.width > 0 && var8.height > 0) {
  1143.                   if (var2.x != var8.x || var2.y != var8.y || var2.width != var8.width || var2.height != var8.height) {
  1144.                      var2.setBounds(var8.x, var8.y, var8.width, var8.height);
  1145.                   }
  1146.                } else {
  1147.                   var2.setBounds(0, 0, 0, 0);
  1148.                }
  1149.             }
  1150.          }
  1151.  
  1152.       }
  1153.    }
  1154. }
  1155.