-Clazz.declarePackage ("java.awt");\r
-Clazz.load (["java.awt.LayoutManager2"], "java.awt.GridBagLayout", ["java.lang.IllegalArgumentException", "java.util.Arrays", "$.Hashtable", "java.awt.Component", "$.Dimension", "$.GridBagConstraints", "$.GridBagLayoutInfo", "$.Point", "$.Rectangle"], function () {\r
-c$ = Clazz.decorateAsClass (function () {\r
-this.comptable = null;\r
-this.defaultConstraints = null;\r
-this.layoutInfo = null;\r
-this.columnWidths = null;\r
-this.rowHeights = null;\r
-this.columnWeights = null;\r
-this.rowWeights = null;\r
-this.componentAdjusting = null;\r
-this.rightToLeft = false;\r
-Clazz.instantialize (this, arguments);\r
-}, java.awt, "GridBagLayout", null, [java.awt.LayoutManager2, java.io.Serializable]);\r
-Clazz.makeConstructor (c$, \r
-function () {\r
-this.comptable = new java.util.Hashtable ();\r
-this.defaultConstraints = new java.awt.GridBagConstraints ();\r
-});\r
-Clazz.defineMethod (c$, "setConstraints", \r
-function (comp, constraints) {\r
-this.comptable.put (comp, constraints.clone ());\r
-}, "java.awt.Component,java.awt.GridBagConstraints");\r
-Clazz.defineMethod (c$, "getConstraints", \r
-function (comp) {\r
-var constraints = this.comptable.get (comp);\r
-if (constraints == null) {\r
-this.setConstraints (comp, this.defaultConstraints);\r
-constraints = this.comptable.get (comp);\r
-}return constraints.clone ();\r
-}, "java.awt.Component");\r
-Clazz.defineMethod (c$, "lookupConstraints", \r
-function (comp) {\r
-var constraints = this.comptable.get (comp);\r
-if (constraints == null) {\r
-this.setConstraints (comp, this.defaultConstraints);\r
-constraints = this.comptable.get (comp);\r
-}return constraints;\r
-}, "java.awt.Component");\r
-Clazz.defineMethod (c$, "removeConstraints", \r
- function (comp) {\r
-this.comptable.remove (comp);\r
-}, "java.awt.Component");\r
-Clazz.defineMethod (c$, "getLayoutOrigin", \r
-function () {\r
-var origin = new java.awt.Point (0, 0);\r
-if (this.layoutInfo != null) {\r
-origin.x = this.layoutInfo.startx;\r
-origin.y = this.layoutInfo.starty;\r
-}return origin;\r
-});\r
-Clazz.defineMethod (c$, "getLayoutDimensions", \r
-function () {\r
-if (this.layoutInfo == null) return Clazz.newIntArray (2, 0, 0);\r
-var dim = Clazz.newIntArray (2, 0);\r
-dim[0] = Clazz.newIntArray (this.layoutInfo.width, 0);\r
-dim[1] = Clazz.newIntArray (this.layoutInfo.height, 0);\r
-System.arraycopy (this.layoutInfo.minWidth, 0, dim[0], 0, this.layoutInfo.width);\r
-System.arraycopy (this.layoutInfo.minHeight, 0, dim[1], 0, this.layoutInfo.height);\r
-return dim;\r
-});\r
-Clazz.defineMethod (c$, "getLayoutWeights", \r
-function () {\r
-if (this.layoutInfo == null) return Clazz.newDoubleArray (2, 0, 0);\r
-var weights = Clazz.newDoubleArray (2, 0);\r
-weights[0] = Clazz.newDoubleArray (this.layoutInfo.width, 0);\r
-weights[1] = Clazz.newDoubleArray (this.layoutInfo.height, 0);\r
-System.arraycopy (this.layoutInfo.weightX, 0, weights[0], 0, this.layoutInfo.width);\r
-System.arraycopy (this.layoutInfo.weightY, 0, weights[1], 0, this.layoutInfo.height);\r
-return weights;\r
-});\r
-Clazz.defineMethod (c$, "location", \r
-function (x, y) {\r
-var loc = new java.awt.Point (0, 0);\r
-var i;\r
-var d;\r
-if (this.layoutInfo == null) return loc;\r
-d = this.layoutInfo.startx;\r
-if (!this.rightToLeft) {\r
-for (i = 0; i < this.layoutInfo.width; i++) {\r
-d += this.layoutInfo.minWidth[i];\r
-if (d > x) break;\r
-}\r
-} else {\r
-for (i = this.layoutInfo.width - 1; i >= 0; i--) {\r
-if (d > x) break;\r
-d += this.layoutInfo.minWidth[i];\r
-}\r
-i++;\r
-}loc.x = i;\r
-d = this.layoutInfo.starty;\r
-for (i = 0; i < this.layoutInfo.height; i++) {\r
-d += this.layoutInfo.minHeight[i];\r
-if (d > y) break;\r
-}\r
-loc.y = i;\r
-return loc;\r
-}, "~N,~N");\r
-Clazz.defineMethod (c$, "addLayoutComponent", \r
-function (name, comp) {\r
-}, "~S,java.awt.Component");\r
-Clazz.defineMethod (c$, "addLayoutComponent", \r
-function (comp, constraints) {\r
-if (Clazz.instanceOf (constraints, java.awt.GridBagConstraints)) {\r
-this.setConstraints (comp, constraints);\r
-} else if (constraints != null) {\r
-throw new IllegalArgumentException ("cannot add to layout: constraints must be a GridBagConstraint");\r
-}}, "java.awt.Component,~O");\r
-Clazz.overrideMethod (c$, "removeLayoutComponent", \r
-function (comp) {\r
-this.removeConstraints (comp);\r
-}, "java.awt.Component");\r
-Clazz.overrideMethod (c$, "preferredLayoutSize", \r
-function (parent) {\r
-var info = this.getLayoutInfo (parent, 2);\r
-return this.getMinSize (parent, info);\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "minimumLayoutSize", \r
-function (parent) {\r
-var info = this.getLayoutInfo (parent, 1);\r
-return this.getMinSize (parent, info);\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "maximumLayoutSize", \r
-function (target) {\r
-return new java.awt.Dimension (2147483647, 2147483647);\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "getLayoutAlignmentX", \r
-function (parent) {\r
-return 0.5;\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "getLayoutAlignmentY", \r
-function (parent) {\r
-return 0.5;\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "invalidateLayout", \r
-function (target) {\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "layoutContainer", \r
-function (parent) {\r
-System.out.println ("GridBagLayout laying out " + parent);\r
-this.arrangeGrid (parent);\r
-}, "java.awt.Container");\r
-Clazz.overrideMethod (c$, "toString", \r
-function () {\r
-return this.getClass ().getName ();\r
-});\r
-Clazz.defineMethod (c$, "getLayoutInfo", \r
-function (parent, sizeflag) {\r
-return this.GetLayoutInfo (parent, sizeflag);\r
-}, "java.awt.Container,~N");\r
-Clazz.defineMethod (c$, "preInitMaximumArraySizes", \r
- function (parent) {\r
-var components = parent.getComponents ();\r
-var comp;\r
-var constraints;\r
-var curX;\r
-var curY;\r
-var curWidth;\r
-var curHeight;\r
-var preMaximumArrayXIndex = 0;\r
-var preMaximumArrayYIndex = 0;\r
-var returnArray = Clazz.newLongArray (2, 0);\r
-for (var compId = 0; compId < components.length; compId++) {\r
-comp = components[compId];\r
-if (!comp.isVisible ()) {\r
-continue;\r
-}constraints = this.lookupConstraints (comp);\r
-curX = constraints.gridx;\r
-curY = constraints.gridy;\r
-curWidth = constraints.gridwidth;\r
-curHeight = constraints.gridheight;\r
-if (curX < 0) {\r
-curX = ++preMaximumArrayYIndex;\r
-}if (curY < 0) {\r
-curY = ++preMaximumArrayXIndex;\r
-}if (curWidth <= 0) {\r
-curWidth = 1;\r
-}if (curHeight <= 0) {\r
-curHeight = 1;\r
-}preMaximumArrayXIndex = Math.max (curY + curHeight, preMaximumArrayXIndex);\r
-preMaximumArrayYIndex = Math.max (curX + curWidth, preMaximumArrayYIndex);\r
-}\r
-returnArray[0] = preMaximumArrayXIndex;\r
-returnArray[1] = preMaximumArrayYIndex;\r
-return returnArray;\r
-}, "java.awt.Container");\r
-Clazz.defineMethod (c$, "GetLayoutInfo", \r
-function (parent, sizeflag) {\r
-{\r
-var r;\r
-var comp;\r
-var constraints;\r
-var d;\r
-var components = parent.getComponents ();\r
-var layoutWidth;\r
-var layoutHeight;\r
-var xMaxArray;\r
-var yMaxArray;\r
-var compindex;\r
-var i;\r
-var k;\r
-var px;\r
-var py;\r
-var pixels_diff;\r
-var nextSize;\r
-var curX = 0;\r
-var curY = 0;\r
-var curWidth = 1;\r
-var curHeight = 1;\r
-var curRow;\r
-var curCol;\r
-var weight_diff;\r
-var weight;\r
-var maximumArrayXIndex = 0;\r
-var maximumArrayYIndex = 0;\r
-var anchor;\r
-layoutWidth = layoutHeight = 0;\r
-curRow = curCol = -1;\r
-var arraySizes = this.preInitMaximumArraySizes (parent);\r
-maximumArrayXIndex = (2 * arraySizes[0] > 2147483647) ? 2147483647 : 2 * arraySizes[0];\r
-maximumArrayYIndex = (2 * arraySizes[1] > 2147483647) ? 2147483647 : 2 * arraySizes[1];\r
-if (this.rowHeights != null) {\r
-maximumArrayXIndex = Math.max (maximumArrayXIndex, this.rowHeights.length);\r
-}if (this.columnWidths != null) {\r
-maximumArrayYIndex = Math.max (maximumArrayYIndex, this.columnWidths.length);\r
-}xMaxArray = Clazz.newIntArray (maximumArrayXIndex, 0);\r
-yMaxArray = Clazz.newIntArray (maximumArrayYIndex, 0);\r
-var hasBaseline = false;\r
-for (compindex = 0; compindex < components.length; compindex++) {\r
-comp = components[compindex];\r
-if (!comp.isVisible ()) continue;\r
-constraints = this.lookupConstraints (comp);\r
-curX = constraints.gridx;\r
-curY = constraints.gridy;\r
-curWidth = constraints.gridwidth;\r
-if (curWidth <= 0) curWidth = 1;\r
-curHeight = constraints.gridheight;\r
-if (curHeight <= 0) curHeight = 1;\r
-if (curX < 0 && curY < 0) {\r
-if (curRow >= 0) curY = curRow;\r
- else if (curCol >= 0) curX = curCol;\r
- else curY = 0;\r
-}if (curX < 0) {\r
-px = 0;\r
-for (i = curY; i < (curY + curHeight); i++) {\r
-px = Math.max (px, xMaxArray[i]);\r
-}\r
-curX = px - curX - 1;\r
-if (curX < 0) curX = 0;\r
-} else if (curY < 0) {\r
-py = 0;\r
-for (i = curX; i < (curX + curWidth); i++) {\r
-py = Math.max (py, yMaxArray[i]);\r
-}\r
-curY = py - curY - 1;\r
-if (curY < 0) curY = 0;\r
-}px = curX + curWidth;\r
-if (layoutWidth < px) {\r
-layoutWidth = px;\r
-}py = curY + curHeight;\r
-if (layoutHeight < py) {\r
-layoutHeight = py;\r
-}for (i = curX; i < (curX + curWidth); i++) {\r
-yMaxArray[i] = py;\r
-}\r
-for (i = curY; i < (curY + curHeight); i++) {\r
-xMaxArray[i] = px;\r
-}\r
-if (sizeflag == 2) d = comp.getPreferredSize ();\r
- else d = comp.getMinimumSize ();\r
-constraints.minWidth = d.width;\r
-constraints.minHeight = d.height;\r
-if (this.calculateBaseline (comp, constraints, d)) {\r
-hasBaseline = true;\r
-}if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;\r
-if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;\r
- else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;\r
-}\r
-if (this.columnWidths != null && layoutWidth < this.columnWidths.length) layoutWidth = this.columnWidths.length;\r
-if (this.rowHeights != null && layoutHeight < this.rowHeights.length) layoutHeight = this.rowHeights.length;\r
-r = new java.awt.GridBagLayoutInfo (layoutWidth, layoutHeight);\r
-curRow = curCol = -1;\r
-java.util.Arrays.fill (xMaxArray, 0);\r
-java.util.Arrays.fill (yMaxArray, 0);\r
-var maxAscent = null;\r
-var maxDescent = null;\r
-var baselineType = null;\r
-if (hasBaseline) {\r
-r.maxAscent = maxAscent = Clazz.newIntArray (layoutHeight, 0);\r
-r.maxDescent = maxDescent = Clazz.newIntArray (layoutHeight, 0);\r
-r.baselineType = baselineType = Clazz.newShortArray (layoutHeight, 0);\r
-r.$hasBaseline = true;\r
-}for (compindex = 0; compindex < components.length; compindex++) {\r
-comp = components[compindex];\r
-if (!comp.isVisible ()) continue;\r
-constraints = this.lookupConstraints (comp);\r
-curX = constraints.gridx;\r
-curY = constraints.gridy;\r
-curWidth = constraints.gridwidth;\r
-curHeight = constraints.gridheight;\r
-if (curX < 0 && curY < 0) {\r
-if (curRow >= 0) curY = curRow;\r
- else if (curCol >= 0) curX = curCol;\r
- else curY = 0;\r
-}if (curX < 0) {\r
-if (curHeight <= 0) {\r
-curHeight += r.height - curY;\r
-if (curHeight < 1) curHeight = 1;\r
-}px = 0;\r
-for (i = curY; i < (curY + curHeight); i++) px = Math.max (px, xMaxArray[i]);\r
-\r
-curX = px - curX - 1;\r
-if (curX < 0) curX = 0;\r
-} else if (curY < 0) {\r
-if (curWidth <= 0) {\r
-curWidth += r.width - curX;\r
-if (curWidth < 1) curWidth = 1;\r
-}py = 0;\r
-for (i = curX; i < (curX + curWidth); i++) {\r
-py = Math.max (py, yMaxArray[i]);\r
-}\r
-curY = py - curY - 1;\r
-if (curY < 0) curY = 0;\r
-}if (curWidth <= 0) {\r
-curWidth += r.width - curX;\r
-if (curWidth < 1) curWidth = 1;\r
-}if (curHeight <= 0) {\r
-curHeight += r.height - curY;\r
-if (curHeight < 1) curHeight = 1;\r
-}px = curX + curWidth;\r
-py = curY + curHeight;\r
-for (i = curX; i < (curX + curWidth); i++) {\r
-yMaxArray[i] = py;\r
-}\r
-for (i = curY; i < (curY + curHeight); i++) {\r
-xMaxArray[i] = px;\r
-}\r
-if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;\r
-if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;\r
- else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;\r
-constraints.tempX = curX;\r
-constraints.tempY = curY;\r
-constraints.tempWidth = curWidth;\r
-constraints.tempHeight = curHeight;\r
-anchor = constraints.anchor;\r
-if (hasBaseline) {\r
-switch (anchor) {\r
-case 256:\r
-case 512:\r
-case 768:\r
-if (constraints.ascent >= 0) {\r
-if (curHeight == 1) {\r
-maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);\r
-maxDescent[curY] = Math.max (maxDescent[curY], constraints.descent);\r
-} else {\r
-if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
-maxDescent[curY + curHeight - 1] = Math.max (maxDescent[curY + curHeight - 1], constraints.descent);\r
-} else {\r
-maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);\r
-}}if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
-baselineType[curY + curHeight - 1] |= (1 << constraints.baselineResizeBehavior.ordinal ());\r
-} else {\r
-baselineType[curY] |= (1 << constraints.baselineResizeBehavior.ordinal ());\r
-}}break;\r
-case 1024:\r
-case 1280:\r
-case 1536:\r
-pixels_diff = constraints.minHeight + constraints.insets.top + constraints.ipady;\r
-maxAscent[curY] = Math.max (maxAscent[curY], pixels_diff);\r
-maxDescent[curY] = Math.max (maxDescent[curY], constraints.insets.bottom);\r
-break;\r
-case 1792:\r
-case 2048:\r
-case 2304:\r
-pixels_diff = constraints.minHeight + constraints.insets.bottom + constraints.ipady;\r
-maxDescent[curY] = Math.max (maxDescent[curY], pixels_diff);\r
-maxAscent[curY] = Math.max (maxAscent[curY], constraints.insets.top);\r
-break;\r
-}\r
-}}\r
-r.weightX = Clazz.newDoubleArray (maximumArrayYIndex, 0);\r
-r.weightY = Clazz.newDoubleArray (maximumArrayXIndex, 0);\r
-r.minWidth = Clazz.newIntArray (maximumArrayYIndex, 0);\r
-r.minHeight = Clazz.newIntArray (maximumArrayXIndex, 0);\r
-if (this.columnWidths != null) System.arraycopy (this.columnWidths, 0, r.minWidth, 0, this.columnWidths.length);\r
-if (this.rowHeights != null) System.arraycopy (this.rowHeights, 0, r.minHeight, 0, this.rowHeights.length);\r
-if (this.columnWeights != null) System.arraycopy (this.columnWeights, 0, r.weightX, 0, Math.min (r.weightX.length, this.columnWeights.length));\r
-if (this.rowWeights != null) System.arraycopy (this.rowWeights, 0, r.weightY, 0, Math.min (r.weightY.length, this.rowWeights.length));\r
-nextSize = 2147483647;\r
-for (i = 1; i != 2147483647; i = nextSize, nextSize = 2147483647) {\r
-for (compindex = 0; compindex < components.length; compindex++) {\r
-comp = components[compindex];\r
-if (!comp.isVisible ()) continue;\r
-constraints = this.lookupConstraints (comp);\r
-if (constraints.tempWidth == i) {\r
-px = constraints.tempX + constraints.tempWidth;\r
-weight_diff = constraints.weightx;\r
-for (k = constraints.tempX; k < px; k++) weight_diff -= r.weightX[k];\r
-\r
-if (weight_diff > 0.0) {\r
-weight = 0.0;\r
-for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];\r
-\r
-for (k = constraints.tempX; weight > 0.0 && k < px; k++) {\r
-var wt = r.weightX[k];\r
-var dx = (wt * weight_diff) / weight;\r
-r.weightX[k] += dx;\r
-weight_diff -= dx;\r
-weight -= wt;\r
-}\r
-r.weightX[px - 1] += weight_diff;\r
-}pixels_diff = constraints.minWidth + constraints.ipadx + constraints.insets.left + constraints.insets.right;\r
-for (k = constraints.tempX; k < px; k++) pixels_diff -= r.minWidth[k];\r
-\r
-if (pixels_diff > 0) {\r
-weight = 0.0;\r
-for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];\r
-\r
-for (k = constraints.tempX; weight > 0.0 && k < px; k++) {\r
-var wt = r.weightX[k];\r
-var dx = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);\r
-r.minWidth[k] += dx;\r
-pixels_diff -= dx;\r
-weight -= wt;\r
-}\r
-r.minWidth[px - 1] += pixels_diff;\r
-}} else if (constraints.tempWidth > i && constraints.tempWidth < nextSize) nextSize = constraints.tempWidth;\r
-if (constraints.tempHeight == i) {\r
-py = constraints.tempY + constraints.tempHeight;\r
-weight_diff = constraints.weighty;\r
-for (k = constraints.tempY; k < py; k++) weight_diff -= r.weightY[k];\r
-\r
-if (weight_diff > 0.0) {\r
-weight = 0.0;\r
-for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];\r
-\r
-for (k = constraints.tempY; weight > 0.0 && k < py; k++) {\r
-var wt = r.weightY[k];\r
-var dy = (wt * weight_diff) / weight;\r
-r.weightY[k] += dy;\r
-weight_diff -= dy;\r
-weight -= wt;\r
-}\r
-r.weightY[py - 1] += weight_diff;\r
-}pixels_diff = -1;\r
-if (hasBaseline) {\r
-switch (constraints.anchor) {\r
-case 256:\r
-case 512:\r
-case 768:\r
-if (constraints.ascent >= 0) {\r
-if (constraints.tempHeight == 1) {\r
-pixels_diff = maxAscent[constraints.tempY] + maxDescent[constraints.tempY];\r
-} else if (constraints.baselineResizeBehavior !== java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
-pixels_diff = maxAscent[constraints.tempY] + constraints.descent;\r
-} else {\r
-pixels_diff = constraints.ascent + maxDescent[constraints.tempY + constraints.tempHeight - 1];\r
-}}break;\r
-case 1024:\r
-case 1280:\r
-case 1536:\r
-pixels_diff = constraints.insets.top + constraints.minHeight + constraints.ipady + maxDescent[constraints.tempY];\r
-break;\r
-case 1792:\r
-case 2048:\r
-case 2304:\r
-pixels_diff = maxAscent[constraints.tempY] + constraints.minHeight + constraints.insets.bottom + constraints.ipady;\r
-break;\r
-}\r
-}if (pixels_diff == -1) {\r
-pixels_diff = constraints.minHeight + constraints.ipady + constraints.insets.top + constraints.insets.bottom;\r
-}for (k = constraints.tempY; k < py; k++) pixels_diff -= r.minHeight[k];\r
-\r
-if (pixels_diff > 0) {\r
-weight = 0.0;\r
-for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];\r
-\r
-for (k = constraints.tempY; weight > 0.0 && k < py; k++) {\r
-var wt = r.weightY[k];\r
-var dy = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);\r
-r.minHeight[k] += dy;\r
-pixels_diff -= dy;\r
-weight -= wt;\r
-}\r
-r.minHeight[py - 1] += pixels_diff;\r
-}} else if (constraints.tempHeight > i && constraints.tempHeight < nextSize) nextSize = constraints.tempHeight;\r
-}\r
-}\r
-return r;\r
-}}, "java.awt.Container,~N");\r
-Clazz.defineMethod (c$, "calculateBaseline", \r
- function (c, constraints, size) {\r
-var anchor = constraints.anchor;\r
-if (anchor == 256 || anchor == 512 || anchor == 768) {\r
-var w = size.width + constraints.ipadx;\r
-var h = size.height + constraints.ipady;\r
-constraints.ascent = c.getBaseline (w, h);\r
-if (constraints.ascent >= 0) {\r
-var baseline = constraints.ascent;\r
-constraints.descent = h - constraints.ascent + constraints.insets.bottom;\r
-constraints.ascent += constraints.insets.top;\r
-constraints.baselineResizeBehavior = c.getBaselineResizeBehavior ();\r
-constraints.centerPadding = 0;\r
-if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET) {\r
-var nextBaseline = c.getBaseline (w, h + 1);\r
-constraints.centerOffset = baseline - Clazz.doubleToInt (h / 2);\r
-if (h % 2 == 0) {\r
-if (baseline != nextBaseline) {\r
-constraints.centerPadding = 1;\r
-}} else if (baseline == nextBaseline) {\r
-constraints.centerOffset--;\r
-constraints.centerPadding = 1;\r
-}}}return true;\r
-} else {\r
-constraints.ascent = -1;\r
-return false;\r
-}}, "java.awt.Component,java.awt.GridBagConstraints,java.awt.Dimension");\r
-Clazz.defineMethod (c$, "adjustForGravity", \r
-function (constraints, r) {\r
-this.AdjustForGravity (constraints, r);\r
-}, "java.awt.GridBagConstraints,java.awt.Rectangle");\r
-Clazz.defineMethod (c$, "AdjustForGravity", \r
-function (constraints, r) {\r
-var diffx;\r
-var diffy;\r
-var cellY = r.y;\r
-var cellHeight = r.height;\r
-if (!this.rightToLeft) {\r
-r.x += constraints.insets.left;\r
-} else {\r
-r.x -= r.width - constraints.insets.right;\r
-}r.width -= (constraints.insets.left + constraints.insets.right);\r
-r.y += constraints.insets.top;\r
-r.height -= (constraints.insets.top + constraints.insets.bottom);\r
-diffx = 0;\r
-if ((constraints.fill != 2 && constraints.fill != 1) && (r.width > (constraints.minWidth + constraints.ipadx))) {\r
-diffx = r.width - (constraints.minWidth + constraints.ipadx);\r
-r.width = constraints.minWidth + constraints.ipadx;\r
-}diffy = 0;\r
-if ((constraints.fill != 3 && constraints.fill != 1) && (r.height > (constraints.minHeight + constraints.ipady))) {\r
-diffy = r.height - (constraints.minHeight + constraints.ipady);\r
-r.height = constraints.minHeight + constraints.ipady;\r
-}switch (constraints.anchor) {\r
-case 256:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 512:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 768:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 1024:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 1280:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 1536:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 1792:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 2048:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 2304:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
-break;\r
-case 10:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-r.y += Clazz.doubleToInt (diffy / 2);\r
-break;\r
-case 19:\r
-case 11:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-break;\r
-case 12:\r
-r.x += diffx;\r
-break;\r
-case 13:\r
-r.x += diffx;\r
-r.y += Clazz.doubleToInt (diffy / 2);\r
-break;\r
-case 14:\r
-r.x += diffx;\r
-r.y += diffy;\r
-break;\r
-case 20:\r
-case 15:\r
-r.x += Clazz.doubleToInt (diffx / 2);\r
-r.y += diffy;\r
-break;\r
-case 16:\r
-r.y += diffy;\r
-break;\r
-case 17:\r
-r.y += Clazz.doubleToInt (diffy / 2);\r
-break;\r
-case 18:\r
-break;\r
-case 21:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}r.y += Clazz.doubleToInt (diffy / 2);\r
-break;\r
-case 22:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}r.y += Clazz.doubleToInt (diffy / 2);\r
-break;\r
-case 23:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}break;\r
-case 24:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}break;\r
-case 25:\r
-if (this.rightToLeft) {\r
-r.x += diffx;\r
-}r.y += diffy;\r
-break;\r
-case 26:\r
-if (!this.rightToLeft) {\r
-r.x += diffx;\r
-}r.y += diffy;\r
-break;\r
-default:\r
-throw new IllegalArgumentException ("illegal anchor value");\r
-}\r
-}, "java.awt.GridBagConstraints,java.awt.Rectangle");\r
-Clazz.defineMethod (c$, "alignOnBaseline", \r
- function (cons, r, cellY, cellHeight) {\r
-if (cons.ascent >= 0) {\r
-if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
-var maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY + cons.tempHeight - 1] + cons.descent - cons.insets.bottom;\r
-if (!cons.isVerticallyResizable ()) {\r
-r.y = maxY - cons.minHeight;\r
-r.height = cons.minHeight;\r
-} else {\r
-r.height = maxY - cellY - cons.insets.top;\r
-}} else {\r
-var baseline;\r
-var ascent = cons.ascent;\r
-if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
-baseline = cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
-} else {\r
-baseline = this.layoutInfo.maxAscent[cons.tempY];\r
-}if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.OTHER) {\r
-var fits = false;\r
-ascent = this.componentAdjusting.getBaseline (r.width, r.height);\r
-if (ascent >= 0) {\r
-ascent += cons.insets.top;\r
-}if (ascent >= 0 && ascent <= baseline) {\r
-if (baseline + (r.height - ascent - cons.insets.top) <= cellHeight - cons.insets.bottom) {\r
-fits = true;\r
-} else if (cons.isVerticallyResizable ()) {\r
-var ascent2 = this.componentAdjusting.getBaseline (r.width, cellHeight - cons.insets.bottom - baseline + ascent);\r
-if (ascent2 >= 0) {\r
-ascent2 += cons.insets.top;\r
-}if (ascent2 >= 0 && ascent2 <= ascent) {\r
-r.height = cellHeight - cons.insets.bottom - baseline + ascent;\r
-ascent = ascent2;\r
-fits = true;\r
-}}}if (!fits) {\r
-ascent = cons.ascent;\r
-r.width = cons.minWidth;\r
-r.height = cons.minHeight;\r
-}}r.y = cellY + baseline - ascent + cons.insets.top;\r
-if (cons.isVerticallyResizable ()) {\r
-switch (cons.baselineResizeBehavior) {\r
-case java.awt.Component.BaselineResizeBehavior.CONSTANT_ASCENT:\r
-r.height = Math.max (cons.minHeight, cellY + cellHeight - r.y - cons.insets.bottom);\r
-break;\r
-case java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET:\r
-{\r
-var upper = r.y - cellY - cons.insets.top;\r
-var lower = cellY + cellHeight - r.y - cons.minHeight - cons.insets.bottom;\r
-var delta = Math.min (upper, lower);\r
-delta += delta;\r
-if (delta > 0 && Clazz.doubleToInt ((cons.minHeight + cons.centerPadding + delta) / 2) + cons.centerOffset != baseline) {\r
-delta--;\r
-}r.height = cons.minHeight + delta;\r
-r.y = cellY + baseline - Clazz.doubleToInt ((r.height + cons.centerPadding) / 2) - cons.centerOffset;\r
-}break;\r
-case java.awt.Component.BaselineResizeBehavior.OTHER:\r
-break;\r
-default:\r
-break;\r
-}\r
-}}} else {\r
-this.centerVertically (cons, r, cellHeight);\r
-}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
-Clazz.defineMethod (c$, "alignAboveBaseline", \r
- function (cons, r, cellY, cellHeight) {\r
-if (this.layoutInfo.hasBaseline (cons.tempY)) {\r
-var maxY;\r
-if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
-maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
-} else {\r
-maxY = cellY + this.layoutInfo.maxAscent[cons.tempY];\r
-}if (cons.isVerticallyResizable ()) {\r
-r.y = cellY + cons.insets.top;\r
-r.height = maxY - r.y;\r
-} else {\r
-r.height = cons.minHeight + cons.ipady;\r
-r.y = maxY - r.height;\r
-}} else {\r
-this.centerVertically (cons, r, cellHeight);\r
-}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
-Clazz.defineMethod (c$, "alignBelowBaseline", \r
- function (cons, r, cellY, cellHeight) {\r
-if (this.layoutInfo.hasBaseline (cons.tempY)) {\r
-if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
-r.y = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
-} else {\r
-r.y = cellY + this.layoutInfo.maxAscent[cons.tempY];\r
-}if (cons.isVerticallyResizable ()) {\r
-r.height = cellY + cellHeight - r.y - cons.insets.bottom;\r
-}} else {\r
-this.centerVertically (cons, r, cellHeight);\r
-}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
-Clazz.defineMethod (c$, "centerVertically", \r
- function (cons, r, cellHeight) {\r
-if (!cons.isVerticallyResizable ()) {\r
-r.y += Math.max (0, Clazz.doubleToInt ((cellHeight - cons.insets.top - cons.insets.bottom - cons.minHeight - cons.ipady) / 2));\r
-}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N");\r
-Clazz.defineMethod (c$, "getMinSize", \r
-function (parent, info) {\r
-return this.GetMinSize (parent, info);\r
-}, "java.awt.Container,java.awt.GridBagLayoutInfo");\r
-Clazz.defineMethod (c$, "GetMinSize", \r
-function (parent, info) {\r
-var d = new java.awt.Dimension ();\r
-var i;\r
-var t;\r
-var insets = parent.getInsets ();\r
-t = 0;\r
-for (i = 0; i < info.width; i++) t += info.minWidth[i];\r
-\r
-d.width = t + insets.left + insets.right;\r
-t = 0;\r
-for (i = 0; i < info.height; i++) t += info.minHeight[i];\r
-\r
-d.height = t + insets.top + insets.bottom;\r
-return d;\r
-}, "java.awt.Container,java.awt.GridBagLayoutInfo");\r
-Clazz.defineMethod (c$, "arrangeGrid", \r
-function (parent) {\r
-this.ArrangeGrid (parent);\r
-}, "java.awt.Container");\r
-Clazz.defineMethod (c$, "ArrangeGrid", \r
-function (parent) {\r
-var comp;\r
-var compindex;\r
-var constraints;\r
-var insets = parent.getInsets ();\r
-var components = parent.getComponents ();\r
-var d;\r
-var r = new java.awt.Rectangle ();\r
-var i;\r
-var diffw;\r
-var diffh;\r
-var weight;\r
-var info;\r
-this.rightToLeft = !parent.getComponentOrientation ().isLeftToRight ();\r
-if (components.length == 0 && (this.columnWidths == null || this.columnWidths.length == 0) && (this.rowHeights == null || this.rowHeights.length == 0)) {\r
-return;\r
-}info = this.getLayoutInfo (parent, 2);\r
-d = this.getMinSize (parent, info);\r
-if (parent.width < d.width || parent.height < d.height) {\r
-info = this.getLayoutInfo (parent, 1);\r
-d = this.getMinSize (parent, info);\r
-}this.layoutInfo = info;\r
-r.width = d.width;\r
-r.height = d.height;\r
-diffw = parent.width - r.width;\r
-if (diffw != 0) {\r
-weight = 0.0;\r
-for (i = 0; i < info.width; i++) weight += info.weightX[i];\r
-\r
-if (weight > 0.0) {\r
-for (i = 0; i < info.width; i++) {\r
-var dx = Clazz.doubleToInt (((diffw) * info.weightX[i]) / weight);\r
-info.minWidth[i] += dx;\r
-r.width += dx;\r
-if (info.minWidth[i] < 0) {\r
-r.width -= info.minWidth[i];\r
-info.minWidth[i] = 0;\r
-}}\r
-}diffw = parent.width - r.width;\r
-} else {\r
-diffw = 0;\r
-}diffh = parent.height - r.height;\r
-if (diffh != 0) {\r
-weight = 0.0;\r
-for (i = 0; i < info.height; i++) weight += info.weightY[i];\r
-\r
-if (weight > 0.0) {\r
-for (i = 0; i < info.height; i++) {\r
-var dy = Clazz.doubleToInt (((diffh) * info.weightY[i]) / weight);\r
-info.minHeight[i] += dy;\r
-r.height += dy;\r
-if (info.minHeight[i] < 0) {\r
-r.height -= info.minHeight[i];\r
-info.minHeight[i] = 0;\r
-}}\r
-}diffh = parent.height - r.height;\r
-} else {\r
-diffh = 0;\r
-}info.startx = Clazz.doubleToInt (diffw / 2) + insets.left;\r
-info.starty = Clazz.doubleToInt (diffh / 2) + insets.top;\r
-for (compindex = 0; compindex < components.length; compindex++) {\r
-comp = components[compindex];\r
-if (!comp.isVisible ()) {\r
-continue;\r
-}constraints = this.lookupConstraints (comp);\r
-if (!this.rightToLeft) {\r
-r.x = info.startx;\r
-for (i = 0; i < constraints.tempX; i++) r.x += info.minWidth[i];\r
-\r
-} else {\r
-r.x = parent.width - (Clazz.doubleToInt (diffw / 2) + insets.right);\r
-for (i = 0; i < constraints.tempX; i++) r.x -= info.minWidth[i];\r
-\r
-}r.y = info.starty;\r
-for (i = 0; i < constraints.tempY; i++) r.y += info.minHeight[i];\r
-\r
-r.width = 0;\r
-for (i = constraints.tempX; i < (constraints.tempX + constraints.tempWidth); i++) {\r
-r.width += info.minWidth[i];\r
-}\r
-r.height = 0;\r
-for (i = constraints.tempY; i < (constraints.tempY + constraints.tempHeight); i++) {\r
-r.height += info.minHeight[i];\r
-}\r
-this.componentAdjusting = comp;\r
-this.adjustForGravity (constraints, r);\r
-if (r.x < 0) {\r
-r.width += r.x;\r
-r.x = 0;\r
-}if (r.y < 0) {\r
-r.height += r.y;\r
-r.y = 0;\r
-}if ((r.width <= 0) || (r.height <= 0)) {\r
-comp.setBounds (0, 0, 0, 0);\r
-} else {\r
-if (comp.x != r.x || comp.y != r.y || comp.width != r.width || comp.height != r.height) {\r
-comp.setBounds (r.x, r.y, r.width, r.height);\r
-}}}\r
-}, "java.awt.Container");\r
-Clazz.defineStatics (c$,\r
-"EMPIRICMULTIPLIER", 2,\r
-"MAXGRIDSIZE", 512,\r
-"MINSIZE", 1,\r
-"PREFERREDSIZE", 2);\r
-});\r
+Clazz.declarePackage ("java.awt");
+Clazz.load (["java.awt.LayoutManager2"], "java.awt.GridBagLayout", ["java.lang.IllegalArgumentException", "java.util.Arrays", "$.Hashtable", "java.awt.Component", "$.Dimension", "$.GridBagConstraints", "$.GridBagLayoutInfo", "$.Point", "$.Rectangle"], function () {
+c$ = Clazz.decorateAsClass (function () {
+this.comptable = null;
+this.defaultConstraints = null;
+this.layoutInfo = null;
+this.columnWidths = null;
+this.rowHeights = null;
+this.columnWeights = null;
+this.rowWeights = null;
+this.componentAdjusting = null;
+this.rightToLeft = false;
+Clazz.instantialize (this, arguments);
+}, java.awt, "GridBagLayout", null, [java.awt.LayoutManager2, java.io.Serializable]);
+Clazz.makeConstructor (c$,
+function () {
+this.comptable = new java.util.Hashtable ();
+this.defaultConstraints = new java.awt.GridBagConstraints ();
+});
+Clazz.defineMethod (c$, "setConstraints",
+function (comp, constraints) {
+this.comptable.put (comp, constraints.clone ());
+}, "java.awt.Component,java.awt.GridBagConstraints");
+Clazz.defineMethod (c$, "getConstraints",
+function (comp) {
+var constraints = this.comptable.get (comp);
+if (constraints == null) {
+this.setConstraints (comp, this.defaultConstraints);
+constraints = this.comptable.get (comp);
+}return constraints.clone ();
+}, "java.awt.Component");
+Clazz.defineMethod (c$, "lookupConstraints",
+function (comp) {
+var constraints = this.comptable.get (comp);
+if (constraints == null) {
+this.setConstraints (comp, this.defaultConstraints);
+constraints = this.comptable.get (comp);
+}return constraints;
+}, "java.awt.Component");
+Clazz.defineMethod (c$, "removeConstraints",
+ function (comp) {
+this.comptable.remove (comp);
+}, "java.awt.Component");
+Clazz.defineMethod (c$, "getLayoutOrigin",
+function () {
+var origin = new java.awt.Point (0, 0);
+if (this.layoutInfo != null) {
+origin.x = this.layoutInfo.startx;
+origin.y = this.layoutInfo.starty;
+}return origin;
+});
+Clazz.defineMethod (c$, "getLayoutDimensions",
+function () {
+if (this.layoutInfo == null) return Clazz.newIntArray (2, 0, 0);
+var dim = Clazz.newIntArray (2, 0);
+dim[0] = Clazz.newIntArray (this.layoutInfo.width, 0);
+dim[1] = Clazz.newIntArray (this.layoutInfo.height, 0);
+System.arraycopy (this.layoutInfo.minWidth, 0, dim[0], 0, this.layoutInfo.width);
+System.arraycopy (this.layoutInfo.minHeight, 0, dim[1], 0, this.layoutInfo.height);
+return dim;
+});
+Clazz.defineMethod (c$, "getLayoutWeights",
+function () {
+if (this.layoutInfo == null) return Clazz.newDoubleArray (2, 0, 0);
+var weights = Clazz.newDoubleArray (2, 0);
+weights[0] = Clazz.newDoubleArray (this.layoutInfo.width, 0);
+weights[1] = Clazz.newDoubleArray (this.layoutInfo.height, 0);
+System.arraycopy (this.layoutInfo.weightX, 0, weights[0], 0, this.layoutInfo.width);
+System.arraycopy (this.layoutInfo.weightY, 0, weights[1], 0, this.layoutInfo.height);
+return weights;
+});
+Clazz.defineMethod (c$, "location",
+function (x, y) {
+var loc = new java.awt.Point (0, 0);
+var i;
+var d;
+if (this.layoutInfo == null) return loc;
+d = this.layoutInfo.startx;
+if (!this.rightToLeft) {
+for (i = 0; i < this.layoutInfo.width; i++) {
+d += this.layoutInfo.minWidth[i];
+if (d > x) break;
+}
+} else {
+for (i = this.layoutInfo.width - 1; i >= 0; i--) {
+if (d > x) break;
+d += this.layoutInfo.minWidth[i];
+}
+i++;
+}loc.x = i;
+d = this.layoutInfo.starty;
+for (i = 0; i < this.layoutInfo.height; i++) {
+d += this.layoutInfo.minHeight[i];
+if (d > y) break;
+}
+loc.y = i;
+return loc;
+}, "~N,~N");
+Clazz.defineMethod (c$, "addLayoutComponent",
+function (name, comp) {
+}, "~S,java.awt.Component");
+Clazz.defineMethod (c$, "addLayoutComponent",
+function (comp, constraints) {
+if (Clazz.instanceOf (constraints, java.awt.GridBagConstraints)) {
+this.setConstraints (comp, constraints);
+} else if (constraints != null) {
+throw new IllegalArgumentException ("cannot add to layout: constraints must be a GridBagConstraint");
+}}, "java.awt.Component,~O");
+Clazz.overrideMethod (c$, "removeLayoutComponent",
+function (comp) {
+this.removeConstraints (comp);
+}, "java.awt.Component");
+Clazz.overrideMethod (c$, "preferredLayoutSize",
+function (parent) {
+var info = this.getLayoutInfo (parent, 2);
+return this.getMinSize (parent, info);
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "minimumLayoutSize",
+function (parent) {
+var info = this.getLayoutInfo (parent, 1);
+return this.getMinSize (parent, info);
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "maximumLayoutSize",
+function (target) {
+return new java.awt.Dimension (2147483647, 2147483647);
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "getLayoutAlignmentX",
+function (parent) {
+return 0.5;
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "getLayoutAlignmentY",
+function (parent) {
+return 0.5;
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "invalidateLayout",
+function (target) {
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "layoutContainer",
+function (parent) {
+System.out.println ("GridBagLayout laying out " + parent);
+this.arrangeGrid (parent);
+}, "java.awt.Container");
+Clazz.overrideMethod (c$, "toString",
+function () {
+return this.getClass ().getName ();
+});
+Clazz.defineMethod (c$, "getLayoutInfo",
+function (parent, sizeflag) {
+return this.GetLayoutInfo (parent, sizeflag);
+}, "java.awt.Container,~N");
+Clazz.defineMethod (c$, "preInitMaximumArraySizes",
+ function (parent) {
+var components = parent.getComponents ();
+var comp;
+var constraints;
+var curX;
+var curY;
+var curWidth;
+var curHeight;
+var preMaximumArrayXIndex = 0;
+var preMaximumArrayYIndex = 0;
+var returnArray = Clazz.newLongArray (2, 0);
+for (var compId = 0; compId < components.length; compId++) {
+comp = components[compId];
+if (!comp.isVisible ()) {
+continue;
+}constraints = this.lookupConstraints (comp);
+curX = constraints.gridx;
+curY = constraints.gridy;
+curWidth = constraints.gridwidth;
+curHeight = constraints.gridheight;
+if (curX < 0) {
+curX = ++preMaximumArrayYIndex;
+}if (curY < 0) {
+curY = ++preMaximumArrayXIndex;
+}if (curWidth <= 0) {
+curWidth = 1;
+}if (curHeight <= 0) {
+curHeight = 1;
+}preMaximumArrayXIndex = Math.max (curY + curHeight, preMaximumArrayXIndex);
+preMaximumArrayYIndex = Math.max (curX + curWidth, preMaximumArrayYIndex);
+}
+returnArray[0] = preMaximumArrayXIndex;
+returnArray[1] = preMaximumArrayYIndex;
+return returnArray;
+}, "java.awt.Container");
+Clazz.defineMethod (c$, "GetLayoutInfo",
+function (parent, sizeflag) {
+{
+var r;
+var comp;
+var constraints;
+var d;
+var components = parent.getComponents ();
+var layoutWidth;
+var layoutHeight;
+var xMaxArray;
+var yMaxArray;
+var compindex;
+var i;
+var k;
+var px;
+var py;
+var pixels_diff;
+var nextSize;
+var curX = 0;
+var curY = 0;
+var curWidth = 1;
+var curHeight = 1;
+var curRow;
+var curCol;
+var weight_diff;
+var weight;
+var maximumArrayXIndex = 0;
+var maximumArrayYIndex = 0;
+var anchor;
+layoutWidth = layoutHeight = 0;
+curRow = curCol = -1;
+var arraySizes = this.preInitMaximumArraySizes (parent);
+maximumArrayXIndex = (2 * arraySizes[0] > 2147483647) ? 2147483647 : 2 * arraySizes[0];
+maximumArrayYIndex = (2 * arraySizes[1] > 2147483647) ? 2147483647 : 2 * arraySizes[1];
+if (this.rowHeights != null) {
+maximumArrayXIndex = Math.max (maximumArrayXIndex, this.rowHeights.length);
+}if (this.columnWidths != null) {
+maximumArrayYIndex = Math.max (maximumArrayYIndex, this.columnWidths.length);
+}xMaxArray = Clazz.newIntArray (maximumArrayXIndex, 0);
+yMaxArray = Clazz.newIntArray (maximumArrayYIndex, 0);
+var hasBaseline = false;
+for (compindex = 0; compindex < components.length; compindex++) {
+comp = components[compindex];
+if (!comp.isVisible ()) continue;
+constraints = this.lookupConstraints (comp);
+curX = constraints.gridx;
+curY = constraints.gridy;
+curWidth = constraints.gridwidth;
+if (curWidth <= 0) curWidth = 1;
+curHeight = constraints.gridheight;
+if (curHeight <= 0) curHeight = 1;
+if (curX < 0 && curY < 0) {
+if (curRow >= 0) curY = curRow;
+ else if (curCol >= 0) curX = curCol;
+ else curY = 0;
+}if (curX < 0) {
+px = 0;
+for (i = curY; i < (curY + curHeight); i++) {
+px = Math.max (px, xMaxArray[i]);
+}
+curX = px - curX - 1;
+if (curX < 0) curX = 0;
+} else if (curY < 0) {
+py = 0;
+for (i = curX; i < (curX + curWidth); i++) {
+py = Math.max (py, yMaxArray[i]);
+}
+curY = py - curY - 1;
+if (curY < 0) curY = 0;
+}px = curX + curWidth;
+if (layoutWidth < px) {
+layoutWidth = px;
+}py = curY + curHeight;
+if (layoutHeight < py) {
+layoutHeight = py;
+}for (i = curX; i < (curX + curWidth); i++) {
+yMaxArray[i] = py;
+}
+for (i = curY; i < (curY + curHeight); i++) {
+xMaxArray[i] = px;
+}
+if (sizeflag == 2) d = comp.getPreferredSize ();
+ else d = comp.getMinimumSize ();
+constraints.minWidth = d.width;
+constraints.minHeight = d.height;
+if (this.calculateBaseline (comp, constraints, d)) {
+hasBaseline = true;
+}if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;
+if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;
+ else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;
+}
+if (this.columnWidths != null && layoutWidth < this.columnWidths.length) layoutWidth = this.columnWidths.length;
+if (this.rowHeights != null && layoutHeight < this.rowHeights.length) layoutHeight = this.rowHeights.length;
+r = new java.awt.GridBagLayoutInfo (layoutWidth, layoutHeight);
+curRow = curCol = -1;
+java.util.Arrays.fill (xMaxArray, 0);
+java.util.Arrays.fill (yMaxArray, 0);
+var maxAscent = null;
+var maxDescent = null;
+var baselineType = null;
+if (hasBaseline) {
+r.maxAscent = maxAscent = Clazz.newIntArray (layoutHeight, 0);
+r.maxDescent = maxDescent = Clazz.newIntArray (layoutHeight, 0);
+r.baselineType = baselineType = Clazz.newShortArray (layoutHeight, 0);
+r.$hasBaseline = true;
+}for (compindex = 0; compindex < components.length; compindex++) {
+comp = components[compindex];
+if (!comp.isVisible ()) continue;
+constraints = this.lookupConstraints (comp);
+curX = constraints.gridx;
+curY = constraints.gridy;
+curWidth = constraints.gridwidth;
+curHeight = constraints.gridheight;
+if (curX < 0 && curY < 0) {
+if (curRow >= 0) curY = curRow;
+ else if (curCol >= 0) curX = curCol;
+ else curY = 0;
+}if (curX < 0) {
+if (curHeight <= 0) {
+curHeight += r.height - curY;
+if (curHeight < 1) curHeight = 1;
+}px = 0;
+for (i = curY; i < (curY + curHeight); i++) px = Math.max (px, xMaxArray[i]);
+
+curX = px - curX - 1;
+if (curX < 0) curX = 0;
+} else if (curY < 0) {
+if (curWidth <= 0) {
+curWidth += r.width - curX;
+if (curWidth < 1) curWidth = 1;
+}py = 0;
+for (i = curX; i < (curX + curWidth); i++) {
+py = Math.max (py, yMaxArray[i]);
+}
+curY = py - curY - 1;
+if (curY < 0) curY = 0;
+}if (curWidth <= 0) {
+curWidth += r.width - curX;
+if (curWidth < 1) curWidth = 1;
+}if (curHeight <= 0) {
+curHeight += r.height - curY;
+if (curHeight < 1) curHeight = 1;
+}px = curX + curWidth;
+py = curY + curHeight;
+for (i = curX; i < (curX + curWidth); i++) {
+yMaxArray[i] = py;
+}
+for (i = curY; i < (curY + curHeight); i++) {
+xMaxArray[i] = px;
+}
+if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;
+if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;
+ else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;
+constraints.tempX = curX;
+constraints.tempY = curY;
+constraints.tempWidth = curWidth;
+constraints.tempHeight = curHeight;
+anchor = constraints.anchor;
+if (hasBaseline) {
+switch (anchor) {
+case 256:
+case 512:
+case 768:
+if (constraints.ascent >= 0) {
+if (curHeight == 1) {
+maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);
+maxDescent[curY] = Math.max (maxDescent[curY], constraints.descent);
+} else {
+if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {
+maxDescent[curY + curHeight - 1] = Math.max (maxDescent[curY + curHeight - 1], constraints.descent);
+} else {
+maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);
+}}if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {
+baselineType[curY + curHeight - 1] |= (1 << constraints.baselineResizeBehavior.ordinal ());
+} else {
+baselineType[curY] |= (1 << constraints.baselineResizeBehavior.ordinal ());
+}}break;
+case 1024:
+case 1280:
+case 1536:
+pixels_diff = constraints.minHeight + constraints.insets.top + constraints.ipady;
+maxAscent[curY] = Math.max (maxAscent[curY], pixels_diff);
+maxDescent[curY] = Math.max (maxDescent[curY], constraints.insets.bottom);
+break;
+case 1792:
+case 2048:
+case 2304:
+pixels_diff = constraints.minHeight + constraints.insets.bottom + constraints.ipady;
+maxDescent[curY] = Math.max (maxDescent[curY], pixels_diff);
+maxAscent[curY] = Math.max (maxAscent[curY], constraints.insets.top);
+break;
+}
+}}
+r.weightX = Clazz.newDoubleArray (maximumArrayYIndex, 0);
+r.weightY = Clazz.newDoubleArray (maximumArrayXIndex, 0);
+r.minWidth = Clazz.newIntArray (maximumArrayYIndex, 0);
+r.minHeight = Clazz.newIntArray (maximumArrayXIndex, 0);
+if (this.columnWidths != null) System.arraycopy (this.columnWidths, 0, r.minWidth, 0, this.columnWidths.length);
+if (this.rowHeights != null) System.arraycopy (this.rowHeights, 0, r.minHeight, 0, this.rowHeights.length);
+if (this.columnWeights != null) System.arraycopy (this.columnWeights, 0, r.weightX, 0, Math.min (r.weightX.length, this.columnWeights.length));
+if (this.rowWeights != null) System.arraycopy (this.rowWeights, 0, r.weightY, 0, Math.min (r.weightY.length, this.rowWeights.length));
+nextSize = 2147483647;
+for (i = 1; i != 2147483647; i = nextSize, nextSize = 2147483647) {
+for (compindex = 0; compindex < components.length; compindex++) {
+comp = components[compindex];
+if (!comp.isVisible ()) continue;
+constraints = this.lookupConstraints (comp);
+if (constraints.tempWidth == i) {
+px = constraints.tempX + constraints.tempWidth;
+weight_diff = constraints.weightx;
+for (k = constraints.tempX; k < px; k++) weight_diff -= r.weightX[k];
+
+if (weight_diff > 0.0) {
+weight = 0.0;
+for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];
+
+for (k = constraints.tempX; weight > 0.0 && k < px; k++) {
+var wt = r.weightX[k];
+var dx = (wt * weight_diff) / weight;
+r.weightX[k] += dx;
+weight_diff -= dx;
+weight -= wt;
+}
+r.weightX[px - 1] += weight_diff;
+}pixels_diff = constraints.minWidth + constraints.ipadx + constraints.insets.left + constraints.insets.right;
+for (k = constraints.tempX; k < px; k++) pixels_diff -= r.minWidth[k];
+
+if (pixels_diff > 0) {
+weight = 0.0;
+for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];
+
+for (k = constraints.tempX; weight > 0.0 && k < px; k++) {
+var wt = r.weightX[k];
+var dx = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);
+r.minWidth[k] += dx;
+pixels_diff -= dx;
+weight -= wt;
+}
+r.minWidth[px - 1] += pixels_diff;
+}} else if (constraints.tempWidth > i && constraints.tempWidth < nextSize) nextSize = constraints.tempWidth;
+if (constraints.tempHeight == i) {
+py = constraints.tempY + constraints.tempHeight;
+weight_diff = constraints.weighty;
+for (k = constraints.tempY; k < py; k++) weight_diff -= r.weightY[k];
+
+if (weight_diff > 0.0) {
+weight = 0.0;
+for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];
+
+for (k = constraints.tempY; weight > 0.0 && k < py; k++) {
+var wt = r.weightY[k];
+var dy = (wt * weight_diff) / weight;
+r.weightY[k] += dy;
+weight_diff -= dy;
+weight -= wt;
+}
+r.weightY[py - 1] += weight_diff;
+}pixels_diff = -1;
+if (hasBaseline) {
+switch (constraints.anchor) {
+case 256:
+case 512:
+case 768:
+if (constraints.ascent >= 0) {
+if (constraints.tempHeight == 1) {
+pixels_diff = maxAscent[constraints.tempY] + maxDescent[constraints.tempY];
+} else if (constraints.baselineResizeBehavior !== java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {
+pixels_diff = maxAscent[constraints.tempY] + constraints.descent;
+} else {
+pixels_diff = constraints.ascent + maxDescent[constraints.tempY + constraints.tempHeight - 1];
+}}break;
+case 1024:
+case 1280:
+case 1536:
+pixels_diff = constraints.insets.top + constraints.minHeight + constraints.ipady + maxDescent[constraints.tempY];
+break;
+case 1792:
+case 2048:
+case 2304:
+pixels_diff = maxAscent[constraints.tempY] + constraints.minHeight + constraints.insets.bottom + constraints.ipady;
+break;
+}
+}if (pixels_diff == -1) {
+pixels_diff = constraints.minHeight + constraints.ipady + constraints.insets.top + constraints.insets.bottom;
+}for (k = constraints.tempY; k < py; k++) pixels_diff -= r.minHeight[k];
+
+if (pixels_diff > 0) {
+weight = 0.0;
+for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];
+
+for (k = constraints.tempY; weight > 0.0 && k < py; k++) {
+var wt = r.weightY[k];
+var dy = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);
+r.minHeight[k] += dy;
+pixels_diff -= dy;
+weight -= wt;
+}
+r.minHeight[py - 1] += pixels_diff;
+}} else if (constraints.tempHeight > i && constraints.tempHeight < nextSize) nextSize = constraints.tempHeight;
+}
+}
+return r;
+}}, "java.awt.Container,~N");
+Clazz.defineMethod (c$, "calculateBaseline",
+ function (c, constraints, size) {
+var anchor = constraints.anchor;
+if (anchor == 256 || anchor == 512 || anchor == 768) {
+var w = size.width + constraints.ipadx;
+var h = size.height + constraints.ipady;
+constraints.ascent = c.getBaseline (w, h);
+if (constraints.ascent >= 0) {
+var baseline = constraints.ascent;
+constraints.descent = h - constraints.ascent + constraints.insets.bottom;
+constraints.ascent += constraints.insets.top;
+constraints.baselineResizeBehavior = c.getBaselineResizeBehavior ();
+constraints.centerPadding = 0;
+if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET) {
+var nextBaseline = c.getBaseline (w, h + 1);
+constraints.centerOffset = baseline - Clazz.doubleToInt (h / 2);
+if (h % 2 == 0) {
+if (baseline != nextBaseline) {
+constraints.centerPadding = 1;
+}} else if (baseline == nextBaseline) {
+constraints.centerOffset--;
+constraints.centerPadding = 1;
+}}}return true;
+} else {
+constraints.ascent = -1;
+return false;
+}}, "java.awt.Component,java.awt.GridBagConstraints,java.awt.Dimension");
+Clazz.defineMethod (c$, "adjustForGravity",
+function (constraints, r) {
+this.AdjustForGravity (constraints, r);
+}, "java.awt.GridBagConstraints,java.awt.Rectangle");
+Clazz.defineMethod (c$, "AdjustForGravity",
+function (constraints, r) {
+var diffx;
+var diffy;
+var cellY = r.y;
+var cellHeight = r.height;
+if (!this.rightToLeft) {
+r.x += constraints.insets.left;
+} else {
+r.x -= r.width - constraints.insets.right;
+}r.width -= (constraints.insets.left + constraints.insets.right);
+r.y += constraints.insets.top;
+r.height -= (constraints.insets.top + constraints.insets.bottom);
+diffx = 0;
+if ((constraints.fill != 2 && constraints.fill != 1) && (r.width > (constraints.minWidth + constraints.ipadx))) {
+diffx = r.width - (constraints.minWidth + constraints.ipadx);
+r.width = constraints.minWidth + constraints.ipadx;
+}diffy = 0;
+if ((constraints.fill != 3 && constraints.fill != 1) && (r.height > (constraints.minHeight + constraints.ipady))) {
+diffy = r.height - (constraints.minHeight + constraints.ipady);
+r.height = constraints.minHeight + constraints.ipady;
+}switch (constraints.anchor) {
+case 256:
+r.x += Clazz.doubleToInt (diffx / 2);
+this.alignOnBaseline (constraints, r, cellY, cellHeight);
+break;
+case 512:
+if (this.rightToLeft) {
+r.x += diffx;
+}this.alignOnBaseline (constraints, r, cellY, cellHeight);
+break;
+case 768:
+if (!this.rightToLeft) {
+r.x += diffx;
+}this.alignOnBaseline (constraints, r, cellY, cellHeight);
+break;
+case 1024:
+r.x += Clazz.doubleToInt (diffx / 2);
+this.alignAboveBaseline (constraints, r, cellY, cellHeight);
+break;
+case 1280:
+if (this.rightToLeft) {
+r.x += diffx;
+}this.alignAboveBaseline (constraints, r, cellY, cellHeight);
+break;
+case 1536:
+if (!this.rightToLeft) {
+r.x += diffx;
+}this.alignAboveBaseline (constraints, r, cellY, cellHeight);
+break;
+case 1792:
+r.x += Clazz.doubleToInt (diffx / 2);
+this.alignBelowBaseline (constraints, r, cellY, cellHeight);
+break;
+case 2048:
+if (this.rightToLeft) {
+r.x += diffx;
+}this.alignBelowBaseline (constraints, r, cellY, cellHeight);
+break;
+case 2304:
+if (!this.rightToLeft) {
+r.x += diffx;
+}this.alignBelowBaseline (constraints, r, cellY, cellHeight);
+break;
+case 10:
+r.x += Clazz.doubleToInt (diffx / 2);
+r.y += Clazz.doubleToInt (diffy / 2);
+break;
+case 19:
+case 11:
+r.x += Clazz.doubleToInt (diffx / 2);
+break;
+case 12:
+r.x += diffx;
+break;
+case 13:
+r.x += diffx;
+r.y += Clazz.doubleToInt (diffy / 2);
+break;
+case 14:
+r.x += diffx;
+r.y += diffy;
+break;
+case 20:
+case 15:
+r.x += Clazz.doubleToInt (diffx / 2);
+r.y += diffy;
+break;
+case 16:
+r.y += diffy;
+break;
+case 17:
+r.y += Clazz.doubleToInt (diffy / 2);
+break;
+case 18:
+break;
+case 21:
+if (this.rightToLeft) {
+r.x += diffx;
+}r.y += Clazz.doubleToInt (diffy / 2);
+break;
+case 22:
+if (!this.rightToLeft) {
+r.x += diffx;
+}r.y += Clazz.doubleToInt (diffy / 2);
+break;
+case 23:
+if (this.rightToLeft) {
+r.x += diffx;
+}break;
+case 24:
+if (!this.rightToLeft) {
+r.x += diffx;
+}break;
+case 25:
+if (this.rightToLeft) {
+r.x += diffx;
+}r.y += diffy;
+break;
+case 26:
+if (!this.rightToLeft) {
+r.x += diffx;
+}r.y += diffy;
+break;
+default:
+throw new IllegalArgumentException ("illegal anchor value");
+}
+}, "java.awt.GridBagConstraints,java.awt.Rectangle");
+Clazz.defineMethod (c$, "alignOnBaseline",
+ function (cons, r, cellY, cellHeight) {
+if (cons.ascent >= 0) {
+if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {
+var maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY + cons.tempHeight - 1] + cons.descent - cons.insets.bottom;
+if (!cons.isVerticallyResizable ()) {
+r.y = maxY - cons.minHeight;
+r.height = cons.minHeight;
+} else {
+r.height = maxY - cellY - cons.insets.top;
+}} else {
+var baseline;
+var ascent = cons.ascent;
+if (this.layoutInfo.hasConstantDescent (cons.tempY)) {
+baseline = cellHeight - this.layoutInfo.maxDescent[cons.tempY];
+} else {
+baseline = this.layoutInfo.maxAscent[cons.tempY];
+}if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.OTHER) {
+var fits = false;
+ascent = this.componentAdjusting.getBaseline (r.width, r.height);
+if (ascent >= 0) {
+ascent += cons.insets.top;
+}if (ascent >= 0 && ascent <= baseline) {
+if (baseline + (r.height - ascent - cons.insets.top) <= cellHeight - cons.insets.bottom) {
+fits = true;
+} else if (cons.isVerticallyResizable ()) {
+var ascent2 = this.componentAdjusting.getBaseline (r.width, cellHeight - cons.insets.bottom - baseline + ascent);
+if (ascent2 >= 0) {
+ascent2 += cons.insets.top;
+}if (ascent2 >= 0 && ascent2 <= ascent) {
+r.height = cellHeight - cons.insets.bottom - baseline + ascent;
+ascent = ascent2;
+fits = true;
+}}}if (!fits) {
+ascent = cons.ascent;
+r.width = cons.minWidth;
+r.height = cons.minHeight;
+}}r.y = cellY + baseline - ascent + cons.insets.top;
+if (cons.isVerticallyResizable ()) {
+switch (cons.baselineResizeBehavior) {
+case java.awt.Component.BaselineResizeBehavior.CONSTANT_ASCENT:
+r.height = Math.max (cons.minHeight, cellY + cellHeight - r.y - cons.insets.bottom);
+break;
+case java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET:
+{
+var upper = r.y - cellY - cons.insets.top;
+var lower = cellY + cellHeight - r.y - cons.minHeight - cons.insets.bottom;
+var delta = Math.min (upper, lower);
+delta += delta;
+if (delta > 0 && Clazz.doubleToInt ((cons.minHeight + cons.centerPadding + delta) / 2) + cons.centerOffset != baseline) {
+delta--;
+}r.height = cons.minHeight + delta;
+r.y = cellY + baseline - Clazz.doubleToInt ((r.height + cons.centerPadding) / 2) - cons.centerOffset;
+}break;
+case java.awt.Component.BaselineResizeBehavior.OTHER:
+break;
+default:
+break;
+}
+}}} else {
+this.centerVertically (cons, r, cellHeight);
+}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");
+Clazz.defineMethod (c$, "alignAboveBaseline",
+ function (cons, r, cellY, cellHeight) {
+if (this.layoutInfo.hasBaseline (cons.tempY)) {
+var maxY;
+if (this.layoutInfo.hasConstantDescent (cons.tempY)) {
+maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];
+} else {
+maxY = cellY + this.layoutInfo.maxAscent[cons.tempY];
+}if (cons.isVerticallyResizable ()) {
+r.y = cellY + cons.insets.top;
+r.height = maxY - r.y;
+} else {
+r.height = cons.minHeight + cons.ipady;
+r.y = maxY - r.height;
+}} else {
+this.centerVertically (cons, r, cellHeight);
+}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");
+Clazz.defineMethod (c$, "alignBelowBaseline",
+ function (cons, r, cellY, cellHeight) {
+if (this.layoutInfo.hasBaseline (cons.tempY)) {
+if (this.layoutInfo.hasConstantDescent (cons.tempY)) {
+r.y = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];
+} else {
+r.y = cellY + this.layoutInfo.maxAscent[cons.tempY];
+}if (cons.isVerticallyResizable ()) {
+r.height = cellY + cellHeight - r.y - cons.insets.bottom;
+}} else {
+this.centerVertically (cons, r, cellHeight);
+}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");
+Clazz.defineMethod (c$, "centerVertically",
+ function (cons, r, cellHeight) {
+if (!cons.isVerticallyResizable ()) {
+r.y += Math.max (0, Clazz.doubleToInt ((cellHeight - cons.insets.top - cons.insets.bottom - cons.minHeight - cons.ipady) / 2));
+}}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N");
+Clazz.defineMethod (c$, "getMinSize",
+function (parent, info) {
+return this.GetMinSize (parent, info);
+}, "java.awt.Container,java.awt.GridBagLayoutInfo");
+Clazz.defineMethod (c$, "GetMinSize",
+function (parent, info) {
+var d = new java.awt.Dimension ();
+var i;
+var t;
+var insets = parent.getInsets ();
+t = 0;
+for (i = 0; i < info.width; i++) t += info.minWidth[i];
+
+d.width = t + insets.left + insets.right;
+t = 0;
+for (i = 0; i < info.height; i++) t += info.minHeight[i];
+
+d.height = t + insets.top + insets.bottom;
+return d;
+}, "java.awt.Container,java.awt.GridBagLayoutInfo");
+Clazz.defineMethod (c$, "arrangeGrid",
+function (parent) {
+this.ArrangeGrid (parent);
+}, "java.awt.Container");
+Clazz.defineMethod (c$, "ArrangeGrid",
+function (parent) {
+var comp;
+var compindex;
+var constraints;
+var insets = parent.getInsets ();
+var components = parent.getComponents ();
+var d;
+var r = new java.awt.Rectangle ();
+var i;
+var diffw;
+var diffh;
+var weight;
+var info;
+this.rightToLeft = !parent.getComponentOrientation ().isLeftToRight ();
+if (components.length == 0 && (this.columnWidths == null || this.columnWidths.length == 0) && (this.rowHeights == null || this.rowHeights.length == 0)) {
+return;
+}info = this.getLayoutInfo (parent, 2);
+d = this.getMinSize (parent, info);
+if (parent.width < d.width || parent.height < d.height) {
+info = this.getLayoutInfo (parent, 1);
+d = this.getMinSize (parent, info);
+}this.layoutInfo = info;
+r.width = d.width;
+r.height = d.height;
+diffw = parent.width - r.width;
+if (diffw != 0) {
+weight = 0.0;
+for (i = 0; i < info.width; i++) weight += info.weightX[i];
+
+if (weight > 0.0) {
+for (i = 0; i < info.width; i++) {
+var dx = Clazz.doubleToInt (((diffw) * info.weightX[i]) / weight);
+info.minWidth[i] += dx;
+r.width += dx;
+if (info.minWidth[i] < 0) {
+r.width -= info.minWidth[i];
+info.minWidth[i] = 0;
+}}
+}diffw = parent.width - r.width;
+} else {
+diffw = 0;
+}diffh = parent.height - r.height;
+if (diffh != 0) {
+weight = 0.0;
+for (i = 0; i < info.height; i++) weight += info.weightY[i];
+
+if (weight > 0.0) {
+for (i = 0; i < info.height; i++) {
+var dy = Clazz.doubleToInt (((diffh) * info.weightY[i]) / weight);
+info.minHeight[i] += dy;
+r.height += dy;
+if (info.minHeight[i] < 0) {
+r.height -= info.minHeight[i];
+info.minHeight[i] = 0;
+}}
+}diffh = parent.height - r.height;
+} else {
+diffh = 0;
+}info.startx = Clazz.doubleToInt (diffw / 2) + insets.left;
+info.starty = Clazz.doubleToInt (diffh / 2) + insets.top;
+for (compindex = 0; compindex < components.length; compindex++) {
+comp = components[compindex];
+if (!comp.isVisible ()) {
+continue;
+}constraints = this.lookupConstraints (comp);
+if (!this.rightToLeft) {
+r.x = info.startx;
+for (i = 0; i < constraints.tempX; i++) r.x += info.minWidth[i];
+
+} else {
+r.x = parent.width - (Clazz.doubleToInt (diffw / 2) + insets.right);
+for (i = 0; i < constraints.tempX; i++) r.x -= info.minWidth[i];
+
+}r.y = info.starty;
+for (i = 0; i < constraints.tempY; i++) r.y += info.minHeight[i];
+
+r.width = 0;
+for (i = constraints.tempX; i < (constraints.tempX + constraints.tempWidth); i++) {
+r.width += info.minWidth[i];
+}
+r.height = 0;
+for (i = constraints.tempY; i < (constraints.tempY + constraints.tempHeight); i++) {
+r.height += info.minHeight[i];
+}
+this.componentAdjusting = comp;
+this.adjustForGravity (constraints, r);
+if (r.x < 0) {
+r.width += r.x;
+r.x = 0;
+}if (r.y < 0) {
+r.height += r.y;
+r.y = 0;
+}if ((r.width <= 0) || (r.height <= 0)) {
+comp.setBounds (0, 0, 0, 0);
+} else {
+if (comp.x != r.x || comp.y != r.y || comp.width != r.width || comp.height != r.height) {
+comp.setBounds (r.x, r.y, r.width, r.height);
+}}}
+}, "java.awt.Container");
+Clazz.defineStatics (c$,
+"EMPIRICMULTIPLIER", 2,
+"MAXGRIDSIZE", 512,
+"MINSIZE", 1,
+"PREFERREDSIZE", 2);
+});
git://source.jalview.org / jalviewjs.git / blobdiff