6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javafx.scene.layout;
27
28 import static org.junit.Assert.assertEquals;
29 import static org.junit.Assert.assertNull;
30 import static org.junit.Assert.assertTrue;
31 import javafx.geometry.Insets;
32 import javafx.geometry.Orientation;
33 import javafx.geometry.Pos;
34 import javafx.scene.shape.Rectangle;
35
36 import org.junit.Before;
37 import org.junit.Test;
38
39
40 public class VBoxTest {
41 VBox vbox;
42
43 @Before public void setUp() {
44 this.vbox = new VBox();
45 }
46
47 @Test public void testVBoxDefaults() {
48 assertEquals(0, vbox.getSpacing(), 1e-100);
49 assertTrue(vbox.isFillWidth());
50 assertEquals(Pos.TOP_LEFT, vbox.getAlignment());
51 }
52
53 @Test public void testVBoxNulls() {
54 vbox.setAlignment(null);
55
56 // this musn't throw NPE
57 vbox.autosize();
58 vbox.layout();
59
60 assertNull(null, vbox.getAlignment());
61 assertNull(null, vbox.alignmentProperty().get());
62 }
63
64 @Test public void testSimpleVBox() {
65 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
66 Rectangle child2 = new Rectangle(100, 100);
67 vbox.getChildren().addAll(child1, child2);
68
69 assertEquals(100, vbox.minWidth(-1), 1e-100);
70 assertEquals(300, vbox.minHeight(-1), 1e-100);
71 assertEquals(300, vbox.prefWidth(-1), 1e-100);
72 assertEquals(500, vbox.prefHeight(-1), 1e-100);
73
74 vbox.autosize();
75 vbox.layout();
76 assertEquals(0, child1.getLayoutX(), 1e-100);
77 assertEquals(0, child1.getLayoutY(), 1e-100);
78 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
79 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
80 assertEquals(0, child2.getLayoutX(), 1e-100);
81 assertEquals(400, child2.getLayoutY(), 1e-100);
82 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
83 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
84
85 vbox.resize(500,500);
86 vbox.layout();
87 assertEquals(0, child1.getLayoutX(), 1e-100);
88 assertEquals(0, child1.getLayoutY(), 1e-100);
89 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
90 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
91 assertEquals(0, child2.getLayoutX(), 1e-100);
92 assertEquals(400, child2.getLayoutY(), 1e-100);
93 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
94 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
95 }
96
97 @Test public void testVBoxSpacing() {
98 vbox.setSpacing(10);
99 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
100 Rectangle child2 = new Rectangle(100, 100);
101 vbox.getChildren().addAll(child1, child2);
102
103 assertEquals(100, vbox.minWidth(-1), 1e-100);
104 assertEquals(310, vbox.minHeight(-1), 1e-100);
105 assertEquals(300, vbox.prefWidth(-1), 1e-100);
106 assertEquals(510, vbox.prefHeight(-1), 1e-100);
107
108 vbox.autosize();
109 vbox.layout();
110 assertEquals(0, child1.getLayoutX(), 1e-100);
111 assertEquals(0, child1.getLayoutY(), 1e-100);
112 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
113 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
114 assertEquals(0, child2.getLayoutX(), 1e-100);
115 assertEquals(410, child2.getLayoutY(), 1e-100);
116 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
117 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
118
119 vbox.resize(500,500);
120 vbox.layout();
121 assertEquals(0, child1.getLayoutX(), 1e-100);
122 assertEquals(0, child1.getLayoutY(), 1e-100);
123 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
124 assertEquals(390, child1.getLayoutBounds().getHeight(), 1e-100);
125 assertEquals(0, child2.getLayoutX(), 1e-100);
126 assertEquals(400, child2.getLayoutY(), 1e-100);
127 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
128 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
129 }
130
131 @Test public void testVBoxFillWidth() {
132 vbox.setFillWidth(false);
133 vbox.setAlignment(Pos.TOP_CENTER);
134 MockResizable child1 = new MockResizable(100,100, 200,300, 500,600);
135 MockResizable child2 = new MockResizable(100,100, 100, 400, 800, 800);
136 vbox.getChildren().addAll(child1, child2);
137
138 assertEquals(100, vbox.minWidth(-1), 1e-100);
139 assertEquals(200, vbox.minHeight(-1), 1e-100);
140 assertEquals(200, vbox.prefWidth(-1), 1e-100);
141 assertEquals(700, vbox.prefHeight(-1), 1e-100);
142
143 vbox.autosize();
144 vbox.layout();
145 assertEquals(0, child1.getLayoutX(), 1e-100);
146 assertEquals(0, child1.getLayoutY(), 1e-100);
147 assertEquals(200, child1.getLayoutBounds().getWidth(), 1e-100);
148 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
149 assertEquals(50, child2.getLayoutX(), 1e-100);
150 assertEquals(300, child2.getLayoutY(), 1e-100);
151 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
152 assertEquals(400, child2.getLayoutBounds().getHeight(), 1e-100);
153
154 vbox.resize(500,800);
155 vbox.layout();
156 assertEquals(150, child1.getLayoutX(), 1e-100);
157 assertEquals(0, child1.getLayoutY(), 1e-100);
158 assertEquals(200, child1.getLayoutBounds().getWidth(), 1e-100);
159 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
160 assertEquals(200, child2.getLayoutX(), 1e-100);
161 assertEquals(300, child2.getLayoutY(), 1e-100);
162 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
163 assertEquals(400, child2.getLayoutBounds().getHeight(), 1e-100);
164 }
165
166 @Test public void testVBoxAlignmentTopLeft() {
167 MockResizable child1 = new MockResizable(300,400);
168 Rectangle child2 = new Rectangle(100, 100);
169 vbox.getChildren().addAll(child1, child2);
170
171 vbox.setAlignment(Pos.TOP_LEFT);
172 vbox.resize(500,600);
173 vbox.layout();
174 assertEquals(0, child1.getLayoutX(), 1e-100);
175 assertEquals(0, child1.getLayoutY(), 1e-100);
176 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
177 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
178 assertEquals(0, child2.getLayoutX(), 1e-100);
179 assertEquals(400, child2.getLayoutY(), 1e-100);
180 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
181 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
182 }
183
184 @Test public void testVBoxAlignmentTopCenter() {
185 MockResizable child1 = new MockResizable(300,400);
186 Rectangle child2 = new Rectangle(100, 100);
187 vbox.getChildren().addAll(child1, child2);
188
189 vbox.setAlignment(Pos.TOP_CENTER);
190 vbox.resize(500,600);
191 vbox.layout();
192 assertEquals(0, child1.getLayoutX(), 1e-100);
193 assertEquals(0, child1.getLayoutY(), 1e-100);
194 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
195 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
196 assertEquals(200, child2.getLayoutX(), 1e-100);
197 assertEquals(400, child2.getLayoutY(), 1e-100);
198 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
199 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
200 }
201
202 @Test public void testVBoxAlignmentTopRight() {
203 MockResizable child1 = new MockResizable(300,400);
204 Rectangle child2 = new Rectangle(100, 100);
205 vbox.getChildren().addAll(child1, child2);
206
207 vbox.setAlignment(Pos.TOP_RIGHT);
208 vbox.resize(500,600);
209 vbox.layout();
210 assertEquals(0, child1.getLayoutX(), 1e-100);
211 assertEquals(0, child1.getLayoutY(), 1e-100);
212 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
213 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
214 assertEquals(400, child2.getLayoutX(), 1e-100);
215 assertEquals(400, child2.getLayoutY(), 1e-100);
216 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
217 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
218 }
219
220 @Test public void testVBoxAlignmentCenterLeft() {
221 MockResizable child1 = new MockResizable(300,400);
222 Rectangle child2 = new Rectangle(100, 100);
223 vbox.getChildren().addAll(child1, child2);
224
225 vbox.setAlignment(Pos.CENTER_LEFT);
226 vbox.resize(500,600);
227 vbox.layout();
228 assertEquals(0, child1.getLayoutX(), 1e-100);
229 assertEquals(50, child1.getLayoutY(), 1e-100);
230 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
231 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
232 assertEquals(0, child2.getLayoutX(), 1e-100);
233 assertEquals(450, child2.getLayoutY(), 1e-100);
234 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
235 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
236 }
237
238 @Test public void testVBoxAlignmentCenter() {
239 MockResizable child1 = new MockResizable(300,400);
240 Rectangle child2 = new Rectangle(100, 100);
241 vbox.getChildren().addAll(child1, child2);
242
243 vbox.setAlignment(Pos.CENTER);
244 vbox.resize(500,600);
245 vbox.layout();
246 assertEquals(0, child1.getLayoutX(), 1e-100);
247 assertEquals(50, child1.getLayoutY(), 1e-100);
248 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
249 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
250 assertEquals(200, child2.getLayoutX(), 1e-100);
251 assertEquals(450, child2.getLayoutY(), 1e-100);
252 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
253 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
254 }
255
256 @Test public void testVBoxAlignmentCenterRight() {
257 MockResizable child1 = new MockResizable(300,400);
258 Rectangle child2 = new Rectangle(100, 100);
259 vbox.getChildren().addAll(child1, child2);
260
261 vbox.setAlignment(Pos.CENTER_RIGHT);
262 vbox.resize(500,600);
263 vbox.layout();
264 assertEquals(0, child1.getLayoutX(), 1e-100);
265 assertEquals(50, child1.getLayoutY(), 1e-100);
266 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
267 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
268 assertEquals(400, child2.getLayoutX(), 1e-100);
269 assertEquals(450, child2.getLayoutY(), 1e-100);
270 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
271 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
272 }
273
274 @Test public void testVBoxAlignmentBottomLeft() {
275 MockResizable child1 = new MockResizable(300,400);
276 Rectangle child2 = new Rectangle(100, 100);
277 vbox.getChildren().addAll(child1, child2);
278
279 vbox.setAlignment(Pos.BOTTOM_LEFT);
280 vbox.resize(500,600);
281 vbox.layout();
282 assertEquals(0, child1.getLayoutX(), 1e-100);
283 assertEquals(100, child1.getLayoutY(), 1e-100);
284 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
285 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
286 assertEquals(0, child2.getLayoutX(), 1e-100);
287 assertEquals(500, child2.getLayoutY(), 1e-100);
288 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
289 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
290 }
291
292 @Test public void testVBoxAlignmentBottomCenter() {
293 MockResizable child1 = new MockResizable(300,400);
294 Rectangle child2 = new Rectangle(100, 100);
295 vbox.getChildren().addAll(child1, child2);
296
297 vbox.setAlignment(Pos.BOTTOM_CENTER);
298 vbox.resize(500,600);
299 vbox.layout();
300 assertEquals(0, child1.getLayoutX(), 1e-100);
301 assertEquals(100, child1.getLayoutY(), 1e-100);
302 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
303 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
304 assertEquals(200, child2.getLayoutX(), 1e-100);
305 assertEquals(500, child2.getLayoutY(), 1e-100);
306 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
307 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
308 }
309
310 @Test public void testVBoxAlignmentBottomRight() {
311 MockResizable child1 = new MockResizable(300,400);
312 Rectangle child2 = new Rectangle(100, 100);
313 vbox.getChildren().addAll(child1, child2);
314
315 vbox.setAlignment(Pos.BOTTOM_RIGHT);
316 vbox.resize(500,600);
317 vbox.layout();
318 assertEquals(0, child1.getLayoutX(), 1e-100);
319 assertEquals(100, child1.getLayoutY(), 1e-100);
320 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
321 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
322 assertEquals(400, child2.getLayoutX(), 1e-100);
323 assertEquals(500, child2.getLayoutY(), 1e-100);
324 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
325 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
326 }
327
328 @Test public void testVBoxContentBiasNullNoChildHasContentBias() {
329 Rectangle r = new Rectangle(100,100);
330 MockResizable child = new MockResizable(100,200);
331 vbox.getChildren().addAll(r, child);
332
333 assertNull(vbox.getContentBias());
334 assertEquals(100, vbox.prefWidth(-1), 0);
335 assertEquals(300, vbox.prefHeight(-1), 0);
336 assertEquals(300, vbox.prefHeight(200), 0);
337 }
338
339 @Test public void testVBoxContentBiasHORIZONTALifChildHORIZONTAL() {
340 Rectangle r = new Rectangle(100,100);
341 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
342 MockResizable child = new MockResizable(100,100);
343 vbox.getChildren().addAll(r, biased, child);
344
345 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
346 }
347
348 @Test public void testVBoxWithHorizontalContentBiasAtPrefSize() {
349 Rectangle rect = new Rectangle(100,100);
350 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
351 MockResizable resizable = new MockResizable(100,100);
352 vbox.getChildren().addAll(rect, biased, resizable);
353
354 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
355 assertEquals(100, vbox.prefWidth(-1), 0);
356 assertEquals(400, vbox.prefHeight(-1), 0);
357
358 vbox.autosize(); // 100 x 400
359 vbox.layout();
360 assertEquals(0, rect.getLayoutX(), 1e-100);
361 assertEquals(0, rect.getLayoutY(), 1e-100);
362 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
363 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
364 assertEquals(0, biased.getLayoutX(), 1e-100);
365 assertEquals(100, biased.getLayoutY(), 1e-100);
366 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
367 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
368 assertEquals(0, resizable.getLayoutX(), 1e-100);
369 assertEquals(300, resizable.getLayoutY(), 1e-100);
370 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
371 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
372 }
373
374 @Test public void testVBoxWithHorizontalContentBiasWithHorizontalShrinking() {
375 Rectangle rect = new Rectangle(100,100);
376 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
377 MockResizable resizable = new MockResizable(100,100);
378 vbox.getChildren().addAll(rect, biased, resizable);
379
380 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
381 assertEquals(600, vbox.prefHeight(50), 0);
382
383 vbox.resize(50, 600);
384 vbox.layout();
385 assertEquals(0, rect.getLayoutX(), 1e-100);
386 assertEquals(0, rect.getLayoutY(), 1e-100);
387 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
388 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
389 assertEquals(0, biased.getLayoutX(), 1e-100);
390 assertEquals(100, biased.getLayoutY(), 1e-100);
391 assertEquals(50, biased.getLayoutBounds().getWidth(), 1e-100);
392 assertEquals(400, biased.getLayoutBounds().getHeight(), 1e-100);
393 assertEquals(0, resizable.getLayoutX(), 1e-100);
394 assertEquals(500, resizable.getLayoutY(), 1e-100);
395 assertEquals(50, resizable.getLayoutBounds().getWidth(), 1e-100);
396 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
397 }
398
399 @Test public void testVBoxWithHorizontalContentBiasWithHorizontalGrowing() {
400 Rectangle rect = new Rectangle(100,100);
401 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
402 MockResizable resizable = new MockResizable(100,100);
403 vbox.getChildren().addAll(rect, biased, resizable);
404
405 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
406 assertEquals(267, vbox.prefHeight(300), 0);
407
408 vbox.resize(300, 267);
409 vbox.layout();
410 assertEquals(0, rect.getLayoutX(), 1e-100);
411 assertEquals(0, rect.getLayoutY(), 1e-100);
412 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
413 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
414 assertEquals(0, biased.getLayoutX(), 1e-100);
415 assertEquals(100, biased.getLayoutY(), 1e-100);
416 assertEquals(300, biased.getLayoutBounds().getWidth(), 1e-100);
417 assertEquals(67, biased.getLayoutBounds().getHeight(), 1e-100);
418 assertEquals(0, resizable.getLayoutX(), 1e-100);
419 assertEquals(167, resizable.getLayoutY(), 1e-100);
420 assertEquals(300, resizable.getLayoutBounds().getWidth(), 1e-100);
421 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
422 }
423
424 @Test public void testVBoxContentBiasVERTICALIfChildVERTICAL() {
425 Rectangle r = new Rectangle(100,100);
426 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
427 MockResizable child = new MockResizable(100,100);
428 vbox.getChildren().addAll(r, biased, child);
429
430 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
431 }
432
433 @Test public void testVBoxWithVerticalContentBiasAtPrefSize() {
434 Rectangle rect = new Rectangle(100,100);
435 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
436 MockResizable resizable = new MockResizable(100,100);
437 vbox.getChildren().addAll(rect, biased, resizable);
438
439 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
440 assertEquals(100, vbox.prefWidth(-1), 0);
441 assertEquals(400, vbox.prefHeight(-1), 0);
442
443 vbox.autosize(); // 100 x 400
444 vbox.layout();
445 assertEquals(0, rect.getLayoutX(), 1e-100);
446 assertEquals(0, rect.getLayoutY(), 1e-100);
447 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
448 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
449 assertEquals(0, biased.getLayoutX(), 1e-100);
450 assertEquals(100, biased.getLayoutY(), 1e-100);
451 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
452 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
453 assertEquals(0, resizable.getLayoutX(), 1e-100);
454 assertEquals(300, resizable.getLayoutY(), 1e-100);
455 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
456 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
457 }
458
459 @Test public void testVBoxWithVerticalContentBiasWithVerticalShrinking() {
460 Rectangle rect = new Rectangle(100,100);
461 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
462 MockResizable resizable = new MockResizable(100,100);
463 vbox.getChildren().addAll(rect, biased, resizable);
464
465 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
466 assertEquals(134, vbox.prefWidth(300), 0);
467
468 vbox.resize(134, 300);
469 vbox.layout();
470 assertEquals(0, rect.getLayoutX(), 1e-100);
471 assertEquals(0, rect.getLayoutY(), 1e-100);
472 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
473 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
474 assertEquals(0, biased.getLayoutX(), 1e-100);
475 assertEquals(100, biased.getLayoutY(), 1e-100);
476 assertEquals(134, biased.getLayoutBounds().getWidth(), 1e-100);
477 assertEquals(150, biased.getLayoutBounds().getHeight(), 1e-100);
478 assertEquals(0, resizable.getLayoutX(), 1e-100);
479 assertEquals(250, resizable.getLayoutY(), 1e-100);
480 assertEquals(134, resizable.getLayoutBounds().getWidth(), 1e-100);
481 assertEquals(50, resizable.getLayoutBounds().getHeight(), 1e-100);
482 }
483
484 @Test public void testVBoxWithVerticalContentBiasWithVerticalGrowingFillWidthFalse() {
485 vbox.setFillWidth(false);
486 Rectangle rect = new Rectangle(100,100);
487 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
488 MockResizable resizable = new MockResizable(100,100);
489 vbox.getChildren().addAll(rect, biased, resizable);
490
491 vbox.setVgrow(biased, Priority.ALWAYS);
492
493 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
494 assertEquals(100, vbox.prefWidth(500), 0);
495
496 vbox.resize(100, 500);
497 vbox.layout();
498 assertEquals(0, rect.getLayoutX(), 1e-100);
499 assertEquals(0, rect.getLayoutY(), 1e-100);
500 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
501 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
502 assertEquals(0, biased.getLayoutX(), 1e-100);
503 assertEquals(100, biased.getLayoutY(), 1e-100);
504 assertEquals(67, biased.getLayoutBounds().getWidth(), 1e-100);
505 assertEquals(300, biased.getLayoutBounds().getHeight(), 1e-100);
506 assertEquals(0, resizable.getLayoutX(), 1e-100);
507 assertEquals(400, resizable.getLayoutY(), 1e-100);
508 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
509 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
510 }
511
512 @Test public void testVBoxWithVerticalContentBiasWithVerticalGrowingFillWidthTrue() {
513 vbox.setFillWidth(true);
514 Rectangle rect = new Rectangle(100,100);
515 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
516 MockResizable resizable = new MockResizable(100,100);
517 vbox.getChildren().addAll(rect, biased, resizable);
518
519 vbox.setVgrow(biased, Priority.ALWAYS);
520
521 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
522 assertEquals(100, vbox.prefWidth(500), 0);
523
524 vbox.resize(100, 500);
525 vbox.layout();
526 assertEquals(0, rect.getLayoutX(), 1e-100);
527 assertEquals(0, rect.getLayoutY(), 1e-100);
528 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
529 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
530 assertEquals(0, biased.getLayoutX(), 1e-100);
531 assertEquals(100, biased.getLayoutY(), 1e-100);
532 assertEquals(67, biased.getLayoutBounds().getWidth(), 1e-100);
533 assertEquals(300, biased.getLayoutBounds().getHeight(), 1e-100);
534 assertEquals(0, resizable.getLayoutX(), 1e-100);
535 assertEquals(400, resizable.getLayoutY(), 1e-100);
536 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
537 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
538 }
539
540 @Test public void testVBoxContentBiasHORIZONTALIfChildHORIZONTALAndFillWidthTrue() {
541 vbox.setFillWidth(true);
542 Rectangle r = new Rectangle(100,100);
543 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
544 MockResizable child = new MockResizable(100,100);
545 vbox.getChildren().addAll(r, biased, child);
546
547 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
548 assertEquals(100, vbox.prefWidth(-1), 0);
549 assertEquals(400, vbox.prefHeight(100), 0);
550 assertEquals(300, vbox.prefHeight(200), 0);
551 }
552
553 // These test are no longer valid. If a content bias is set getContentBias()
554 // should never return null.
555 // @Test public void testVBoxContentBiasNullIfChildHORIZONTALAndFillWidthFalse() {
556 // vbox.setFillWidth(false);
557 // Rectangle r = new Rectangle(100,100);
558 // MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
559 // MockResizable child = new MockResizable(100,100);
560 // vbox.getChildren().addAll(r, biased, child);
561 //
562 // assertNull(vbox.getContentBias());
563 // assertEquals(100, vbox.prefWidth(-1), 0);
564 // assertEquals(400, vbox.prefHeight(-1), 0);
565 // assertEquals(400, vbox.prefHeight(200), 0);
566 // }
567 //
568 // @Test public void testVBoxContentBiasNullIfChildVERTICALAndFillWidthTrue() {
569 // vbox.setFillWidth(true);
570 // Rectangle r = new Rectangle(100,100);
571 // MockBiased biased = new MockBiased(Orientation.VERTICAL, 200, 100);
572 // MockResizable child = new MockResizable(100,100);
573 // vbox.getChildren().addAll(r, biased, child);
574 //
575 // assertNull(vbox.getContentBias());
576 // assertEquals(300, vbox.prefHeight(-1), 0);
577 // assertEquals(200, vbox.prefWidth(-1), 0);
578 // assertEquals(200, vbox.prefWidth(200), 0);
579 // }
580 //
581 // @Test public void testVBoxContentBiasNullIfChildVERTICALAndFillWidthFalse() {
582 // vbox.setFillWidth(false);
583 // Rectangle r = new Rectangle(100,100);
584 // MockBiased biased = new MockBiased(Orientation.VERTICAL, 200, 100);
585 // MockResizable child = new MockResizable(100,100);
586 // vbox.getChildren().addAll(r, biased, child);
587 //
588 // assertNull(vbox.getContentBias());
589 // assertEquals(300, vbox.prefHeight(-1), 0);
590 // assertEquals(200, vbox.prefWidth(-1), 0);
591 // assertEquals(200, vbox.prefWidth(200), 0);
592 // }
593
594 @Test public void testVBoxSetMarginConstraint() {
595 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
596
597 assertNull(VBox.getMargin(child1));
598
599 Insets margin = new Insets(10,20,30,40);
600 VBox.setMargin(child1, margin);
601 assertEquals(margin, VBox.getMargin(child1));
602
603 VBox.setMargin(child1, null);
604 assertNull(VBox.getMargin(child1));
605 }
606
607 @Test public void testVBoxMarginConstraint() {
608 VBox vbox = new VBox();
609 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
610 Rectangle child2 = new Rectangle(100, 100);
611 vbox.getChildren().addAll(child1, child2);
612
613 VBox.setMargin(child1, new Insets(10,20,30,40));
614
615 assertEquals(160, vbox.minWidth(-1), 1e-100);
616 assertEquals(340, vbox.minHeight(-1), 1e-100);
617 assertEquals(360, vbox.prefWidth(-1), 1e-100);
618 assertEquals(540, vbox.prefHeight(-1), 1e-100);
619
620 vbox.autosize();
621 vbox.layout();
622 assertEquals(40, child1.getLayoutX(), 1e-100);
623 assertEquals(10, child1.getLayoutY(), 1e-100);
624 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
625 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
626 assertEquals(0, child2.getLayoutX(), 1e-100);
627 assertEquals(440, child2.getLayoutY(), 1e-100);
628 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
629 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
630
631 vbox.resize(500,500);
639 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
640 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
641 }
642
643 @Test public void testVBoxSetVgrowConstraint() {
644 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
645
646 assertNull(VBox.getVgrow(child1));
647
648 VBox.setVgrow(child1, Priority.ALWAYS);
649 assertEquals(Priority.ALWAYS, VBox.getVgrow(child1));
650
651 VBox.setVgrow(child1, null);
652 assertNull(VBox.getVgrow(child1));
653 }
654
655 @Test public void testVBoxHgrowConstraint() {
656 VBox vbox = new VBox();
657 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
658 Rectangle child2 = new Rectangle(100, 100);
659 vbox.getChildren().addAll(child1, child2);
660
661 VBox.setVgrow(child1, Priority.ALWAYS);
662
663 assertEquals(100, vbox.minWidth(-1), 1e-100);
664 assertEquals(300, vbox.minHeight(-1), 1e-100);
665 assertEquals(300, vbox.prefWidth(-1), 1e-100);
666 assertEquals(500, vbox.prefHeight(-1), 1e-100);
667
668 vbox.autosize();
669 vbox.layout();
670 assertEquals(0, child1.getLayoutX(), 1e-100);
671 assertEquals(0, child1.getLayoutY(), 1e-100);
672 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
673 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
674 assertEquals(0, child2.getLayoutX(), 1e-100);
675 assertEquals(400, child2.getLayoutY(), 1e-100);
676 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
677 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
678
679 vbox.resize(500,600);
680 vbox.layout();
681 assertEquals(0, child1.getLayoutX(), 1e-100);
682 assertEquals(0, child1.getLayoutY(), 1e-100);
683 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
684 assertEquals(500, child1.getLayoutBounds().getHeight(), 1e-100);
685 assertEquals(0, child2.getLayoutX(), 1e-100);
686 assertEquals(500, child2.getLayoutY(), 1e-100);
687 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
688 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
689 }
690
691 @Test public void testVBoxWithHorizontalBiasedChild() {
692 VBox vbox = new VBox();
693
694 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100,100);
695 MockBiased biased2 = new MockBiased(Orientation.HORIZONTAL, 200, 200);
696 VBox.setVgrow(biased, Priority.ALWAYS);
697
698 vbox.getChildren().addAll(biased, biased2);
699
700 assertEquals(200, vbox.prefWidth(-1), 1e-100);
701 assertEquals(300, vbox.prefHeight(-1), 1e-100);
702
703 vbox.autosize();
704 vbox.layout();
705 assertEquals(0, biased.getLayoutX(), 1e-100);
706 assertEquals(0, biased.getLayoutY(), 1e-100);
707 assertEquals(200, biased.getLayoutBounds().getWidth(), 1e-100);
708 assertEquals(50, biased.getLayoutBounds().getHeight(), 1e-100);
709 assertEquals(0, biased2.getLayoutX(), 1e-100);
710 assertEquals(50, biased2.getLayoutY(), 1e-100);
711 assertEquals(200, biased2.getLayoutBounds().getWidth(), 1e-100);
712 assertEquals(200, biased2.getLayoutBounds().getHeight(), 1e-100);
713 }
714
715 @Test public void testVBoxWithVerticalBiasedChild() {
716 VBox vbox = new VBox();
717
718 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100,100);
719 MockBiased biased2 = new MockBiased(Orientation.VERTICAL, 200, 200);
720 VBox.setVgrow(biased, Priority.ALWAYS);
721
722 vbox.getChildren().addAll(biased, biased2);
723
724 assertEquals(200, vbox.prefWidth(-1), 1e-100);
725 assertEquals(300, vbox.prefHeight(-1), 1e-100);
726 assertEquals(200, vbox.minWidth(-1), 1e-100); // 1 with max height
727 assertEquals(20, vbox.minHeight(-1), 1e-100);
728 assertEquals(Math.ceil(Math.max(100 * 100 / 50.0, 200 * 200 / 150.0)), vbox.minWidth(200), 1e-100);
729
730 vbox.autosize();
731 vbox.layout();
732 assertEquals(0, biased.getLayoutX(), 1e-100);
733 assertEquals(0, biased.getLayoutY(), 1e-100);
734 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
735 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
736 assertEquals(0, biased2.getLayoutX(), 1e-100);
737 assertEquals(100, biased2.getLayoutY(), 1e-100);
738 assertEquals(200, biased2.getLayoutBounds().getWidth(), 1e-100);
739 assertEquals(200, biased2.getLayoutBounds().getHeight(), 1e-100);
740 }
741
742 @Test public void testMaxHeightHonoredWhenGrowing() {
743 MockRegion child = new MockRegion(10,10,100,100,300,300);
744 MockRegion child2 = new MockRegion(10,10,100,100,200,200);
745 VBox.setVgrow(child, Priority.ALWAYS);
746 VBox.setVgrow(child2, Priority.ALWAYS);
747
748 vbox.getChildren().addAll(child, child2);
749
750 vbox.resize(600,600);
751 vbox.layout();
752 assertEquals(300, child.getHeight(), 0);
753 assertEquals(0, child.getLayoutY(), 0);
754 assertEquals(200, child2.getHeight(), 0);
755 assertEquals(300, child2.getLayoutY(), 0);
756 }
757
758 @Test public void testLayoutWhenChildrenAreRemoved_RT19406() {
759 Rectangle child1 = new Rectangle(100,100);
760 Rectangle child2 = new Rectangle(100, 100);
761 vbox.getChildren().addAll(child1, child2);
762
763 assertEquals(100, vbox.prefWidth(-1), 1e-100);
764 assertEquals(200, vbox.prefHeight(-1), 1e-100);
765
766 vbox.resize(100, 200);
767 vbox.layout();
768 assertEquals(0, child1.getLayoutX(), 1e-100);
769 assertEquals(0, child1.getLayoutY(), 1e-100);
770 assertEquals(100, child1.getLayoutBounds().getWidth(), 1e-100);
771 assertEquals(100, child1.getLayoutBounds().getHeight(), 1e-100);
772 assertEquals(0, child2.getLayoutX(), 1e-100);
773 assertEquals(100, child2.getLayoutY(), 1e-100);
774 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
775 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
776
777 vbox.getChildren().remove(child2);
778 assertEquals(100, vbox.prefWidth(-1), 1e-100);
779 assertEquals(100, vbox.prefHeight(-1), 1e-100);
780 }
781 }
|
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package test.javafx.scene.layout;
27
28 import test.javafx.scene.layout.MockBiased;
29 import test.javafx.scene.layout.MockRegion;
30 import static org.junit.Assert.assertEquals;
31 import static org.junit.Assert.assertNull;
32 import static org.junit.Assert.assertTrue;
33 import javafx.geometry.Insets;
34 import javafx.geometry.Orientation;
35 import javafx.geometry.Pos;
36 import javafx.scene.ParentShim;
37 import javafx.scene.layout.Priority;
38 import javafx.scene.layout.VBox;
39 import javafx.scene.shape.Rectangle;
40
41 import org.junit.Before;
42 import org.junit.Test;
43
44
45 public class VBoxTest {
46 VBox vbox;
47
48 @Before public void setUp() {
49 this.vbox = new VBox();
50 }
51
52 @Test public void testVBoxDefaults() {
53 assertEquals(0, vbox.getSpacing(), 1e-100);
54 assertTrue(vbox.isFillWidth());
55 assertEquals(Pos.TOP_LEFT, vbox.getAlignment());
56 }
57
58 @Test public void testVBoxNulls() {
59 vbox.setAlignment(null);
60
61 // this musn't throw NPE
62 vbox.autosize();
63 vbox.layout();
64
65 assertNull(null, vbox.getAlignment());
66 assertNull(null, vbox.alignmentProperty().get());
67 }
68
69 @Test public void testSimpleVBox() {
70 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
71 Rectangle child2 = new Rectangle(100, 100);
72 ParentShim.getChildren(vbox).addAll(child1, child2);
73
74 assertEquals(100, vbox.minWidth(-1), 1e-100);
75 assertEquals(300, vbox.minHeight(-1), 1e-100);
76 assertEquals(300, vbox.prefWidth(-1), 1e-100);
77 assertEquals(500, vbox.prefHeight(-1), 1e-100);
78
79 vbox.autosize();
80 vbox.layout();
81 assertEquals(0, child1.getLayoutX(), 1e-100);
82 assertEquals(0, child1.getLayoutY(), 1e-100);
83 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
84 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
85 assertEquals(0, child2.getLayoutX(), 1e-100);
86 assertEquals(400, child2.getLayoutY(), 1e-100);
87 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
88 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
89
90 vbox.resize(500,500);
91 vbox.layout();
92 assertEquals(0, child1.getLayoutX(), 1e-100);
93 assertEquals(0, child1.getLayoutY(), 1e-100);
94 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
95 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
96 assertEquals(0, child2.getLayoutX(), 1e-100);
97 assertEquals(400, child2.getLayoutY(), 1e-100);
98 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
99 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
100 }
101
102 @Test public void testVBoxSpacing() {
103 vbox.setSpacing(10);
104 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
105 Rectangle child2 = new Rectangle(100, 100);
106 ParentShim.getChildren(vbox).addAll(child1, child2);
107
108 assertEquals(100, vbox.minWidth(-1), 1e-100);
109 assertEquals(310, vbox.minHeight(-1), 1e-100);
110 assertEquals(300, vbox.prefWidth(-1), 1e-100);
111 assertEquals(510, vbox.prefHeight(-1), 1e-100);
112
113 vbox.autosize();
114 vbox.layout();
115 assertEquals(0, child1.getLayoutX(), 1e-100);
116 assertEquals(0, child1.getLayoutY(), 1e-100);
117 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
118 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
119 assertEquals(0, child2.getLayoutX(), 1e-100);
120 assertEquals(410, child2.getLayoutY(), 1e-100);
121 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
122 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
123
124 vbox.resize(500,500);
125 vbox.layout();
126 assertEquals(0, child1.getLayoutX(), 1e-100);
127 assertEquals(0, child1.getLayoutY(), 1e-100);
128 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
129 assertEquals(390, child1.getLayoutBounds().getHeight(), 1e-100);
130 assertEquals(0, child2.getLayoutX(), 1e-100);
131 assertEquals(400, child2.getLayoutY(), 1e-100);
132 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
133 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
134 }
135
136 @Test public void testVBoxFillWidth() {
137 vbox.setFillWidth(false);
138 vbox.setAlignment(Pos.TOP_CENTER);
139 MockResizable child1 = new MockResizable(100,100, 200,300, 500,600);
140 MockResizable child2 = new MockResizable(100,100, 100, 400, 800, 800);
141 ParentShim.getChildren(vbox).addAll(child1, child2);
142
143 assertEquals(100, vbox.minWidth(-1), 1e-100);
144 assertEquals(200, vbox.minHeight(-1), 1e-100);
145 assertEquals(200, vbox.prefWidth(-1), 1e-100);
146 assertEquals(700, vbox.prefHeight(-1), 1e-100);
147
148 vbox.autosize();
149 vbox.layout();
150 assertEquals(0, child1.getLayoutX(), 1e-100);
151 assertEquals(0, child1.getLayoutY(), 1e-100);
152 assertEquals(200, child1.getLayoutBounds().getWidth(), 1e-100);
153 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
154 assertEquals(50, child2.getLayoutX(), 1e-100);
155 assertEquals(300, child2.getLayoutY(), 1e-100);
156 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
157 assertEquals(400, child2.getLayoutBounds().getHeight(), 1e-100);
158
159 vbox.resize(500,800);
160 vbox.layout();
161 assertEquals(150, child1.getLayoutX(), 1e-100);
162 assertEquals(0, child1.getLayoutY(), 1e-100);
163 assertEquals(200, child1.getLayoutBounds().getWidth(), 1e-100);
164 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
165 assertEquals(200, child2.getLayoutX(), 1e-100);
166 assertEquals(300, child2.getLayoutY(), 1e-100);
167 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
168 assertEquals(400, child2.getLayoutBounds().getHeight(), 1e-100);
169 }
170
171 @Test public void testVBoxAlignmentTopLeft() {
172 MockResizable child1 = new MockResizable(300,400);
173 Rectangle child2 = new Rectangle(100, 100);
174 ParentShim.getChildren(vbox).addAll(child1, child2);
175
176 vbox.setAlignment(Pos.TOP_LEFT);
177 vbox.resize(500,600);
178 vbox.layout();
179 assertEquals(0, child1.getLayoutX(), 1e-100);
180 assertEquals(0, child1.getLayoutY(), 1e-100);
181 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
182 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
183 assertEquals(0, child2.getLayoutX(), 1e-100);
184 assertEquals(400, child2.getLayoutY(), 1e-100);
185 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
186 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
187 }
188
189 @Test public void testVBoxAlignmentTopCenter() {
190 MockResizable child1 = new MockResizable(300,400);
191 Rectangle child2 = new Rectangle(100, 100);
192 ParentShim.getChildren(vbox).addAll(child1, child2);
193
194 vbox.setAlignment(Pos.TOP_CENTER);
195 vbox.resize(500,600);
196 vbox.layout();
197 assertEquals(0, child1.getLayoutX(), 1e-100);
198 assertEquals(0, child1.getLayoutY(), 1e-100);
199 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
200 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
201 assertEquals(200, child2.getLayoutX(), 1e-100);
202 assertEquals(400, child2.getLayoutY(), 1e-100);
203 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
204 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
205 }
206
207 @Test public void testVBoxAlignmentTopRight() {
208 MockResizable child1 = new MockResizable(300,400);
209 Rectangle child2 = new Rectangle(100, 100);
210 ParentShim.getChildren(vbox).addAll(child1, child2);
211
212 vbox.setAlignment(Pos.TOP_RIGHT);
213 vbox.resize(500,600);
214 vbox.layout();
215 assertEquals(0, child1.getLayoutX(), 1e-100);
216 assertEquals(0, child1.getLayoutY(), 1e-100);
217 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
218 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
219 assertEquals(400, child2.getLayoutX(), 1e-100);
220 assertEquals(400, child2.getLayoutY(), 1e-100);
221 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
222 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
223 }
224
225 @Test public void testVBoxAlignmentCenterLeft() {
226 MockResizable child1 = new MockResizable(300,400);
227 Rectangle child2 = new Rectangle(100, 100);
228 ParentShim.getChildren(vbox).addAll(child1, child2);
229
230 vbox.setAlignment(Pos.CENTER_LEFT);
231 vbox.resize(500,600);
232 vbox.layout();
233 assertEquals(0, child1.getLayoutX(), 1e-100);
234 assertEquals(50, child1.getLayoutY(), 1e-100);
235 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
236 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
237 assertEquals(0, child2.getLayoutX(), 1e-100);
238 assertEquals(450, child2.getLayoutY(), 1e-100);
239 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
240 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
241 }
242
243 @Test public void testVBoxAlignmentCenter() {
244 MockResizable child1 = new MockResizable(300,400);
245 Rectangle child2 = new Rectangle(100, 100);
246 ParentShim.getChildren(vbox).addAll(child1, child2);
247
248 vbox.setAlignment(Pos.CENTER);
249 vbox.resize(500,600);
250 vbox.layout();
251 assertEquals(0, child1.getLayoutX(), 1e-100);
252 assertEquals(50, child1.getLayoutY(), 1e-100);
253 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
254 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
255 assertEquals(200, child2.getLayoutX(), 1e-100);
256 assertEquals(450, child2.getLayoutY(), 1e-100);
257 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
258 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
259 }
260
261 @Test public void testVBoxAlignmentCenterRight() {
262 MockResizable child1 = new MockResizable(300,400);
263 Rectangle child2 = new Rectangle(100, 100);
264 ParentShim.getChildren(vbox).addAll(child1, child2);
265
266 vbox.setAlignment(Pos.CENTER_RIGHT);
267 vbox.resize(500,600);
268 vbox.layout();
269 assertEquals(0, child1.getLayoutX(), 1e-100);
270 assertEquals(50, child1.getLayoutY(), 1e-100);
271 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
272 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
273 assertEquals(400, child2.getLayoutX(), 1e-100);
274 assertEquals(450, child2.getLayoutY(), 1e-100);
275 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
276 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
277 }
278
279 @Test public void testVBoxAlignmentBottomLeft() {
280 MockResizable child1 = new MockResizable(300,400);
281 Rectangle child2 = new Rectangle(100, 100);
282 ParentShim.getChildren(vbox).addAll(child1, child2);
283
284 vbox.setAlignment(Pos.BOTTOM_LEFT);
285 vbox.resize(500,600);
286 vbox.layout();
287 assertEquals(0, child1.getLayoutX(), 1e-100);
288 assertEquals(100, child1.getLayoutY(), 1e-100);
289 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
290 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
291 assertEquals(0, child2.getLayoutX(), 1e-100);
292 assertEquals(500, child2.getLayoutY(), 1e-100);
293 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
294 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
295 }
296
297 @Test public void testVBoxAlignmentBottomCenter() {
298 MockResizable child1 = new MockResizable(300,400);
299 Rectangle child2 = new Rectangle(100, 100);
300 ParentShim.getChildren(vbox).addAll(child1, child2);
301
302 vbox.setAlignment(Pos.BOTTOM_CENTER);
303 vbox.resize(500,600);
304 vbox.layout();
305 assertEquals(0, child1.getLayoutX(), 1e-100);
306 assertEquals(100, child1.getLayoutY(), 1e-100);
307 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
308 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
309 assertEquals(200, child2.getLayoutX(), 1e-100);
310 assertEquals(500, child2.getLayoutY(), 1e-100);
311 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
312 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
313 }
314
315 @Test public void testVBoxAlignmentBottomRight() {
316 MockResizable child1 = new MockResizable(300,400);
317 Rectangle child2 = new Rectangle(100, 100);
318 ParentShim.getChildren(vbox).addAll(child1, child2);
319
320 vbox.setAlignment(Pos.BOTTOM_RIGHT);
321 vbox.resize(500,600);
322 vbox.layout();
323 assertEquals(0, child1.getLayoutX(), 1e-100);
324 assertEquals(100, child1.getLayoutY(), 1e-100);
325 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
326 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
327 assertEquals(400, child2.getLayoutX(), 1e-100);
328 assertEquals(500, child2.getLayoutY(), 1e-100);
329 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
330 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
331 }
332
333 @Test public void testVBoxContentBiasNullNoChildHasContentBias() {
334 Rectangle r = new Rectangle(100,100);
335 MockResizable child = new MockResizable(100,200);
336 ParentShim.getChildren(vbox).addAll(r, child);
337
338 assertNull(vbox.getContentBias());
339 assertEquals(100, vbox.prefWidth(-1), 0);
340 assertEquals(300, vbox.prefHeight(-1), 0);
341 assertEquals(300, vbox.prefHeight(200), 0);
342 }
343
344 @Test public void testVBoxContentBiasHORIZONTALifChildHORIZONTAL() {
345 Rectangle r = new Rectangle(100,100);
346 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
347 MockResizable child = new MockResizable(100,100);
348 ParentShim.getChildren(vbox).addAll(r, biased, child);
349
350 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
351 }
352
353 @Test public void testVBoxWithHorizontalContentBiasAtPrefSize() {
354 Rectangle rect = new Rectangle(100,100);
355 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
356 MockResizable resizable = new MockResizable(100,100);
357 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
358
359 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
360 assertEquals(100, vbox.prefWidth(-1), 0);
361 assertEquals(400, vbox.prefHeight(-1), 0);
362
363 vbox.autosize(); // 100 x 400
364 vbox.layout();
365 assertEquals(0, rect.getLayoutX(), 1e-100);
366 assertEquals(0, rect.getLayoutY(), 1e-100);
367 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
368 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
369 assertEquals(0, biased.getLayoutX(), 1e-100);
370 assertEquals(100, biased.getLayoutY(), 1e-100);
371 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
372 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
373 assertEquals(0, resizable.getLayoutX(), 1e-100);
374 assertEquals(300, resizable.getLayoutY(), 1e-100);
375 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
376 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
377 }
378
379 @Test public void testVBoxWithHorizontalContentBiasWithHorizontalShrinking() {
380 Rectangle rect = new Rectangle(100,100);
381 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
382 MockResizable resizable = new MockResizable(100,100);
383 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
384
385 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
386 assertEquals(600, vbox.prefHeight(50), 0);
387
388 vbox.resize(50, 600);
389 vbox.layout();
390 assertEquals(0, rect.getLayoutX(), 1e-100);
391 assertEquals(0, rect.getLayoutY(), 1e-100);
392 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
393 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
394 assertEquals(0, biased.getLayoutX(), 1e-100);
395 assertEquals(100, biased.getLayoutY(), 1e-100);
396 assertEquals(50, biased.getLayoutBounds().getWidth(), 1e-100);
397 assertEquals(400, biased.getLayoutBounds().getHeight(), 1e-100);
398 assertEquals(0, resizable.getLayoutX(), 1e-100);
399 assertEquals(500, resizable.getLayoutY(), 1e-100);
400 assertEquals(50, resizable.getLayoutBounds().getWidth(), 1e-100);
401 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
402 }
403
404 @Test public void testVBoxWithHorizontalContentBiasWithHorizontalGrowing() {
405 Rectangle rect = new Rectangle(100,100);
406 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
407 MockResizable resizable = new MockResizable(100,100);
408 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
409
410 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
411 assertEquals(267, vbox.prefHeight(300), 0);
412
413 vbox.resize(300, 267);
414 vbox.layout();
415 assertEquals(0, rect.getLayoutX(), 1e-100);
416 assertEquals(0, rect.getLayoutY(), 1e-100);
417 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
418 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
419 assertEquals(0, biased.getLayoutX(), 1e-100);
420 assertEquals(100, biased.getLayoutY(), 1e-100);
421 assertEquals(300, biased.getLayoutBounds().getWidth(), 1e-100);
422 assertEquals(67, biased.getLayoutBounds().getHeight(), 1e-100);
423 assertEquals(0, resizable.getLayoutX(), 1e-100);
424 assertEquals(167, resizable.getLayoutY(), 1e-100);
425 assertEquals(300, resizable.getLayoutBounds().getWidth(), 1e-100);
426 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
427 }
428
429 @Test public void testVBoxContentBiasVERTICALIfChildVERTICAL() {
430 Rectangle r = new Rectangle(100,100);
431 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
432 MockResizable child = new MockResizable(100,100);
433 ParentShim.getChildren(vbox).addAll(r, biased, child);
434
435 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
436 }
437
438 @Test public void testVBoxWithVerticalContentBiasAtPrefSize() {
439 Rectangle rect = new Rectangle(100,100);
440 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
441 MockResizable resizable = new MockResizable(100,100);
442 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
443
444 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
445 assertEquals(100, vbox.prefWidth(-1), 0);
446 assertEquals(400, vbox.prefHeight(-1), 0);
447
448 vbox.autosize(); // 100 x 400
449 vbox.layout();
450 assertEquals(0, rect.getLayoutX(), 1e-100);
451 assertEquals(0, rect.getLayoutY(), 1e-100);
452 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
453 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
454 assertEquals(0, biased.getLayoutX(), 1e-100);
455 assertEquals(100, biased.getLayoutY(), 1e-100);
456 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
457 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
458 assertEquals(0, resizable.getLayoutX(), 1e-100);
459 assertEquals(300, resizable.getLayoutY(), 1e-100);
460 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
461 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
462 }
463
464 @Test public void testVBoxWithVerticalContentBiasWithVerticalShrinking() {
465 Rectangle rect = new Rectangle(100,100);
466 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
467 MockResizable resizable = new MockResizable(100,100);
468 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
469
470 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
471 assertEquals(134, vbox.prefWidth(300), 0);
472
473 vbox.resize(134, 300);
474 vbox.layout();
475 assertEquals(0, rect.getLayoutX(), 1e-100);
476 assertEquals(0, rect.getLayoutY(), 1e-100);
477 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
478 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
479 assertEquals(0, biased.getLayoutX(), 1e-100);
480 assertEquals(100, biased.getLayoutY(), 1e-100);
481 assertEquals(134, biased.getLayoutBounds().getWidth(), 1e-100);
482 assertEquals(150, biased.getLayoutBounds().getHeight(), 1e-100);
483 assertEquals(0, resizable.getLayoutX(), 1e-100);
484 assertEquals(250, resizable.getLayoutY(), 1e-100);
485 assertEquals(134, resizable.getLayoutBounds().getWidth(), 1e-100);
486 assertEquals(50, resizable.getLayoutBounds().getHeight(), 1e-100);
487 }
488
489 @Test public void testVBoxWithVerticalContentBiasWithVerticalGrowingFillWidthFalse() {
490 vbox.setFillWidth(false);
491 Rectangle rect = new Rectangle(100,100);
492 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
493 MockResizable resizable = new MockResizable(100,100);
494 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
495
496 vbox.setVgrow(biased, Priority.ALWAYS);
497
498 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
499 assertEquals(100, vbox.prefWidth(500), 0);
500
501 vbox.resize(100, 500);
502 vbox.layout();
503 assertEquals(0, rect.getLayoutX(), 1e-100);
504 assertEquals(0, rect.getLayoutY(), 1e-100);
505 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
506 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
507 assertEquals(0, biased.getLayoutX(), 1e-100);
508 assertEquals(100, biased.getLayoutY(), 1e-100);
509 assertEquals(67, biased.getLayoutBounds().getWidth(), 1e-100);
510 assertEquals(300, biased.getLayoutBounds().getHeight(), 1e-100);
511 assertEquals(0, resizable.getLayoutX(), 1e-100);
512 assertEquals(400, resizable.getLayoutY(), 1e-100);
513 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
514 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
515 }
516
517 @Test public void testVBoxWithVerticalContentBiasWithVerticalGrowingFillWidthTrue() {
518 vbox.setFillWidth(true);
519 Rectangle rect = new Rectangle(100,100);
520 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
521 MockResizable resizable = new MockResizable(100,100);
522 ParentShim.getChildren(vbox).addAll(rect, biased, resizable);
523
524 vbox.setVgrow(biased, Priority.ALWAYS);
525
526 assertEquals(Orientation.VERTICAL, vbox.getContentBias());
527 assertEquals(100, vbox.prefWidth(500), 0);
528
529 vbox.resize(100, 500);
530 vbox.layout();
531 assertEquals(0, rect.getLayoutX(), 1e-100);
532 assertEquals(0, rect.getLayoutY(), 1e-100);
533 assertEquals(100, rect.getLayoutBounds().getWidth(), 1e-100);
534 assertEquals(100, rect.getLayoutBounds().getHeight(), 1e-100);
535 assertEquals(0, biased.getLayoutX(), 1e-100);
536 assertEquals(100, biased.getLayoutY(), 1e-100);
537 assertEquals(67, biased.getLayoutBounds().getWidth(), 1e-100);
538 assertEquals(300, biased.getLayoutBounds().getHeight(), 1e-100);
539 assertEquals(0, resizable.getLayoutX(), 1e-100);
540 assertEquals(400, resizable.getLayoutY(), 1e-100);
541 assertEquals(100, resizable.getLayoutBounds().getWidth(), 1e-100);
542 assertEquals(100, resizable.getLayoutBounds().getHeight(), 1e-100);
543 }
544
545 @Test public void testVBoxContentBiasHORIZONTALIfChildHORIZONTALAndFillWidthTrue() {
546 vbox.setFillWidth(true);
547 Rectangle r = new Rectangle(100,100);
548 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
549 MockResizable child = new MockResizable(100,100);
550 ParentShim.getChildren(vbox).addAll(r, biased, child);
551
552 assertEquals(Orientation.HORIZONTAL, vbox.getContentBias());
553 assertEquals(100, vbox.prefWidth(-1), 0);
554 assertEquals(400, vbox.prefHeight(100), 0);
555 assertEquals(300, vbox.prefHeight(200), 0);
556 }
557
558 // These test are no longer valid. If a content bias is set getContentBias()
559 // should never return null.
560 // @Test public void testVBoxContentBiasNullIfChildHORIZONTALAndFillWidthFalse() {
561 // vbox.setFillWidth(false);
562 // Rectangle r = new Rectangle(100,100);
563 // MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
564 // MockResizable child = new MockResizable(100,100);
565 // ParentShim.getChildren(vbox).addAll(r, biased, child);
566 //
567 // assertNull(vbox.getContentBias());
568 // assertEquals(100, vbox.prefWidth(-1), 0);
569 // assertEquals(400, vbox.prefHeight(-1), 0);
570 // assertEquals(400, vbox.prefHeight(200), 0);
571 // }
572 //
573 // @Test public void testVBoxContentBiasNullIfChildVERTICALAndFillWidthTrue() {
574 // vbox.setFillWidth(true);
575 // Rectangle r = new Rectangle(100,100);
576 // MockBiased biased = new MockBiased(Orientation.VERTICAL, 200, 100);
577 // MockResizable child = new MockResizable(100,100);
578 // ParentShim.getChildren(vbox).addAll(r, biased, child);
579 //
580 // assertNull(vbox.getContentBias());
581 // assertEquals(300, vbox.prefHeight(-1), 0);
582 // assertEquals(200, vbox.prefWidth(-1), 0);
583 // assertEquals(200, vbox.prefWidth(200), 0);
584 // }
585 //
586 // @Test public void testVBoxContentBiasNullIfChildVERTICALAndFillWidthFalse() {
587 // vbox.setFillWidth(false);
588 // Rectangle r = new Rectangle(100,100);
589 // MockBiased biased = new MockBiased(Orientation.VERTICAL, 200, 100);
590 // MockResizable child = new MockResizable(100,100);
591 // ParentShim.getChildren(vbox).addAll(r, biased, child);
592 //
593 // assertNull(vbox.getContentBias());
594 // assertEquals(300, vbox.prefHeight(-1), 0);
595 // assertEquals(200, vbox.prefWidth(-1), 0);
596 // assertEquals(200, vbox.prefWidth(200), 0);
597 // }
598
599 @Test public void testVBoxSetMarginConstraint() {
600 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
601
602 assertNull(VBox.getMargin(child1));
603
604 Insets margin = new Insets(10,20,30,40);
605 VBox.setMargin(child1, margin);
606 assertEquals(margin, VBox.getMargin(child1));
607
608 VBox.setMargin(child1, null);
609 assertNull(VBox.getMargin(child1));
610 }
611
612 @Test public void testVBoxMarginConstraint() {
613 VBox vbox = new VBox();
614 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
615 Rectangle child2 = new Rectangle(100, 100);
616 ParentShim.getChildren(vbox).addAll(child1, child2);
617
618 VBox.setMargin(child1, new Insets(10,20,30,40));
619
620 assertEquals(160, vbox.minWidth(-1), 1e-100);
621 assertEquals(340, vbox.minHeight(-1), 1e-100);
622 assertEquals(360, vbox.prefWidth(-1), 1e-100);
623 assertEquals(540, vbox.prefHeight(-1), 1e-100);
624
625 vbox.autosize();
626 vbox.layout();
627 assertEquals(40, child1.getLayoutX(), 1e-100);
628 assertEquals(10, child1.getLayoutY(), 1e-100);
629 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
630 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
631 assertEquals(0, child2.getLayoutX(), 1e-100);
632 assertEquals(440, child2.getLayoutY(), 1e-100);
633 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
634 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
635
636 vbox.resize(500,500);
644 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
645 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
646 }
647
648 @Test public void testVBoxSetVgrowConstraint() {
649 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
650
651 assertNull(VBox.getVgrow(child1));
652
653 VBox.setVgrow(child1, Priority.ALWAYS);
654 assertEquals(Priority.ALWAYS, VBox.getVgrow(child1));
655
656 VBox.setVgrow(child1, null);
657 assertNull(VBox.getVgrow(child1));
658 }
659
660 @Test public void testVBoxHgrowConstraint() {
661 VBox vbox = new VBox();
662 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
663 Rectangle child2 = new Rectangle(100, 100);
664 ParentShim.getChildren(vbox).addAll(child1, child2);
665
666 VBox.setVgrow(child1, Priority.ALWAYS);
667
668 assertEquals(100, vbox.minWidth(-1), 1e-100);
669 assertEquals(300, vbox.minHeight(-1), 1e-100);
670 assertEquals(300, vbox.prefWidth(-1), 1e-100);
671 assertEquals(500, vbox.prefHeight(-1), 1e-100);
672
673 vbox.autosize();
674 vbox.layout();
675 assertEquals(0, child1.getLayoutX(), 1e-100);
676 assertEquals(0, child1.getLayoutY(), 1e-100);
677 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
678 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
679 assertEquals(0, child2.getLayoutX(), 1e-100);
680 assertEquals(400, child2.getLayoutY(), 1e-100);
681 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
682 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
683
684 vbox.resize(500,600);
685 vbox.layout();
686 assertEquals(0, child1.getLayoutX(), 1e-100);
687 assertEquals(0, child1.getLayoutY(), 1e-100);
688 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
689 assertEquals(500, child1.getLayoutBounds().getHeight(), 1e-100);
690 assertEquals(0, child2.getLayoutX(), 1e-100);
691 assertEquals(500, child2.getLayoutY(), 1e-100);
692 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
693 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
694 }
695
696 @Test public void testVBoxWithHorizontalBiasedChild() {
697 VBox vbox = new VBox();
698
699 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100,100);
700 MockBiased biased2 = new MockBiased(Orientation.HORIZONTAL, 200, 200);
701 VBox.setVgrow(biased, Priority.ALWAYS);
702
703 ParentShim.getChildren(vbox).addAll(biased, biased2);
704
705 assertEquals(200, vbox.prefWidth(-1), 1e-100);
706 assertEquals(300, vbox.prefHeight(-1), 1e-100);
707
708 vbox.autosize();
709 vbox.layout();
710 assertEquals(0, biased.getLayoutX(), 1e-100);
711 assertEquals(0, biased.getLayoutY(), 1e-100);
712 assertEquals(200, biased.getLayoutBounds().getWidth(), 1e-100);
713 assertEquals(50, biased.getLayoutBounds().getHeight(), 1e-100);
714 assertEquals(0, biased2.getLayoutX(), 1e-100);
715 assertEquals(50, biased2.getLayoutY(), 1e-100);
716 assertEquals(200, biased2.getLayoutBounds().getWidth(), 1e-100);
717 assertEquals(200, biased2.getLayoutBounds().getHeight(), 1e-100);
718 }
719
720 @Test public void testVBoxWithVerticalBiasedChild() {
721 VBox vbox = new VBox();
722
723 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100,100);
724 MockBiased biased2 = new MockBiased(Orientation.VERTICAL, 200, 200);
725 VBox.setVgrow(biased, Priority.ALWAYS);
726
727 ParentShim.getChildren(vbox).addAll(biased, biased2);
728
729 assertEquals(200, vbox.prefWidth(-1), 1e-100);
730 assertEquals(300, vbox.prefHeight(-1), 1e-100);
731 assertEquals(200, vbox.minWidth(-1), 1e-100); // 1 with max height
732 assertEquals(20, vbox.minHeight(-1), 1e-100);
733 assertEquals(Math.ceil(Math.max(100 * 100 / 50.0, 200 * 200 / 150.0)), vbox.minWidth(200), 1e-100);
734
735 vbox.autosize();
736 vbox.layout();
737 assertEquals(0, biased.getLayoutX(), 1e-100);
738 assertEquals(0, biased.getLayoutY(), 1e-100);
739 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
740 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
741 assertEquals(0, biased2.getLayoutX(), 1e-100);
742 assertEquals(100, biased2.getLayoutY(), 1e-100);
743 assertEquals(200, biased2.getLayoutBounds().getWidth(), 1e-100);
744 assertEquals(200, biased2.getLayoutBounds().getHeight(), 1e-100);
745 }
746
747 @Test public void testMaxHeightHonoredWhenGrowing() {
748 MockRegion child = new MockRegion(10,10,100,100,300,300);
749 MockRegion child2 = new MockRegion(10,10,100,100,200,200);
750 VBox.setVgrow(child, Priority.ALWAYS);
751 VBox.setVgrow(child2, Priority.ALWAYS);
752
753 ParentShim.getChildren(vbox).addAll(child, child2);
754
755 vbox.resize(600,600);
756 vbox.layout();
757 assertEquals(300, child.getHeight(), 0);
758 assertEquals(0, child.getLayoutY(), 0);
759 assertEquals(200, child2.getHeight(), 0);
760 assertEquals(300, child2.getLayoutY(), 0);
761 }
762
763 @Test public void testLayoutWhenChildrenAreRemoved_RT19406() {
764 Rectangle child1 = new Rectangle(100,100);
765 Rectangle child2 = new Rectangle(100, 100);
766 ParentShim.getChildren(vbox).addAll(child1, child2);
767
768 assertEquals(100, vbox.prefWidth(-1), 1e-100);
769 assertEquals(200, vbox.prefHeight(-1), 1e-100);
770
771 vbox.resize(100, 200);
772 vbox.layout();
773 assertEquals(0, child1.getLayoutX(), 1e-100);
774 assertEquals(0, child1.getLayoutY(), 1e-100);
775 assertEquals(100, child1.getLayoutBounds().getWidth(), 1e-100);
776 assertEquals(100, child1.getLayoutBounds().getHeight(), 1e-100);
777 assertEquals(0, child2.getLayoutX(), 1e-100);
778 assertEquals(100, child2.getLayoutY(), 1e-100);
779 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
780 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
781
782 ParentShim.getChildren(vbox).remove(child2);
783 assertEquals(100, vbox.prefWidth(-1), 1e-100);
784 assertEquals(100, vbox.prefHeight(-1), 1e-100);
785 }
786 }
|