site/j2s/java/awt/GridBagLayout.js

   1 Clazz.declarePackage ("java.awt");\r
   2 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
   3 c$ = Clazz.decorateAsClass (function () {\r
   4 this.comptable = null;\r
   5 this.defaultConstraints = null;\r
   6 this.layoutInfo = null;\r
   7 this.columnWidths = null;\r
   8 this.rowHeights = null;\r
   9 this.columnWeights = null;\r
  10 this.rowWeights = null;\r
  11 this.componentAdjusting = null;\r
  12 this.rightToLeft = false;\r
  13 Clazz.instantialize (this, arguments);\r
  14 }, java.awt, "GridBagLayout", null, [java.awt.LayoutManager2, java.io.Serializable]);\r
  15 Clazz.makeConstructor (c$, \r
  16 function () {\r
  17 this.comptable =  new java.util.Hashtable ();\r
  18 this.defaultConstraints =  new java.awt.GridBagConstraints ();\r
  19 });\r
  20 Clazz.defineMethod (c$, "setConstraints", \r
  21 function (comp, constraints) {\r
  22 this.comptable.put (comp, constraints.clone ());\r
  23 }, "java.awt.Component,java.awt.GridBagConstraints");\r
  24 Clazz.defineMethod (c$, "getConstraints", \r
  25 function (comp) {\r
  26 var constraints = this.comptable.get (comp);\r
  27 if (constraints == null) {\r
  28 this.setConstraints (comp, this.defaultConstraints);\r
  29 constraints = this.comptable.get (comp);\r
  30 }return constraints.clone ();\r
  31 }, "java.awt.Component");\r
  32 Clazz.defineMethod (c$, "lookupConstraints", \r
  33 function (comp) {\r
  34 var constraints = this.comptable.get (comp);\r
  35 if (constraints == null) {\r
  36 this.setConstraints (comp, this.defaultConstraints);\r
  37 constraints = this.comptable.get (comp);\r
  38 }return constraints;\r
  39 }, "java.awt.Component");\r
  40 Clazz.defineMethod (c$, "removeConstraints", \r
  41  function (comp) {\r
  42 this.comptable.remove (comp);\r
  43 }, "java.awt.Component");\r
  44 Clazz.defineMethod (c$, "getLayoutOrigin", \r
  45 function () {\r
  46 var origin =  new java.awt.Point (0, 0);\r
  47 if (this.layoutInfo != null) {\r
  48 origin.x = this.layoutInfo.startx;\r
  49 origin.y = this.layoutInfo.starty;\r
  50 }return origin;\r
  51 });\r
  52 Clazz.defineMethod (c$, "getLayoutDimensions", \r
  53 function () {\r
  54 if (this.layoutInfo == null) return  Clazz.newIntArray (2, 0, 0);\r
  55 var dim =  Clazz.newIntArray (2, 0);\r
  56 dim[0] =  Clazz.newIntArray (this.layoutInfo.width, 0);\r
  57 dim[1] =  Clazz.newIntArray (this.layoutInfo.height, 0);\r
  58 System.arraycopy (this.layoutInfo.minWidth, 0, dim[0], 0, this.layoutInfo.width);\r
  59 System.arraycopy (this.layoutInfo.minHeight, 0, dim[1], 0, this.layoutInfo.height);\r
  60 return dim;\r
  61 });\r
  62 Clazz.defineMethod (c$, "getLayoutWeights", \r
  63 function () {\r
  64 if (this.layoutInfo == null) return  Clazz.newDoubleArray (2, 0, 0);\r
  65 var weights =  Clazz.newDoubleArray (2, 0);\r
  66 weights[0] =  Clazz.newDoubleArray (this.layoutInfo.width, 0);\r
  67 weights[1] =  Clazz.newDoubleArray (this.layoutInfo.height, 0);\r
  68 System.arraycopy (this.layoutInfo.weightX, 0, weights[0], 0, this.layoutInfo.width);\r
  69 System.arraycopy (this.layoutInfo.weightY, 0, weights[1], 0, this.layoutInfo.height);\r
  70 return weights;\r
  71 });\r
  72 Clazz.defineMethod (c$, "location", \r
  73 function (x, y) {\r
  74 var loc =  new java.awt.Point (0, 0);\r
  75 var i;\r
  76 var d;\r
  77 if (this.layoutInfo == null) return loc;\r
  78 d = this.layoutInfo.startx;\r
  79 if (!this.rightToLeft) {\r
  80 for (i = 0; i < this.layoutInfo.width; i++) {\r
  81 d += this.layoutInfo.minWidth[i];\r
  82 if (d > x) break;\r
  83 }\r
  84 } else {\r
  85 for (i = this.layoutInfo.width - 1; i >= 0; i--) {\r
  86 if (d > x) break;\r
  87 d += this.layoutInfo.minWidth[i];\r
  88 }\r
  89 i++;\r
  90 }loc.x = i;\r
  91 d = this.layoutInfo.starty;\r
  92 for (i = 0; i < this.layoutInfo.height; i++) {\r
  93 d += this.layoutInfo.minHeight[i];\r
  94 if (d > y) break;\r
  95 }\r
  96 loc.y = i;\r
  97 return loc;\r
  98 }, "~N,~N");\r
  99 Clazz.defineMethod (c$, "addLayoutComponent", \r
 100 function (name, comp) {\r
 101 }, "~S,java.awt.Component");\r
 102 Clazz.defineMethod (c$, "addLayoutComponent", \r
 103 function (comp, constraints) {\r
 104 if (Clazz.instanceOf (constraints, java.awt.GridBagConstraints)) {\r
 105 this.setConstraints (comp, constraints);\r
 106 } else if (constraints != null) {\r
 107 throw  new IllegalArgumentException ("cannot add to layout: constraints must be a GridBagConstraint");\r
 108 }}, "java.awt.Component,~O");\r
 109 Clazz.overrideMethod (c$, "removeLayoutComponent", \r
 110 function (comp) {\r
 111 this.removeConstraints (comp);\r
 112 }, "java.awt.Component");\r
 113 Clazz.overrideMethod (c$, "preferredLayoutSize", \r
 114 function (parent) {\r
 115 var info = this.getLayoutInfo (parent, 2);\r
 116 return this.getMinSize (parent, info);\r
 117 }, "java.awt.Container");\r
 118 Clazz.overrideMethod (c$, "minimumLayoutSize", \r
 119 function (parent) {\r
 120 var info = this.getLayoutInfo (parent, 1);\r
 121 return this.getMinSize (parent, info);\r
 122 }, "java.awt.Container");\r
 123 Clazz.overrideMethod (c$, "maximumLayoutSize", \r
 124 function (target) {\r
 125 return  new java.awt.Dimension (2147483647, 2147483647);\r
 126 }, "java.awt.Container");\r
 127 Clazz.overrideMethod (c$, "getLayoutAlignmentX", \r
 128 function (parent) {\r
 129 return 0.5;\r
 130 }, "java.awt.Container");\r
 131 Clazz.overrideMethod (c$, "getLayoutAlignmentY", \r
 132 function (parent) {\r
 133 return 0.5;\r
 134 }, "java.awt.Container");\r
 135 Clazz.overrideMethod (c$, "invalidateLayout", \r
 136 function (target) {\r
 137 }, "java.awt.Container");\r
 138 Clazz.overrideMethod (c$, "layoutContainer", \r
 139 function (parent) {\r
 140 System.out.println ("GridBagLayout laying out " + parent);\r
 141 this.arrangeGrid (parent);\r
 142 }, "java.awt.Container");\r
 143 Clazz.overrideMethod (c$, "toString", \r
 144 function () {\r
 145 return this.getClass ().getName ();\r
 146 });\r
 147 Clazz.defineMethod (c$, "getLayoutInfo", \r
 148 function (parent, sizeflag) {\r
 149 return this.GetLayoutInfo (parent, sizeflag);\r
 150 }, "java.awt.Container,~N");\r
 151 Clazz.defineMethod (c$, "preInitMaximumArraySizes", \r
 152  function (parent) {\r
 153 var components = parent.getComponents ();\r
 154 var comp;\r
 155 var constraints;\r
 156 var curX;\r
 157 var curY;\r
 158 var curWidth;\r
 159 var curHeight;\r
 160 var preMaximumArrayXIndex = 0;\r
 161 var preMaximumArrayYIndex = 0;\r
 162 var returnArray =  Clazz.newLongArray (2, 0);\r
 163 for (var compId = 0; compId < components.length; compId++) {\r
 164 comp = components[compId];\r
 165 if (!comp.isVisible ()) {\r
 166 continue;\r
 167 }constraints = this.lookupConstraints (comp);\r
 168 curX = constraints.gridx;\r
 169 curY = constraints.gridy;\r
 170 curWidth = constraints.gridwidth;\r
 171 curHeight = constraints.gridheight;\r
 172 if (curX < 0) {\r
 173 curX = ++preMaximumArrayYIndex;\r
 174 }if (curY < 0) {\r
 175 curY = ++preMaximumArrayXIndex;\r
 176 }if (curWidth <= 0) {\r
 177 curWidth = 1;\r
 178 }if (curHeight <= 0) {\r
 179 curHeight = 1;\r
 180 }preMaximumArrayXIndex = Math.max (curY + curHeight, preMaximumArrayXIndex);\r
 181 preMaximumArrayYIndex = Math.max (curX + curWidth, preMaximumArrayYIndex);\r
 182 }\r
 183 returnArray[0] = preMaximumArrayXIndex;\r
 184 returnArray[1] = preMaximumArrayYIndex;\r
 185 return returnArray;\r
 186 }, "java.awt.Container");\r
 187 Clazz.defineMethod (c$, "GetLayoutInfo", \r
 188 function (parent, sizeflag) {\r
 189 {\r
 190 var r;\r
 191 var comp;\r
 192 var constraints;\r
 193 var d;\r
 194 var components = parent.getComponents ();\r
 195 var layoutWidth;\r
 196 var layoutHeight;\r
 197 var xMaxArray;\r
 198 var yMaxArray;\r
 199 var compindex;\r
 200 var i;\r
 201 var k;\r
 202 var px;\r
 203 var py;\r
 204 var pixels_diff;\r
 205 var nextSize;\r
 206 var curX = 0;\r
 207 var curY = 0;\r
 208 var curWidth = 1;\r
 209 var curHeight = 1;\r
 210 var curRow;\r
 211 var curCol;\r
 212 var weight_diff;\r
 213 var weight;\r
 214 var maximumArrayXIndex = 0;\r
 215 var maximumArrayYIndex = 0;\r
 216 var anchor;\r
 217 layoutWidth = layoutHeight = 0;\r
 218 curRow = curCol = -1;\r
 219 var arraySizes = this.preInitMaximumArraySizes (parent);\r
 220 maximumArrayXIndex = (2 * arraySizes[0] > 2147483647) ? 2147483647 : 2 * arraySizes[0];\r
 221 maximumArrayYIndex = (2 * arraySizes[1] > 2147483647) ? 2147483647 : 2 * arraySizes[1];\r
 222 if (this.rowHeights != null) {\r
 223 maximumArrayXIndex = Math.max (maximumArrayXIndex, this.rowHeights.length);\r
 224 }if (this.columnWidths != null) {\r
 225 maximumArrayYIndex = Math.max (maximumArrayYIndex, this.columnWidths.length);\r
 226 }xMaxArray =  Clazz.newIntArray (maximumArrayXIndex, 0);\r
 227 yMaxArray =  Clazz.newIntArray (maximumArrayYIndex, 0);\r
 228 var hasBaseline = false;\r
 229 for (compindex = 0; compindex < components.length; compindex++) {\r
 230 comp = components[compindex];\r
 231 if (!comp.isVisible ()) continue;\r
 232 constraints = this.lookupConstraints (comp);\r
 233 curX = constraints.gridx;\r
 234 curY = constraints.gridy;\r
 235 curWidth = constraints.gridwidth;\r
 236 if (curWidth <= 0) curWidth = 1;\r
 237 curHeight = constraints.gridheight;\r
 238 if (curHeight <= 0) curHeight = 1;\r
 239 if (curX < 0 && curY < 0) {\r
 240 if (curRow >= 0) curY = curRow;\r
 241  else if (curCol >= 0) curX = curCol;\r
 242  else curY = 0;\r
 243 }if (curX < 0) {\r
 244 px = 0;\r
 245 for (i = curY; i < (curY + curHeight); i++) {\r
 246 px = Math.max (px, xMaxArray[i]);\r
 247 }\r
 248 curX = px - curX - 1;\r
 249 if (curX < 0) curX = 0;\r
 250 } else if (curY < 0) {\r
 251 py = 0;\r
 252 for (i = curX; i < (curX + curWidth); i++) {\r
 253 py = Math.max (py, yMaxArray[i]);\r
 254 }\r
 255 curY = py - curY - 1;\r
 256 if (curY < 0) curY = 0;\r
 257 }px = curX + curWidth;\r
 258 if (layoutWidth < px) {\r
 259 layoutWidth = px;\r
 260 }py = curY + curHeight;\r
 261 if (layoutHeight < py) {\r
 262 layoutHeight = py;\r
 263 }for (i = curX; i < (curX + curWidth); i++) {\r
 264 yMaxArray[i] = py;\r
 265 }\r
 266 for (i = curY; i < (curY + curHeight); i++) {\r
 267 xMaxArray[i] = px;\r
 268 }\r
 269 if (sizeflag == 2) d = comp.getPreferredSize ();\r
 270  else d = comp.getMinimumSize ();\r
 271 constraints.minWidth = d.width;\r
 272 constraints.minHeight = d.height;\r
 273 if (this.calculateBaseline (comp, constraints, d)) {\r
 274 hasBaseline = true;\r
 275 }if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;\r
 276 if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;\r
 277  else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;\r
 278 }\r
 279 if (this.columnWidths != null && layoutWidth < this.columnWidths.length) layoutWidth = this.columnWidths.length;\r
 280 if (this.rowHeights != null && layoutHeight < this.rowHeights.length) layoutHeight = this.rowHeights.length;\r
 281 r =  new java.awt.GridBagLayoutInfo (layoutWidth, layoutHeight);\r
 282 curRow = curCol = -1;\r
 283 java.util.Arrays.fill (xMaxArray, 0);\r
 284 java.util.Arrays.fill (yMaxArray, 0);\r
 285 var maxAscent = null;\r
 286 var maxDescent = null;\r
 287 var baselineType = null;\r
 288 if (hasBaseline) {\r
 289 r.maxAscent = maxAscent =  Clazz.newIntArray (layoutHeight, 0);\r
 290 r.maxDescent = maxDescent =  Clazz.newIntArray (layoutHeight, 0);\r
 291 r.baselineType = baselineType =  Clazz.newShortArray (layoutHeight, 0);\r
 292 r.$hasBaseline = true;\r
 293 }for (compindex = 0; compindex < components.length; compindex++) {\r
 294 comp = components[compindex];\r
 295 if (!comp.isVisible ()) continue;\r
 296 constraints = this.lookupConstraints (comp);\r
 297 curX = constraints.gridx;\r
 298 curY = constraints.gridy;\r
 299 curWidth = constraints.gridwidth;\r
 300 curHeight = constraints.gridheight;\r
 301 if (curX < 0 && curY < 0) {\r
 302 if (curRow >= 0) curY = curRow;\r
 303  else if (curCol >= 0) curX = curCol;\r
 304  else curY = 0;\r
 305 }if (curX < 0) {\r
 306 if (curHeight <= 0) {\r
 307 curHeight += r.height - curY;\r
 308 if (curHeight < 1) curHeight = 1;\r
 309 }px = 0;\r
 310 for (i = curY; i < (curY + curHeight); i++) px = Math.max (px, xMaxArray[i]);\r
 311 \r
 312 curX = px - curX - 1;\r
 313 if (curX < 0) curX = 0;\r
 314 } else if (curY < 0) {\r
 315 if (curWidth <= 0) {\r
 316 curWidth += r.width - curX;\r
 317 if (curWidth < 1) curWidth = 1;\r
 318 }py = 0;\r
 319 for (i = curX; i < (curX + curWidth); i++) {\r
 320 py = Math.max (py, yMaxArray[i]);\r
 321 }\r
 322 curY = py - curY - 1;\r
 323 if (curY < 0) curY = 0;\r
 324 }if (curWidth <= 0) {\r
 325 curWidth += r.width - curX;\r
 326 if (curWidth < 1) curWidth = 1;\r
 327 }if (curHeight <= 0) {\r
 328 curHeight += r.height - curY;\r
 329 if (curHeight < 1) curHeight = 1;\r
 330 }px = curX + curWidth;\r
 331 py = curY + curHeight;\r
 332 for (i = curX; i < (curX + curWidth); i++) {\r
 333 yMaxArray[i] = py;\r
 334 }\r
 335 for (i = curY; i < (curY + curHeight); i++) {\r
 336 xMaxArray[i] = px;\r
 337 }\r
 338 if (constraints.gridheight == 0 && constraints.gridwidth == 0) curRow = curCol = -1;\r
 339 if (constraints.gridheight == 0 && curRow < 0) curCol = curX + curWidth;\r
 340  else if (constraints.gridwidth == 0 && curCol < 0) curRow = curY + curHeight;\r
 341 constraints.tempX = curX;\r
 342 constraints.tempY = curY;\r
 343 constraints.tempWidth = curWidth;\r
 344 constraints.tempHeight = curHeight;\r
 345 anchor = constraints.anchor;\r
 346 if (hasBaseline) {\r
 347 switch (anchor) {\r
 348 case 256:\r
 349 case 512:\r
 350 case 768:\r
 351 if (constraints.ascent >= 0) {\r
 352 if (curHeight == 1) {\r
 353 maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);\r
 354 maxDescent[curY] = Math.max (maxDescent[curY], constraints.descent);\r
 355 } else {\r
 356 if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
 357 maxDescent[curY + curHeight - 1] = Math.max (maxDescent[curY + curHeight - 1], constraints.descent);\r
 358 } else {\r
 359 maxAscent[curY] = Math.max (maxAscent[curY], constraints.ascent);\r
 360 }}if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
 361 baselineType[curY + curHeight - 1] |= (1 << constraints.baselineResizeBehavior.ordinal ());\r
 362 } else {\r
 363 baselineType[curY] |= (1 << constraints.baselineResizeBehavior.ordinal ());\r
 364 }}break;\r
 365 case 1024:\r
 366 case 1280:\r
 367 case 1536:\r
 368 pixels_diff = constraints.minHeight + constraints.insets.top + constraints.ipady;\r
 369 maxAscent[curY] = Math.max (maxAscent[curY], pixels_diff);\r
 370 maxDescent[curY] = Math.max (maxDescent[curY], constraints.insets.bottom);\r
 371 break;\r
 372 case 1792:\r
 373 case 2048:\r
 374 case 2304:\r
 375 pixels_diff = constraints.minHeight + constraints.insets.bottom + constraints.ipady;\r
 376 maxDescent[curY] = Math.max (maxDescent[curY], pixels_diff);\r
 377 maxAscent[curY] = Math.max (maxAscent[curY], constraints.insets.top);\r
 378 break;\r
 379 }\r
 380 }}\r
 381 r.weightX =  Clazz.newDoubleArray (maximumArrayYIndex, 0);\r
 382 r.weightY =  Clazz.newDoubleArray (maximumArrayXIndex, 0);\r
 383 r.minWidth =  Clazz.newIntArray (maximumArrayYIndex, 0);\r
 384 r.minHeight =  Clazz.newIntArray (maximumArrayXIndex, 0);\r
 385 if (this.columnWidths != null) System.arraycopy (this.columnWidths, 0, r.minWidth, 0, this.columnWidths.length);\r
 386 if (this.rowHeights != null) System.arraycopy (this.rowHeights, 0, r.minHeight, 0, this.rowHeights.length);\r
 387 if (this.columnWeights != null) System.arraycopy (this.columnWeights, 0, r.weightX, 0, Math.min (r.weightX.length, this.columnWeights.length));\r
 388 if (this.rowWeights != null) System.arraycopy (this.rowWeights, 0, r.weightY, 0, Math.min (r.weightY.length, this.rowWeights.length));\r
 389 nextSize = 2147483647;\r
 390 for (i = 1; i != 2147483647; i = nextSize, nextSize = 2147483647) {\r
 391 for (compindex = 0; compindex < components.length; compindex++) {\r
 392 comp = components[compindex];\r
 393 if (!comp.isVisible ()) continue;\r
 394 constraints = this.lookupConstraints (comp);\r
 395 if (constraints.tempWidth == i) {\r
 396 px = constraints.tempX + constraints.tempWidth;\r
 397 weight_diff = constraints.weightx;\r
 398 for (k = constraints.tempX; k < px; k++) weight_diff -= r.weightX[k];\r
 399 \r
 400 if (weight_diff > 0.0) {\r
 401 weight = 0.0;\r
 402 for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];\r
 403 \r
 404 for (k = constraints.tempX; weight > 0.0 && k < px; k++) {\r
 405 var wt = r.weightX[k];\r
 406 var dx = (wt * weight_diff) / weight;\r
 407 r.weightX[k] += dx;\r
 408 weight_diff -= dx;\r
 409 weight -= wt;\r
 410 }\r
 411 r.weightX[px - 1] += weight_diff;\r
 412 }pixels_diff = constraints.minWidth + constraints.ipadx + constraints.insets.left + constraints.insets.right;\r
 413 for (k = constraints.tempX; k < px; k++) pixels_diff -= r.minWidth[k];\r
 414 \r
 415 if (pixels_diff > 0) {\r
 416 weight = 0.0;\r
 417 for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];\r
 418 \r
 419 for (k = constraints.tempX; weight > 0.0 && k < px; k++) {\r
 420 var wt = r.weightX[k];\r
 421 var dx = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);\r
 422 r.minWidth[k] += dx;\r
 423 pixels_diff -= dx;\r
 424 weight -= wt;\r
 425 }\r
 426 r.minWidth[px - 1] += pixels_diff;\r
 427 }} else if (constraints.tempWidth > i && constraints.tempWidth < nextSize) nextSize = constraints.tempWidth;\r
 428 if (constraints.tempHeight == i) {\r
 429 py = constraints.tempY + constraints.tempHeight;\r
 430 weight_diff = constraints.weighty;\r
 431 for (k = constraints.tempY; k < py; k++) weight_diff -= r.weightY[k];\r
 432 \r
 433 if (weight_diff > 0.0) {\r
 434 weight = 0.0;\r
 435 for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];\r
 436 \r
 437 for (k = constraints.tempY; weight > 0.0 && k < py; k++) {\r
 438 var wt = r.weightY[k];\r
 439 var dy = (wt * weight_diff) / weight;\r
 440 r.weightY[k] += dy;\r
 441 weight_diff -= dy;\r
 442 weight -= wt;\r
 443 }\r
 444 r.weightY[py - 1] += weight_diff;\r
 445 }pixels_diff = -1;\r
 446 if (hasBaseline) {\r
 447 switch (constraints.anchor) {\r
 448 case 256:\r
 449 case 512:\r
 450 case 768:\r
 451 if (constraints.ascent >= 0) {\r
 452 if (constraints.tempHeight == 1) {\r
 453 pixels_diff = maxAscent[constraints.tempY] + maxDescent[constraints.tempY];\r
 454 } else if (constraints.baselineResizeBehavior !== java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
 455 pixels_diff = maxAscent[constraints.tempY] + constraints.descent;\r
 456 } else {\r
 457 pixels_diff = constraints.ascent + maxDescent[constraints.tempY + constraints.tempHeight - 1];\r
 458 }}break;\r
 459 case 1024:\r
 460 case 1280:\r
 461 case 1536:\r
 462 pixels_diff = constraints.insets.top + constraints.minHeight + constraints.ipady + maxDescent[constraints.tempY];\r
 463 break;\r
 464 case 1792:\r
 465 case 2048:\r
 466 case 2304:\r
 467 pixels_diff = maxAscent[constraints.tempY] + constraints.minHeight + constraints.insets.bottom + constraints.ipady;\r
 468 break;\r
 469 }\r
 470 }if (pixels_diff == -1) {\r
 471 pixels_diff = constraints.minHeight + constraints.ipady + constraints.insets.top + constraints.insets.bottom;\r
 472 }for (k = constraints.tempY; k < py; k++) pixels_diff -= r.minHeight[k];\r
 473 \r
 474 if (pixels_diff > 0) {\r
 475 weight = 0.0;\r
 476 for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];\r
 477 \r
 478 for (k = constraints.tempY; weight > 0.0 && k < py; k++) {\r
 479 var wt = r.weightY[k];\r
 480 var dy = Clazz.doubleToInt ((wt * (pixels_diff)) / weight);\r
 481 r.minHeight[k] += dy;\r
 482 pixels_diff -= dy;\r
 483 weight -= wt;\r
 484 }\r
 485 r.minHeight[py - 1] += pixels_diff;\r
 486 }} else if (constraints.tempHeight > i && constraints.tempHeight < nextSize) nextSize = constraints.tempHeight;\r
 487 }\r
 488 }\r
 489 return r;\r
 490 }}, "java.awt.Container,~N");\r
 491 Clazz.defineMethod (c$, "calculateBaseline", \r
 492  function (c, constraints, size) {\r
 493 var anchor = constraints.anchor;\r
 494 if (anchor == 256 || anchor == 512 || anchor == 768) {\r
 495 var w = size.width + constraints.ipadx;\r
 496 var h = size.height + constraints.ipady;\r
 497 constraints.ascent = c.getBaseline (w, h);\r
 498 if (constraints.ascent >= 0) {\r
 499 var baseline = constraints.ascent;\r
 500 constraints.descent = h - constraints.ascent + constraints.insets.bottom;\r
 501 constraints.ascent += constraints.insets.top;\r
 502 constraints.baselineResizeBehavior = c.getBaselineResizeBehavior ();\r
 503 constraints.centerPadding = 0;\r
 504 if (constraints.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET) {\r
 505 var nextBaseline = c.getBaseline (w, h + 1);\r
 506 constraints.centerOffset = baseline - Clazz.doubleToInt (h / 2);\r
 507 if (h % 2 == 0) {\r
 508 if (baseline != nextBaseline) {\r
 509 constraints.centerPadding = 1;\r
 510 }} else if (baseline == nextBaseline) {\r
 511 constraints.centerOffset--;\r
 512 constraints.centerPadding = 1;\r
 513 }}}return true;\r
 514 } else {\r
 515 constraints.ascent = -1;\r
 516 return false;\r
 517 }}, "java.awt.Component,java.awt.GridBagConstraints,java.awt.Dimension");\r
 518 Clazz.defineMethod (c$, "adjustForGravity", \r
 519 function (constraints, r) {\r
 520 this.AdjustForGravity (constraints, r);\r
 521 }, "java.awt.GridBagConstraints,java.awt.Rectangle");\r
 522 Clazz.defineMethod (c$, "AdjustForGravity", \r
 523 function (constraints, r) {\r
 524 var diffx;\r
 525 var diffy;\r
 526 var cellY = r.y;\r
 527 var cellHeight = r.height;\r
 528 if (!this.rightToLeft) {\r
 529 r.x += constraints.insets.left;\r
 530 } else {\r
 531 r.x -= r.width - constraints.insets.right;\r
 532 }r.width -= (constraints.insets.left + constraints.insets.right);\r
 533 r.y += constraints.insets.top;\r
 534 r.height -= (constraints.insets.top + constraints.insets.bottom);\r
 535 diffx = 0;\r
 536 if ((constraints.fill != 2 && constraints.fill != 1) && (r.width > (constraints.minWidth + constraints.ipadx))) {\r
 537 diffx = r.width - (constraints.minWidth + constraints.ipadx);\r
 538 r.width = constraints.minWidth + constraints.ipadx;\r
 539 }diffy = 0;\r
 540 if ((constraints.fill != 3 && constraints.fill != 1) && (r.height > (constraints.minHeight + constraints.ipady))) {\r
 541 diffy = r.height - (constraints.minHeight + constraints.ipady);\r
 542 r.height = constraints.minHeight + constraints.ipady;\r
 543 }switch (constraints.anchor) {\r
 544 case 256:\r
 545 r.x += Clazz.doubleToInt (diffx / 2);\r
 546 this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
 547 break;\r
 548 case 512:\r
 549 if (this.rightToLeft) {\r
 550 r.x += diffx;\r
 551 }this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
 552 break;\r
 553 case 768:\r
 554 if (!this.rightToLeft) {\r
 555 r.x += diffx;\r
 556 }this.alignOnBaseline (constraints, r, cellY, cellHeight);\r
 557 break;\r
 558 case 1024:\r
 559 r.x += Clazz.doubleToInt (diffx / 2);\r
 560 this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
 561 break;\r
 562 case 1280:\r
 563 if (this.rightToLeft) {\r
 564 r.x += diffx;\r
 565 }this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
 566 break;\r
 567 case 1536:\r
 568 if (!this.rightToLeft) {\r
 569 r.x += diffx;\r
 570 }this.alignAboveBaseline (constraints, r, cellY, cellHeight);\r
 571 break;\r
 572 case 1792:\r
 573 r.x += Clazz.doubleToInt (diffx / 2);\r
 574 this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
 575 break;\r
 576 case 2048:\r
 577 if (this.rightToLeft) {\r
 578 r.x += diffx;\r
 579 }this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
 580 break;\r
 581 case 2304:\r
 582 if (!this.rightToLeft) {\r
 583 r.x += diffx;\r
 584 }this.alignBelowBaseline (constraints, r, cellY, cellHeight);\r
 585 break;\r
 586 case 10:\r
 587 r.x += Clazz.doubleToInt (diffx / 2);\r
 588 r.y += Clazz.doubleToInt (diffy / 2);\r
 589 break;\r
 590 case 19:\r
 591 case 11:\r
 592 r.x += Clazz.doubleToInt (diffx / 2);\r
 593 break;\r
 594 case 12:\r
 595 r.x += diffx;\r
 596 break;\r
 597 case 13:\r
 598 r.x += diffx;\r
 599 r.y += Clazz.doubleToInt (diffy / 2);\r
 600 break;\r
 601 case 14:\r
 602 r.x += diffx;\r
 603 r.y += diffy;\r
 604 break;\r
 605 case 20:\r
 606 case 15:\r
 607 r.x += Clazz.doubleToInt (diffx / 2);\r
 608 r.y += diffy;\r
 609 break;\r
 610 case 16:\r
 611 r.y += diffy;\r
 612 break;\r
 613 case 17:\r
 614 r.y += Clazz.doubleToInt (diffy / 2);\r
 615 break;\r
 616 case 18:\r
 617 break;\r
 618 case 21:\r
 619 if (this.rightToLeft) {\r
 620 r.x += diffx;\r
 621 }r.y += Clazz.doubleToInt (diffy / 2);\r
 622 break;\r
 623 case 22:\r
 624 if (!this.rightToLeft) {\r
 625 r.x += diffx;\r
 626 }r.y += Clazz.doubleToInt (diffy / 2);\r
 627 break;\r
 628 case 23:\r
 629 if (this.rightToLeft) {\r
 630 r.x += diffx;\r
 631 }break;\r
 632 case 24:\r
 633 if (!this.rightToLeft) {\r
 634 r.x += diffx;\r
 635 }break;\r
 636 case 25:\r
 637 if (this.rightToLeft) {\r
 638 r.x += diffx;\r
 639 }r.y += diffy;\r
 640 break;\r
 641 case 26:\r
 642 if (!this.rightToLeft) {\r
 643 r.x += diffx;\r
 644 }r.y += diffy;\r
 645 break;\r
 646 default:\r
 647 throw  new IllegalArgumentException ("illegal anchor value");\r
 648 }\r
 649 }, "java.awt.GridBagConstraints,java.awt.Rectangle");\r
 650 Clazz.defineMethod (c$, "alignOnBaseline", \r
 651  function (cons, r, cellY, cellHeight) {\r
 652 if (cons.ascent >= 0) {\r
 653 if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.CONSTANT_DESCENT) {\r
 654 var maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY + cons.tempHeight - 1] + cons.descent - cons.insets.bottom;\r
 655 if (!cons.isVerticallyResizable ()) {\r
 656 r.y = maxY - cons.minHeight;\r
 657 r.height = cons.minHeight;\r
 658 } else {\r
 659 r.height = maxY - cellY - cons.insets.top;\r
 660 }} else {\r
 661 var baseline;\r
 662 var ascent = cons.ascent;\r
 663 if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
 664 baseline = cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
 665 } else {\r
 666 baseline = this.layoutInfo.maxAscent[cons.tempY];\r
 667 }if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.OTHER) {\r
 668 var fits = false;\r
 669 ascent = this.componentAdjusting.getBaseline (r.width, r.height);\r
 670 if (ascent >= 0) {\r
 671 ascent += cons.insets.top;\r
 672 }if (ascent >= 0 && ascent <= baseline) {\r
 673 if (baseline + (r.height - ascent - cons.insets.top) <= cellHeight - cons.insets.bottom) {\r
 674 fits = true;\r
 675 } else if (cons.isVerticallyResizable ()) {\r
 676 var ascent2 = this.componentAdjusting.getBaseline (r.width, cellHeight - cons.insets.bottom - baseline + ascent);\r
 677 if (ascent2 >= 0) {\r
 678 ascent2 += cons.insets.top;\r
 679 }if (ascent2 >= 0 && ascent2 <= ascent) {\r
 680 r.height = cellHeight - cons.insets.bottom - baseline + ascent;\r
 681 ascent = ascent2;\r
 682 fits = true;\r
 683 }}}if (!fits) {\r
 684 ascent = cons.ascent;\r
 685 r.width = cons.minWidth;\r
 686 r.height = cons.minHeight;\r
 687 }}r.y = cellY + baseline - ascent + cons.insets.top;\r
 688 if (cons.isVerticallyResizable ()) {\r
 689 switch (cons.baselineResizeBehavior) {\r
 690 case java.awt.Component.BaselineResizeBehavior.CONSTANT_ASCENT:\r
 691 r.height = Math.max (cons.minHeight, cellY + cellHeight - r.y - cons.insets.bottom);\r
 692 break;\r
 693 case java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET:\r
 694 {\r
 695 var upper = r.y - cellY - cons.insets.top;\r
 696 var lower = cellY + cellHeight - r.y - cons.minHeight - cons.insets.bottom;\r
 697 var delta = Math.min (upper, lower);\r
 698 delta += delta;\r
 699 if (delta > 0 && Clazz.doubleToInt ((cons.minHeight + cons.centerPadding + delta) / 2) + cons.centerOffset != baseline) {\r
 700 delta--;\r
 701 }r.height = cons.minHeight + delta;\r
 702 r.y = cellY + baseline - Clazz.doubleToInt ((r.height + cons.centerPadding) / 2) - cons.centerOffset;\r
 703 }break;\r
 704 case java.awt.Component.BaselineResizeBehavior.OTHER:\r
 705 break;\r
 706 default:\r
 707 break;\r
 708 }\r
 709 }}} else {\r
 710 this.centerVertically (cons, r, cellHeight);\r
 711 }}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
 712 Clazz.defineMethod (c$, "alignAboveBaseline", \r
 713  function (cons, r, cellY, cellHeight) {\r
 714 if (this.layoutInfo.hasBaseline (cons.tempY)) {\r
 715 var maxY;\r
 716 if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
 717 maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
 718 } else {\r
 719 maxY = cellY + this.layoutInfo.maxAscent[cons.tempY];\r
 720 }if (cons.isVerticallyResizable ()) {\r
 721 r.y = cellY + cons.insets.top;\r
 722 r.height = maxY - r.y;\r
 723 } else {\r
 724 r.height = cons.minHeight + cons.ipady;\r
 725 r.y = maxY - r.height;\r
 726 }} else {\r
 727 this.centerVertically (cons, r, cellHeight);\r
 728 }}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
 729 Clazz.defineMethod (c$, "alignBelowBaseline", \r
 730  function (cons, r, cellY, cellHeight) {\r
 731 if (this.layoutInfo.hasBaseline (cons.tempY)) {\r
 732 if (this.layoutInfo.hasConstantDescent (cons.tempY)) {\r
 733 r.y = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];\r
 734 } else {\r
 735 r.y = cellY + this.layoutInfo.maxAscent[cons.tempY];\r
 736 }if (cons.isVerticallyResizable ()) {\r
 737 r.height = cellY + cellHeight - r.y - cons.insets.bottom;\r
 738 }} else {\r
 739 this.centerVertically (cons, r, cellHeight);\r
 740 }}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N,~N");\r
 741 Clazz.defineMethod (c$, "centerVertically", \r
 742  function (cons, r, cellHeight) {\r
 743 if (!cons.isVerticallyResizable ()) {\r
 744 r.y += Math.max (0, Clazz.doubleToInt ((cellHeight - cons.insets.top - cons.insets.bottom - cons.minHeight - cons.ipady) / 2));\r
 745 }}, "java.awt.GridBagConstraints,java.awt.Rectangle,~N");\r
 746 Clazz.defineMethod (c$, "getMinSize", \r
 747 function (parent, info) {\r
 748 return this.GetMinSize (parent, info);\r
 749 }, "java.awt.Container,java.awt.GridBagLayoutInfo");\r
 750 Clazz.defineMethod (c$, "GetMinSize", \r
 751 function (parent, info) {\r
 752 var d =  new java.awt.Dimension ();\r
 753 var i;\r
 754 var t;\r
 755 var insets = parent.getInsets ();\r
 756 t = 0;\r
 757 for (i = 0; i < info.width; i++) t += info.minWidth[i];\r
 758 \r
 759 d.width = t + insets.left + insets.right;\r
 760 t = 0;\r
 761 for (i = 0; i < info.height; i++) t += info.minHeight[i];\r
 762 \r
 763 d.height = t + insets.top + insets.bottom;\r
 764 return d;\r
 765 }, "java.awt.Container,java.awt.GridBagLayoutInfo");\r
 766 Clazz.defineMethod (c$, "arrangeGrid", \r
 767 function (parent) {\r
 768 this.ArrangeGrid (parent);\r
 769 }, "java.awt.Container");\r
 770 Clazz.defineMethod (c$, "ArrangeGrid", \r
 771 function (parent) {\r
 772 var comp;\r
 773 var compindex;\r
 774 var constraints;\r
 775 var insets = parent.getInsets ();\r
 776 var components = parent.getComponents ();\r
 777 var d;\r
 778 var r =  new java.awt.Rectangle ();\r
 779 var i;\r
 780 var diffw;\r
 781 var diffh;\r
 782 var weight;\r
 783 var info;\r
 784 this.rightToLeft = !parent.getComponentOrientation ().isLeftToRight ();\r
 785 if (components.length == 0 && (this.columnWidths == null || this.columnWidths.length == 0) && (this.rowHeights == null || this.rowHeights.length == 0)) {\r
 786 return;\r
 787 }info = this.getLayoutInfo (parent, 2);\r
 788 d = this.getMinSize (parent, info);\r
 789 if (parent.width < d.width || parent.height < d.height) {\r
 790 info = this.getLayoutInfo (parent, 1);\r
 791 d = this.getMinSize (parent, info);\r
 792 }this.layoutInfo = info;\r
 793 r.width = d.width;\r
 794 r.height = d.height;\r
 795 diffw = parent.width - r.width;\r
 796 if (diffw != 0) {\r
 797 weight = 0.0;\r
 798 for (i = 0; i < info.width; i++) weight += info.weightX[i];\r
 799 \r
 800 if (weight > 0.0) {\r
 801 for (i = 0; i < info.width; i++) {\r
 802 var dx = Clazz.doubleToInt (((diffw) * info.weightX[i]) / weight);\r
 803 info.minWidth[i] += dx;\r
 804 r.width += dx;\r
 805 if (info.minWidth[i] < 0) {\r
 806 r.width -= info.minWidth[i];\r
 807 info.minWidth[i] = 0;\r
 808 }}\r
 809 }diffw = parent.width - r.width;\r
 810 } else {\r
 811 diffw = 0;\r
 812 }diffh = parent.height - r.height;\r
 813 if (diffh != 0) {\r
 814 weight = 0.0;\r
 815 for (i = 0; i < info.height; i++) weight += info.weightY[i];\r
 816 \r
 817 if (weight > 0.0) {\r
 818 for (i = 0; i < info.height; i++) {\r
 819 var dy = Clazz.doubleToInt (((diffh) * info.weightY[i]) / weight);\r
 820 info.minHeight[i] += dy;\r
 821 r.height += dy;\r
 822 if (info.minHeight[i] < 0) {\r
 823 r.height -= info.minHeight[i];\r
 824 info.minHeight[i] = 0;\r
 825 }}\r
 826 }diffh = parent.height - r.height;\r
 827 } else {\r
 828 diffh = 0;\r
 829 }info.startx = Clazz.doubleToInt (diffw / 2) + insets.left;\r
 830 info.starty = Clazz.doubleToInt (diffh / 2) + insets.top;\r
 831 for (compindex = 0; compindex < components.length; compindex++) {\r
 832 comp = components[compindex];\r
 833 if (!comp.isVisible ()) {\r
 834 continue;\r
 835 }constraints = this.lookupConstraints (comp);\r
 836 if (!this.rightToLeft) {\r
 837 r.x = info.startx;\r
 838 for (i = 0; i < constraints.tempX; i++) r.x += info.minWidth[i];\r
 839 \r
 840 } else {\r
 841 r.x = parent.width - (Clazz.doubleToInt (diffw / 2) + insets.right);\r
 842 for (i = 0; i < constraints.tempX; i++) r.x -= info.minWidth[i];\r
 843 \r
 844 }r.y = info.starty;\r
 845 for (i = 0; i < constraints.tempY; i++) r.y += info.minHeight[i];\r
 846 \r
 847 r.width = 0;\r
 848 for (i = constraints.tempX; i < (constraints.tempX + constraints.tempWidth); i++) {\r
 849 r.width += info.minWidth[i];\r
 850 }\r
 851 r.height = 0;\r
 852 for (i = constraints.tempY; i < (constraints.tempY + constraints.tempHeight); i++) {\r
 853 r.height += info.minHeight[i];\r
 854 }\r
 855 this.componentAdjusting = comp;\r
 856 this.adjustForGravity (constraints, r);\r
 857 if (r.x < 0) {\r
 858 r.width += r.x;\r
 859 r.x = 0;\r
 860 }if (r.y < 0) {\r
 861 r.height += r.y;\r
 862 r.y = 0;\r
 863 }if ((r.width <= 0) || (r.height <= 0)) {\r
 864 comp.setBounds (0, 0, 0, 0);\r
 865 } else {\r
 866 if (comp.x != r.x || comp.y != r.y || comp.width != r.width || comp.height != r.height) {\r
 867 comp.setBounds (r.x, r.y, r.width, r.height);\r
 868 }}}\r
 869 }, "java.awt.Container");\r
 870 Clazz.defineStatics (c$,\r
 871 "EMPIRICMULTIPLIER", 2,\r
 872 "MAXGRIDSIZE", 512,\r
 873 "MINSIZE", 1,\r
 874 "PREFERREDSIZE", 2);\r
 875 });\r