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
17 this.comptable = new java.util.Hashtable ();
\r
18 this.defaultConstraints = new java.awt.GridBagConstraints ();
\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
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
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
42 this.comptable.remove (comp);
\r
43 }, "java.awt.Component");
\r
44 Clazz.defineMethod (c$, "getLayoutOrigin",
\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
52 Clazz.defineMethod (c$, "getLayoutDimensions",
\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
62 Clazz.defineMethod (c$, "getLayoutWeights",
\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
72 Clazz.defineMethod (c$, "location",
\r
74 var loc = new java.awt.Point (0, 0);
\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
85 for (i = this.layoutInfo.width - 1; i >= 0; i--) {
\r
87 d += this.layoutInfo.minWidth[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
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
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
130 }, "java.awt.Container");
\r
131 Clazz.overrideMethod (c$, "getLayoutAlignmentY",
\r
132 function (parent) {
\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
145 return this.getClass ().getName ();
\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
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
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
173 curX = ++preMaximumArrayYIndex;
\r
175 curY = ++preMaximumArrayXIndex;
\r
176 }if (curWidth <= 0) {
\r
178 }if (curHeight <= 0) {
\r
180 }preMaximumArrayXIndex = Math.max (curY + curHeight, preMaximumArrayXIndex);
\r
181 preMaximumArrayYIndex = Math.max (curX + curWidth, preMaximumArrayYIndex);
\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
194 var components = parent.getComponents ();
\r
214 var maximumArrayXIndex = 0;
\r
215 var maximumArrayYIndex = 0;
\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
245 for (i = curY; i < (curY + curHeight); i++) {
\r
246 px = Math.max (px, xMaxArray[i]);
\r
248 curX = px - curX - 1;
\r
249 if (curX < 0) curX = 0;
\r
250 } else if (curY < 0) {
\r
252 for (i = curX; i < (curX + curWidth); i++) {
\r
253 py = Math.max (py, yMaxArray[i]);
\r
255 curY = py - curY - 1;
\r
256 if (curY < 0) curY = 0;
\r
257 }px = curX + curWidth;
\r
258 if (layoutWidth < px) {
\r
260 }py = curY + curHeight;
\r
261 if (layoutHeight < py) {
\r
263 }for (i = curX; i < (curX + curWidth); i++) {
\r
266 for (i = curY; i < (curY + curHeight); i++) {
\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
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
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
306 if (curHeight <= 0) {
\r
307 curHeight += r.height - curY;
\r
308 if (curHeight < 1) curHeight = 1;
\r
310 for (i = curY; i < (curY + curHeight); i++) px = Math.max (px, xMaxArray[i]);
\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
319 for (i = curX; i < (curX + curWidth); i++) {
\r
320 py = Math.max (py, yMaxArray[i]);
\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
335 for (i = curY; i < (curY + curHeight); i++) {
\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
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
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
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
363 baselineType[curY] |= (1 << constraints.baselineResizeBehavior.ordinal ());
\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
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
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
400 if (weight_diff > 0.0) {
\r
402 for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];
\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
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
415 if (pixels_diff > 0) {
\r
417 for (k = constraints.tempX; k < px; k++) weight += r.weightX[k];
\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
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
433 if (weight_diff > 0.0) {
\r
435 for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];
\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
444 r.weightY[py - 1] += weight_diff;
\r
447 switch (constraints.anchor) {
\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
457 pixels_diff = constraints.ascent + maxDescent[constraints.tempY + constraints.tempHeight - 1];
\r
462 pixels_diff = constraints.insets.top + constraints.minHeight + constraints.ipady + maxDescent[constraints.tempY];
\r
467 pixels_diff = maxAscent[constraints.tempY] + constraints.minHeight + constraints.insets.bottom + constraints.ipady;
\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
474 if (pixels_diff > 0) {
\r
476 for (k = constraints.tempY; k < py; k++) weight += r.weightY[k];
\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
485 r.minHeight[py - 1] += pixels_diff;
\r
486 }} else if (constraints.tempHeight > i && constraints.tempHeight < nextSize) nextSize = constraints.tempHeight;
\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
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
515 constraints.ascent = -1;
\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
527 var cellHeight = r.height;
\r
528 if (!this.rightToLeft) {
\r
529 r.x += constraints.insets.left;
\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
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
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
545 r.x += Clazz.doubleToInt (diffx / 2);
\r
546 this.alignOnBaseline (constraints, r, cellY, cellHeight);
\r
549 if (this.rightToLeft) {
\r
551 }this.alignOnBaseline (constraints, r, cellY, cellHeight);
\r
554 if (!this.rightToLeft) {
\r
556 }this.alignOnBaseline (constraints, r, cellY, cellHeight);
\r
559 r.x += Clazz.doubleToInt (diffx / 2);
\r
560 this.alignAboveBaseline (constraints, r, cellY, cellHeight);
\r
563 if (this.rightToLeft) {
\r
565 }this.alignAboveBaseline (constraints, r, cellY, cellHeight);
\r
568 if (!this.rightToLeft) {
\r
570 }this.alignAboveBaseline (constraints, r, cellY, cellHeight);
\r
573 r.x += Clazz.doubleToInt (diffx / 2);
\r
574 this.alignBelowBaseline (constraints, r, cellY, cellHeight);
\r
577 if (this.rightToLeft) {
\r
579 }this.alignBelowBaseline (constraints, r, cellY, cellHeight);
\r
582 if (!this.rightToLeft) {
\r
584 }this.alignBelowBaseline (constraints, r, cellY, cellHeight);
\r
587 r.x += Clazz.doubleToInt (diffx / 2);
\r
588 r.y += Clazz.doubleToInt (diffy / 2);
\r
592 r.x += Clazz.doubleToInt (diffx / 2);
\r
599 r.y += Clazz.doubleToInt (diffy / 2);
\r
607 r.x += Clazz.doubleToInt (diffx / 2);
\r
614 r.y += Clazz.doubleToInt (diffy / 2);
\r
619 if (this.rightToLeft) {
\r
621 }r.y += Clazz.doubleToInt (diffy / 2);
\r
624 if (!this.rightToLeft) {
\r
626 }r.y += Clazz.doubleToInt (diffy / 2);
\r
629 if (this.rightToLeft) {
\r
633 if (!this.rightToLeft) {
\r
637 if (this.rightToLeft) {
\r
642 if (!this.rightToLeft) {
\r
647 throw new IllegalArgumentException ("illegal anchor value");
\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
659 r.height = maxY - cellY - cons.insets.top;
\r
662 var ascent = cons.ascent;
\r
663 if (this.layoutInfo.hasConstantDescent (cons.tempY)) {
\r
664 baseline = cellHeight - this.layoutInfo.maxDescent[cons.tempY];
\r
666 baseline = this.layoutInfo.maxAscent[cons.tempY];
\r
667 }if (cons.baselineResizeBehavior === java.awt.Component.BaselineResizeBehavior.OTHER) {
\r
669 ascent = this.componentAdjusting.getBaseline (r.width, r.height);
\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
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
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
693 case java.awt.Component.BaselineResizeBehavior.CENTER_OFFSET:
\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
699 if (delta > 0 && Clazz.doubleToInt ((cons.minHeight + cons.centerPadding + delta) / 2) + cons.centerOffset != baseline) {
\r
701 }r.height = cons.minHeight + delta;
\r
702 r.y = cellY + baseline - Clazz.doubleToInt ((r.height + cons.centerPadding) / 2) - cons.centerOffset;
\r
704 case java.awt.Component.BaselineResizeBehavior.OTHER:
\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
716 if (this.layoutInfo.hasConstantDescent (cons.tempY)) {
\r
717 maxY = cellY + cellHeight - this.layoutInfo.maxDescent[cons.tempY];
\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
724 r.height = cons.minHeight + cons.ipady;
\r
725 r.y = maxY - r.height;
\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
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
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
755 var insets = parent.getInsets ();
\r
757 for (i = 0; i < info.width; i++) t += info.minWidth[i];
\r
759 d.width = t + insets.left + insets.right;
\r
761 for (i = 0; i < info.height; i++) t += info.minHeight[i];
\r
763 d.height = t + insets.top + insets.bottom;
\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
775 var insets = parent.getInsets ();
\r
776 var components = parent.getComponents ();
\r
778 var r = new java.awt.Rectangle ();
\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
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
794 r.height = d.height;
\r
795 diffw = parent.width - r.width;
\r
798 for (i = 0; i < info.width; i++) weight += info.weightX[i];
\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
805 if (info.minWidth[i] < 0) {
\r
806 r.width -= info.minWidth[i];
\r
807 info.minWidth[i] = 0;
\r
809 }diffw = parent.width - r.width;
\r
812 }diffh = parent.height - r.height;
\r
815 for (i = 0; i < info.height; i++) weight += info.weightY[i];
\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
822 if (info.minHeight[i] < 0) {
\r
823 r.height -= info.minHeight[i];
\r
824 info.minHeight[i] = 0;
\r
826 }diffh = parent.height - r.height;
\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
835 }constraints = this.lookupConstraints (comp);
\r
836 if (!this.rightToLeft) {
\r
838 for (i = 0; i < constraints.tempX; i++) r.x += info.minWidth[i];
\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
844 }r.y = info.starty;
\r
845 for (i = 0; i < constraints.tempY; i++) r.y += info.minHeight[i];
\r
848 for (i = constraints.tempX; i < (constraints.tempX + constraints.tempWidth); i++) {
\r
849 r.width += info.minWidth[i];
\r
852 for (i = constraints.tempY; i < (constraints.tempY + constraints.tempHeight); i++) {
\r
853 r.height += info.minHeight[i];
\r
855 this.componentAdjusting = comp;
\r
856 this.adjustForGravity (constraints, r);
\r
863 }if ((r.width <= 0) || (r.height <= 0)) {
\r
864 comp.setBounds (0, 0, 0, 0);
\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
869 }, "java.awt.Container");
\r
870 Clazz.defineStatics (c$,
\r
871 "EMPIRICMULTIPLIER", 2,
\r
872 "MAXGRIDSIZE", 512,
\r
874 "PREFERREDSIZE", 2);
\r