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 javafx.geometry.Insets;
31 import javafx.geometry.Orientation;
32 import javafx.geometry.Pos;
33 import javafx.scene.shape.Rectangle;
34
35 import org.junit.Before;
36 import org.junit.Test;
37
38
39 public class StackPaneTest {
40 StackPane stack;
41
42 @Before public void setUp() {
43 this.stack = new StackPane();
44 }
45
46 @Test public void testStackPaneDefaults() {
47 assertEquals(Pos.CENTER, stack.getAlignment());
48 }
49
50 @Test public void testStackPaneNulls() {
51 stack.setAlignment(null);
52
53 // this musn't throw NPE
54 stack.autosize();
55 stack.layout();
56
57 assertNull(null, stack.getAlignment());
58 assertNull(null, stack.alignmentProperty().get());
59 }
60
61 @Test public void testSimpleStackPane() {
62 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
63 Rectangle child2 = new Rectangle(100, 100);
64 stack.getChildren().addAll(child1, child2);
65
66 assertEquals(100, stack.minWidth(-1), 1e-100);
67 assertEquals(200, stack.minHeight(-1), 1e-100);
68 assertEquals(300, stack.prefWidth(-1), 1e-100);
69 assertEquals(400, stack.prefHeight(-1), 1e-100);
70
71 stack.autosize();
72 stack.layout();
73 assertEquals(0, child1.getLayoutX(), 1e-100);
74 assertEquals(0, child1.getLayoutY(), 1e-100);
75 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
76 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
77 assertEquals(100, child2.getLayoutX(), 1e-100);
78 assertEquals(150, child2.getLayoutY(), 1e-100);
79 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
80 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
81
82 stack.resize(500,500);
83 stack.layout();
84 assertEquals(0, child1.getLayoutX(), 1e-100);
85 assertEquals(0, child1.getLayoutY(), 1e-100);
86 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
87 assertEquals(500, child1.getLayoutBounds().getHeight(), 1e-100);
88 assertEquals(200, child2.getLayoutX(), 1e-100);
89 assertEquals(200, child2.getLayoutY(), 1e-100);
90 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
91 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
92 }
93
94 @Test public void testStackPaneAlignmentTopLeft() {
95 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
96 Rectangle child2 = new Rectangle(100, 100);
97 stack.getChildren().addAll(child1, child2);
98
99 stack.setAlignment(Pos.TOP_LEFT);
100 stack.autosize();
101 stack.layout();
102 assertEquals(0, child1.getLayoutX(), 1e-100);
103 assertEquals(0, child1.getLayoutY(), 1e-100);
104 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
105 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
106 assertEquals(0, child2.getLayoutX(), 1e-100);
107 assertEquals(0, child2.getLayoutY(), 1e-100);
108 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
109 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
110 }
111
112 @Test public void testStackPaneAlignmentTopCenter() {
113 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
114 Rectangle child2 = new Rectangle(100, 100);
115 stack.getChildren().addAll(child1, child2);
116
117 stack.setAlignment(Pos.TOP_CENTER);
118 stack.autosize();
119 stack.layout();
120 assertEquals(0, child1.getLayoutX(), 1e-100);
121 assertEquals(0, child1.getLayoutY(), 1e-100);
122 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
123 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
124 assertEquals(100, child2.getLayoutX(), 1e-100);
125 assertEquals(0, child2.getLayoutY(), 1e-100);
126 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
127 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
128 }
129
130 @Test public void testStackPaneAlignmentTopRight() {
131 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
132 Rectangle child2 = new Rectangle(100, 100);
133 stack.getChildren().addAll(child1, child2);
134
135 stack.setAlignment(Pos.TOP_RIGHT);
136 stack.autosize();
137 stack.layout();
138 assertEquals(0, child1.getLayoutX(), 1e-100);
139 assertEquals(0, child1.getLayoutY(), 1e-100);
140 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
141 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
142 assertEquals(200, child2.getLayoutX(), 1e-100);
143 assertEquals(0, child2.getLayoutY(), 1e-100);
144 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
145 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
146 }
147
148 @Test public void testStackPaneAlignmentCenterLeft() {
149 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
150 Rectangle child2 = new Rectangle(100, 100);
151 stack.getChildren().addAll(child1, child2);
152
153 stack.setAlignment(Pos.CENTER_LEFT);
154 stack.autosize();
155 stack.layout();
156 assertEquals(0, child1.getLayoutX(), 1e-100);
157 assertEquals(0, child1.getLayoutY(), 1e-100);
158 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
159 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
160 assertEquals(0, child2.getLayoutX(), 1e-100);
161 assertEquals(150, child2.getLayoutY(), 1e-100);
162 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
163 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
164 }
165
166 @Test public void testStackPaneAlignmentCenter() {
167 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
168 Rectangle child2 = new Rectangle(100, 100);
169 stack.getChildren().addAll(child1, child2);
170
171 stack.setAlignment(Pos.CENTER);
172 stack.autosize();
173 stack.layout();
174 assertEquals(0, child1.getLayoutX(), 1e-100);
175 assertEquals(0, child1.getLayoutY(), 1e-100);
176 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
177 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
178 assertEquals(100, child2.getLayoutX(), 1e-100);
179 assertEquals(150, 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 testStackPaneAlignmentCenterRight() {
185 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
186 Rectangle child2 = new Rectangle(100, 100);
187 stack.getChildren().addAll(child1, child2);
188
189 stack.setAlignment(Pos.CENTER_RIGHT);
190 stack.autosize();
191 stack.layout();
192 assertEquals(0, child1.getLayoutX(), 1e-100);
193 assertEquals(0, child1.getLayoutY(), 1e-100);
194 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
195 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
196 assertEquals(200, child2.getLayoutX(), 1e-100);
197 assertEquals(150, 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 testStackPaneAlignmentBottomLeft() {
203 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
204 Rectangle child2 = new Rectangle(100, 100);
205 stack.getChildren().addAll(child1, child2);
206
207 stack.setAlignment(Pos.BOTTOM_LEFT);
208 stack.autosize();
209 stack.layout();
210 assertEquals(0, child1.getLayoutX(), 1e-100);
211 assertEquals(0, child1.getLayoutY(), 1e-100);
212 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
213 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
214 assertEquals(0, child2.getLayoutX(), 1e-100);
215 assertEquals(300, 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 testStackPaneAlignmentBottomCenter() {
221 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
222 Rectangle child2 = new Rectangle(100, 100);
223 stack.getChildren().addAll(child1, child2);
224
225 stack.setAlignment(Pos.BOTTOM_CENTER);
226 stack.autosize();
227 stack.layout();
228 assertEquals(0, child1.getLayoutX(), 1e-100);
229 assertEquals(0, child1.getLayoutY(), 1e-100);
230 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
231 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
232 assertEquals(100, child2.getLayoutX(), 1e-100);
233 assertEquals(300, 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 testStackPaneAlignmentBottomRight() {
239 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
240 Rectangle child2 = new Rectangle(100, 100);
241 stack.getChildren().addAll(child1, child2);
242
243 stack.setAlignment(Pos.BOTTOM_RIGHT);
244 stack.autosize();
245 stack.layout();
246 assertEquals(0, child1.getLayoutX(), 1e-100);
247 assertEquals(0, child1.getLayoutY(), 1e-100);
248 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
249 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
250 assertEquals(200, child2.getLayoutX(), 1e-100);
251 assertEquals(300, 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 testStackPaneAlignmentBaselineLeft() {
257 MockResizable child1 = new MockResizable(300,300);
258 Rectangle child2 = new Rectangle(100, 100);
259 stack.getChildren().addAll(child1, child2);
260
261 stack.setAlignment(Pos.BASELINE_LEFT);
262 stack.autosize();
263 stack.layout();
264 assertEquals(0, child1.getLayoutX(), 1e-100);
265 assertEquals(0, child1.getLayoutY(), 1e-100);
266 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
267 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
268 assertEquals(0, child2.getLayoutX(), 1e-100);
269 assertEquals(190, 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 testStackPaneAlignmentBaselineCenter() {
275 MockResizable child1 = new MockResizable(300,300);
276 Rectangle child2 = new Rectangle(100, 100);
277 stack.getChildren().addAll(child1, child2);
278
279 stack.setAlignment(Pos.BASELINE_CENTER);
280 stack.autosize();
281 stack.layout();
282 assertEquals(0, child1.getLayoutX(), 1e-100);
283 assertEquals(0, child1.getLayoutY(), 1e-100);
284 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
285 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
286 assertEquals(100, child2.getLayoutX(), 1e-100);
287 assertEquals(190, 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 testStackPaneAlignmentBaselineRight() {
293 MockResizable child1 = new MockResizable(300,300);
294 Rectangle child2 = new Rectangle(100, 100);
295 stack.getChildren().addAll(child1, child2);
296
297 stack.setAlignment(Pos.BASELINE_RIGHT);
298 stack.autosize();
299 stack.layout();
300 assertEquals(0, child1.getLayoutX(), 1e-100);
301 assertEquals(0, child1.getLayoutY(), 1e-100);
302 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
303 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
304 assertEquals(200, child2.getLayoutX(), 1e-100);
305 assertEquals(190, 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 testStackPaneAlignmentBaselineLeftComputed() {
311 MockResizable child1 = new MockResizable(300,300) {
312 @Override public double getBaselineOffset() {
313 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
314 }
315 };
316 Rectangle child2 = new Rectangle(100, 100);
317 stack.getChildren().addAll(child1, child2);
318
319 stack.setAlignment(Pos.BASELINE_LEFT);
320 stack.autosize();
321 stack.layout();
322 assertEquals(0, child1.getLayoutX(), 1e-100);
323 assertEquals(0, child1.getLayoutY(), 1e-100);
324 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
325 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
326 assertEquals(0, child2.getLayoutX(), 1e-100);
327 assertEquals(200, child2.getLayoutY(), 1e-100);
328 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
329 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
330 }
331
332 @Test public void testStackPaneAlignmentBaselineCenterComputed() {
333 MockResizable child1 = new MockResizable(300,300) {
334 @Override public double getBaselineOffset() {
335 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
336 }
337 };
338 Rectangle child2 = new Rectangle(100, 100);
339 stack.getChildren().addAll(child1, child2);
340
341 stack.setAlignment(Pos.BASELINE_CENTER);
342 stack.autosize();
343 stack.layout();
344 assertEquals(0, child1.getLayoutX(), 1e-100);
345 assertEquals(0, child1.getLayoutY(), 1e-100);
346 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
347 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
348 assertEquals(100, child2.getLayoutX(), 1e-100);
349 assertEquals(200, child2.getLayoutY(), 1e-100);
350 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
351 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
352 }
353
354 @Test public void testStackPaneAlignmentBaselineRightComputed() {
355 MockResizable child1 = new MockResizable(300,300) {
356 @Override public double getBaselineOffset() {
357 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
358 }
359 }; Rectangle child2 = new Rectangle(100, 100);
360 stack.getChildren().addAll(child1, child2);
361
362 stack.setAlignment(Pos.BASELINE_RIGHT);
363 stack.autosize();
364 stack.layout();
365 assertEquals(0, child1.getLayoutX(), 1e-100);
366 assertEquals(0, child1.getLayoutY(), 1e-100);
367 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
368 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
369 assertEquals(200, child2.getLayoutX(), 1e-100);
370 assertEquals(200, child2.getLayoutY(), 1e-100);
371 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
372 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
373 }
374
375 @Test public void testStackPaneContentBiasNullNoChildHasContentBias() {
376 Rectangle r = new Rectangle(100,100);
377 MockResizable child = new MockResizable(100,200);
378 stack.getChildren().addAll(r, child);
379
380 assertNull(stack.getContentBias());
381 }
382
383 @Test public void testStackPaneContentBiasHORIZONTALIfChildHORIZONTAL() {
384 Rectangle r = new Rectangle(100,100);
385 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
386 MockResizable child = new MockResizable(100,100);
387 stack.getChildren().addAll(r, biased, child);
388
389 assertEquals(Orientation.HORIZONTAL, stack.getContentBias());
390 assertEquals(100, stack.prefWidth(-1), 0);
391 assertEquals(200, stack.prefHeight(100), 0);
392 assertEquals(100, stack.prefHeight(200), 0);
393 }
394
395 @Test public void testStackPaneContentBiasVERTICALIfChildVERTICAL() {
396 Rectangle r = new Rectangle(100,100);
397 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
398 MockResizable child = new MockResizable(100,100);
399 stack.getChildren().addAll(r, biased, child);
400
401 assertEquals(Orientation.VERTICAL, stack.getContentBias());
402 assertEquals(200, stack.prefHeight(-1), 0);
403 assertEquals(100, stack.prefWidth(200), 0);
404 assertEquals(200, stack.prefWidth(100), 0);
405 }
406
407 @Test public void testStackPaneSetMarginConstraint() {
408 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
409
410 assertNull(StackPane.getMargin(child1));
411
412 Insets margin = new Insets(10,20,30,40);
413 StackPane.setMargin(child1, margin);
414 assertEquals(margin, StackPane.getMargin(child1));
415
416 StackPane.setMargin(child1, null);
417 assertNull(StackPane.getMargin(child1));
418 }
419
420 @Test public void testStackPaneMarginConstraint() {
421 StackPane stack = new StackPane();
422 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
423 Rectangle child2 = new Rectangle(100, 100);
424 stack.getChildren().addAll(child1, child2);
425
426 StackPane.setMargin(child1, new Insets(10,20,30,40));
427
428 assertEquals(160, stack.minWidth(-1), 1e-100);
429 assertEquals(240, stack.minHeight(-1), 1e-100);
430 assertEquals(360, stack.prefWidth(-1), 1e-100);
431 assertEquals(440, stack.prefHeight(-1), 1e-100);
432
433 stack.autosize();
434 stack.layout();
435 assertEquals(40, child1.getLayoutX(), 1e-100);
436 assertEquals(10, child1.getLayoutY(), 1e-100);
437 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
438 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
439 assertEquals(130, child2.getLayoutX(), 1e-100);
440 assertEquals(170, child2.getLayoutY(), 1e-100);
441 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
442 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
443
444 stack.resize(500,500);
452 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
453 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
454 }
455
456 @Test public void testStackPaneSetAlignmentConstraint() {
457 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
458
459 assertNull(StackPane.getAlignment(child1));
460
461 StackPane.setAlignment(child1, Pos.TOP_LEFT);
462 assertEquals(Pos.TOP_LEFT, StackPane.getAlignment(child1));
463
464 StackPane.setAlignment(child1, null);
465 assertNull(StackPane.getAlignment(child1));
466 }
467
468 @Test public void testStackPaneAlignmentConstraint() {
469 StackPane stack = new StackPane();
470 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
471 Rectangle child2 = new Rectangle(100, 100);
472 stack.getChildren().addAll(child1, child2);
473
474 StackPane.setAlignment(child2, Pos.TOP_LEFT);
475
476 assertEquals(100, stack.minWidth(-1), 1e-100);
477 assertEquals(200, stack.minHeight(-1), 1e-100);
478 assertEquals(300, stack.prefWidth(-1), 1e-100);
479 assertEquals(400, stack.prefHeight(-1), 1e-100);
480
481 stack.autosize();
482 stack.layout();
483 assertEquals(0, child1.getLayoutX(), 1e-100);
484 assertEquals(0, child1.getLayoutY(), 1e-100);
485 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
486 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
487 assertEquals(0, child2.getLayoutX(), 1e-100);
488 assertEquals(0, child2.getLayoutY(), 1e-100);
489 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
490 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
491
492 stack.resize(500,500);
493 stack.layout();
494 assertEquals(0, child1.getLayoutX(), 1e-100);
495 assertEquals(0, child1.getLayoutY(), 1e-100);
496 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
497 assertEquals(500, child1.getLayoutBounds().getHeight(), 1e-100);
498 assertEquals(0, child2.getLayoutX(), 1e-100);
499 assertEquals(0, child2.getLayoutY(), 1e-100);
500 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
501 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
502 }
503
504 @Test public void testStackPaneWithHorizontalBiasedChild() {
505 StackPane stack = new StackPane();
506
507 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100,100);
508
509 stack.getChildren().add(biased);
510
511 assertEquals(100, stack.prefWidth(-1), 1e-100);
512 assertEquals(100, stack.prefHeight(-1), 1e-100);
513
514 stack.autosize();
515 stack.layout();
516 assertEquals(0, biased.getLayoutX(), 1e-100);
517 assertEquals(0, biased.getLayoutY(), 1e-100);
518 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
519 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
520
521 stack.resize(200, 200);
522 stack.layout();
523 assertEquals(0, biased.getLayoutX(), 1e-100);
524 assertEquals(75, biased.getLayoutY(), 1e-100);
525 assertEquals(200, biased.getLayoutBounds().getWidth(), 1e-100);
526 assertEquals(50, biased.getLayoutBounds().getHeight(), 1e-100);
527 }
528
529 @Test public void testStackPaneWithVerticalBiasedChild() {
530 StackPane stack = new StackPane();
531
532 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100,100);
533
534 stack.getChildren().add(biased);
535
536 assertEquals(100, stack.prefWidth(-1), 1e-100);
537 assertEquals(100, stack.prefHeight(-1), 1e-100);
538
539 stack.autosize();
540 stack.layout();
541 assertEquals(0, biased.getLayoutX(), 1e-100);
542 assertEquals(0, biased.getLayoutY(), 1e-100);
543 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
544 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
545
546 stack.resize(200, 200);
547 stack.layout();
548 assertEquals(75, biased.getLayoutX(), 1e-100);
549 assertEquals(0, biased.getLayoutY(), 1e-100);
550 assertEquals(50, biased.getLayoutBounds().getWidth(), 1e-100);
551 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
552 }
553
554 }
|
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 static org.junit.Assert.assertEquals;
30 import static org.junit.Assert.assertNull;
31 import javafx.geometry.Insets;
32 import javafx.geometry.Orientation;
33 import javafx.geometry.Pos;
34 import javafx.scene.ParentShim;
35 import javafx.scene.layout.StackPane;
36 import javafx.scene.shape.Rectangle;
37
38 import org.junit.Before;
39 import org.junit.Test;
40
41
42 public class StackPaneTest {
43 StackPane stack;
44
45 @Before public void setUp() {
46 this.stack = new StackPane();
47 }
48
49 @Test public void testStackPaneDefaults() {
50 assertEquals(Pos.CENTER, stack.getAlignment());
51 }
52
53 @Test public void testStackPaneNulls() {
54 stack.setAlignment(null);
55
56 // this musn't throw NPE
57 stack.autosize();
58 stack.layout();
59
60 assertNull(null, stack.getAlignment());
61 assertNull(null, stack.alignmentProperty().get());
62 }
63
64 @Test public void testSimpleStackPane() {
65 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
66 Rectangle child2 = new Rectangle(100, 100);
67 ParentShim.getChildren(stack).addAll(child1, child2);
68
69 assertEquals(100, stack.minWidth(-1), 1e-100);
70 assertEquals(200, stack.minHeight(-1), 1e-100);
71 assertEquals(300, stack.prefWidth(-1), 1e-100);
72 assertEquals(400, stack.prefHeight(-1), 1e-100);
73
74 stack.autosize();
75 stack.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(100, child2.getLayoutX(), 1e-100);
81 assertEquals(150, child2.getLayoutY(), 1e-100);
82 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
83 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
84
85 stack.resize(500,500);
86 stack.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(500, child1.getLayoutBounds().getHeight(), 1e-100);
91 assertEquals(200, child2.getLayoutX(), 1e-100);
92 assertEquals(200, 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 testStackPaneAlignmentTopLeft() {
98 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
99 Rectangle child2 = new Rectangle(100, 100);
100 ParentShim.getChildren(stack).addAll(child1, child2);
101
102 stack.setAlignment(Pos.TOP_LEFT);
103 stack.autosize();
104 stack.layout();
105 assertEquals(0, child1.getLayoutX(), 1e-100);
106 assertEquals(0, child1.getLayoutY(), 1e-100);
107 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
108 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
109 assertEquals(0, child2.getLayoutX(), 1e-100);
110 assertEquals(0, child2.getLayoutY(), 1e-100);
111 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
112 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
113 }
114
115 @Test public void testStackPaneAlignmentTopCenter() {
116 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
117 Rectangle child2 = new Rectangle(100, 100);
118 ParentShim.getChildren(stack).addAll(child1, child2);
119
120 stack.setAlignment(Pos.TOP_CENTER);
121 stack.autosize();
122 stack.layout();
123 assertEquals(0, child1.getLayoutX(), 1e-100);
124 assertEquals(0, child1.getLayoutY(), 1e-100);
125 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
126 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
127 assertEquals(100, child2.getLayoutX(), 1e-100);
128 assertEquals(0, child2.getLayoutY(), 1e-100);
129 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
130 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
131 }
132
133 @Test public void testStackPaneAlignmentTopRight() {
134 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
135 Rectangle child2 = new Rectangle(100, 100);
136 ParentShim.getChildren(stack).addAll(child1, child2);
137
138 stack.setAlignment(Pos.TOP_RIGHT);
139 stack.autosize();
140 stack.layout();
141 assertEquals(0, child1.getLayoutX(), 1e-100);
142 assertEquals(0, child1.getLayoutY(), 1e-100);
143 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
144 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
145 assertEquals(200, child2.getLayoutX(), 1e-100);
146 assertEquals(0, child2.getLayoutY(), 1e-100);
147 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
148 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
149 }
150
151 @Test public void testStackPaneAlignmentCenterLeft() {
152 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
153 Rectangle child2 = new Rectangle(100, 100);
154 ParentShim.getChildren(stack).addAll(child1, child2);
155
156 stack.setAlignment(Pos.CENTER_LEFT);
157 stack.autosize();
158 stack.layout();
159 assertEquals(0, child1.getLayoutX(), 1e-100);
160 assertEquals(0, child1.getLayoutY(), 1e-100);
161 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
162 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
163 assertEquals(0, child2.getLayoutX(), 1e-100);
164 assertEquals(150, child2.getLayoutY(), 1e-100);
165 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
166 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
167 }
168
169 @Test public void testStackPaneAlignmentCenter() {
170 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
171 Rectangle child2 = new Rectangle(100, 100);
172 ParentShim.getChildren(stack).addAll(child1, child2);
173
174 stack.setAlignment(Pos.CENTER);
175 stack.autosize();
176 stack.layout();
177 assertEquals(0, child1.getLayoutX(), 1e-100);
178 assertEquals(0, child1.getLayoutY(), 1e-100);
179 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
180 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
181 assertEquals(100, child2.getLayoutX(), 1e-100);
182 assertEquals(150, child2.getLayoutY(), 1e-100);
183 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
184 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
185 }
186
187 @Test public void testStackPaneAlignmentCenterRight() {
188 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
189 Rectangle child2 = new Rectangle(100, 100);
190 ParentShim.getChildren(stack).addAll(child1, child2);
191
192 stack.setAlignment(Pos.CENTER_RIGHT);
193 stack.autosize();
194 stack.layout();
195 assertEquals(0, child1.getLayoutX(), 1e-100);
196 assertEquals(0, child1.getLayoutY(), 1e-100);
197 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
198 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
199 assertEquals(200, child2.getLayoutX(), 1e-100);
200 assertEquals(150, child2.getLayoutY(), 1e-100);
201 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
202 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
203 }
204
205 @Test public void testStackPaneAlignmentBottomLeft() {
206 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
207 Rectangle child2 = new Rectangle(100, 100);
208 ParentShim.getChildren(stack).addAll(child1, child2);
209
210 stack.setAlignment(Pos.BOTTOM_LEFT);
211 stack.autosize();
212 stack.layout();
213 assertEquals(0, child1.getLayoutX(), 1e-100);
214 assertEquals(0, child1.getLayoutY(), 1e-100);
215 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
216 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
217 assertEquals(0, child2.getLayoutX(), 1e-100);
218 assertEquals(300, child2.getLayoutY(), 1e-100);
219 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
220 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
221 }
222
223 @Test public void testStackPaneAlignmentBottomCenter() {
224 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
225 Rectangle child2 = new Rectangle(100, 100);
226 ParentShim.getChildren(stack).addAll(child1, child2);
227
228 stack.setAlignment(Pos.BOTTOM_CENTER);
229 stack.autosize();
230 stack.layout();
231 assertEquals(0, child1.getLayoutX(), 1e-100);
232 assertEquals(0, child1.getLayoutY(), 1e-100);
233 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
234 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
235 assertEquals(100, child2.getLayoutX(), 1e-100);
236 assertEquals(300, child2.getLayoutY(), 1e-100);
237 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
238 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
239 }
240
241 @Test public void testStackPaneAlignmentBottomRight() {
242 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
243 Rectangle child2 = new Rectangle(100, 100);
244 ParentShim.getChildren(stack).addAll(child1, child2);
245
246 stack.setAlignment(Pos.BOTTOM_RIGHT);
247 stack.autosize();
248 stack.layout();
249 assertEquals(0, child1.getLayoutX(), 1e-100);
250 assertEquals(0, child1.getLayoutY(), 1e-100);
251 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
252 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
253 assertEquals(200, child2.getLayoutX(), 1e-100);
254 assertEquals(300, child2.getLayoutY(), 1e-100);
255 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
256 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
257 }
258
259 @Test public void testStackPaneAlignmentBaselineLeft() {
260 MockResizable child1 = new MockResizable(300,300);
261 Rectangle child2 = new Rectangle(100, 100);
262 ParentShim.getChildren(stack).addAll(child1, child2);
263
264 stack.setAlignment(Pos.BASELINE_LEFT);
265 stack.autosize();
266 stack.layout();
267 assertEquals(0, child1.getLayoutX(), 1e-100);
268 assertEquals(0, child1.getLayoutY(), 1e-100);
269 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
270 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
271 assertEquals(0, child2.getLayoutX(), 1e-100);
272 assertEquals(190, child2.getLayoutY(), 1e-100);
273 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
274 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
275 }
276
277 @Test public void testStackPaneAlignmentBaselineCenter() {
278 MockResizable child1 = new MockResizable(300,300);
279 Rectangle child2 = new Rectangle(100, 100);
280 ParentShim.getChildren(stack).addAll(child1, child2);
281
282 stack.setAlignment(Pos.BASELINE_CENTER);
283 stack.autosize();
284 stack.layout();
285 assertEquals(0, child1.getLayoutX(), 1e-100);
286 assertEquals(0, child1.getLayoutY(), 1e-100);
287 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
288 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
289 assertEquals(100, child2.getLayoutX(), 1e-100);
290 assertEquals(190, child2.getLayoutY(), 1e-100);
291 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
292 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
293 }
294
295 @Test public void testStackPaneAlignmentBaselineRight() {
296 MockResizable child1 = new MockResizable(300,300);
297 Rectangle child2 = new Rectangle(100, 100);
298 ParentShim.getChildren(stack).addAll(child1, child2);
299
300 stack.setAlignment(Pos.BASELINE_RIGHT);
301 stack.autosize();
302 stack.layout();
303 assertEquals(0, child1.getLayoutX(), 1e-100);
304 assertEquals(0, child1.getLayoutY(), 1e-100);
305 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
306 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
307 assertEquals(200, child2.getLayoutX(), 1e-100);
308 assertEquals(190, child2.getLayoutY(), 1e-100);
309 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
310 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
311 }
312
313 @Test public void testStackPaneAlignmentBaselineLeftComputed() {
314 MockResizable child1 = new MockResizable(300,300) {
315 @Override public double getBaselineOffset() {
316 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
317 }
318 };
319 Rectangle child2 = new Rectangle(100, 100);
320 ParentShim.getChildren(stack).addAll(child1, child2);
321
322 stack.setAlignment(Pos.BASELINE_LEFT);
323 stack.autosize();
324 stack.layout();
325 assertEquals(0, child1.getLayoutX(), 1e-100);
326 assertEquals(0, child1.getLayoutY(), 1e-100);
327 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
328 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
329 assertEquals(0, child2.getLayoutX(), 1e-100);
330 assertEquals(200, child2.getLayoutY(), 1e-100);
331 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
332 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
333 }
334
335 @Test public void testStackPaneAlignmentBaselineCenterComputed() {
336 MockResizable child1 = new MockResizable(300,300) {
337 @Override public double getBaselineOffset() {
338 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
339 }
340 };
341 Rectangle child2 = new Rectangle(100, 100);
342 ParentShim.getChildren(stack).addAll(child1, child2);
343
344 stack.setAlignment(Pos.BASELINE_CENTER);
345 stack.autosize();
346 stack.layout();
347 assertEquals(0, child1.getLayoutX(), 1e-100);
348 assertEquals(0, child1.getLayoutY(), 1e-100);
349 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
350 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
351 assertEquals(100, child2.getLayoutX(), 1e-100);
352 assertEquals(200, child2.getLayoutY(), 1e-100);
353 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
354 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
355 }
356
357 @Test public void testStackPaneAlignmentBaselineRightComputed() {
358 MockResizable child1 = new MockResizable(300,300) {
359 @Override public double getBaselineOffset() {
360 return BASELINE_OFFSET_SAME_AS_HEIGHT; // should be prefHeight
361 }
362 }; Rectangle child2 = new Rectangle(100, 100);
363 ParentShim.getChildren(stack).addAll(child1, child2);
364
365 stack.setAlignment(Pos.BASELINE_RIGHT);
366 stack.autosize();
367 stack.layout();
368 assertEquals(0, child1.getLayoutX(), 1e-100);
369 assertEquals(0, child1.getLayoutY(), 1e-100);
370 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
371 assertEquals(300, child1.getLayoutBounds().getHeight(), 1e-100);
372 assertEquals(200, child2.getLayoutX(), 1e-100);
373 assertEquals(200, child2.getLayoutY(), 1e-100);
374 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
375 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
376 }
377
378 @Test public void testStackPaneContentBiasNullNoChildHasContentBias() {
379 Rectangle r = new Rectangle(100,100);
380 MockResizable child = new MockResizable(100,200);
381 ParentShim.getChildren(stack).addAll(r, child);
382
383 assertNull(stack.getContentBias());
384 }
385
386 @Test public void testStackPaneContentBiasHORIZONTALIfChildHORIZONTAL() {
387 Rectangle r = new Rectangle(100,100);
388 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100, 200);
389 MockResizable child = new MockResizable(100,100);
390 ParentShim.getChildren(stack).addAll(r, biased, child);
391
392 assertEquals(Orientation.HORIZONTAL, stack.getContentBias());
393 assertEquals(100, stack.prefWidth(-1), 0);
394 assertEquals(200, stack.prefHeight(100), 0);
395 assertEquals(100, stack.prefHeight(200), 0);
396 }
397
398 @Test public void testStackPaneContentBiasVERTICALIfChildVERTICAL() {
399 Rectangle r = new Rectangle(100,100);
400 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100, 200);
401 MockResizable child = new MockResizable(100,100);
402 ParentShim.getChildren(stack).addAll(r, biased, child);
403
404 assertEquals(Orientation.VERTICAL, stack.getContentBias());
405 assertEquals(200, stack.prefHeight(-1), 0);
406 assertEquals(100, stack.prefWidth(200), 0);
407 assertEquals(200, stack.prefWidth(100), 0);
408 }
409
410 @Test public void testStackPaneSetMarginConstraint() {
411 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
412
413 assertNull(StackPane.getMargin(child1));
414
415 Insets margin = new Insets(10,20,30,40);
416 StackPane.setMargin(child1, margin);
417 assertEquals(margin, StackPane.getMargin(child1));
418
419 StackPane.setMargin(child1, null);
420 assertNull(StackPane.getMargin(child1));
421 }
422
423 @Test public void testStackPaneMarginConstraint() {
424 StackPane stack = new StackPane();
425 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
426 Rectangle child2 = new Rectangle(100, 100);
427 ParentShim.getChildren(stack).addAll(child1, child2);
428
429 StackPane.setMargin(child1, new Insets(10,20,30,40));
430
431 assertEquals(160, stack.minWidth(-1), 1e-100);
432 assertEquals(240, stack.minHeight(-1), 1e-100);
433 assertEquals(360, stack.prefWidth(-1), 1e-100);
434 assertEquals(440, stack.prefHeight(-1), 1e-100);
435
436 stack.autosize();
437 stack.layout();
438 assertEquals(40, child1.getLayoutX(), 1e-100);
439 assertEquals(10, child1.getLayoutY(), 1e-100);
440 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
441 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
442 assertEquals(130, child2.getLayoutX(), 1e-100);
443 assertEquals(170, child2.getLayoutY(), 1e-100);
444 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
445 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
446
447 stack.resize(500,500);
455 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
456 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
457 }
458
459 @Test public void testStackPaneSetAlignmentConstraint() {
460 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
461
462 assertNull(StackPane.getAlignment(child1));
463
464 StackPane.setAlignment(child1, Pos.TOP_LEFT);
465 assertEquals(Pos.TOP_LEFT, StackPane.getAlignment(child1));
466
467 StackPane.setAlignment(child1, null);
468 assertNull(StackPane.getAlignment(child1));
469 }
470
471 @Test public void testStackPaneAlignmentConstraint() {
472 StackPane stack = new StackPane();
473 MockResizable child1 = new MockResizable(100,200, 300,400, 500,600);
474 Rectangle child2 = new Rectangle(100, 100);
475 ParentShim.getChildren(stack).addAll(child1, child2);
476
477 StackPane.setAlignment(child2, Pos.TOP_LEFT);
478
479 assertEquals(100, stack.minWidth(-1), 1e-100);
480 assertEquals(200, stack.minHeight(-1), 1e-100);
481 assertEquals(300, stack.prefWidth(-1), 1e-100);
482 assertEquals(400, stack.prefHeight(-1), 1e-100);
483
484 stack.autosize();
485 stack.layout();
486 assertEquals(0, child1.getLayoutX(), 1e-100);
487 assertEquals(0, child1.getLayoutY(), 1e-100);
488 assertEquals(300, child1.getLayoutBounds().getWidth(), 1e-100);
489 assertEquals(400, child1.getLayoutBounds().getHeight(), 1e-100);
490 assertEquals(0, child2.getLayoutX(), 1e-100);
491 assertEquals(0, child2.getLayoutY(), 1e-100);
492 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
493 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
494
495 stack.resize(500,500);
496 stack.layout();
497 assertEquals(0, child1.getLayoutX(), 1e-100);
498 assertEquals(0, child1.getLayoutY(), 1e-100);
499 assertEquals(500, child1.getLayoutBounds().getWidth(), 1e-100);
500 assertEquals(500, child1.getLayoutBounds().getHeight(), 1e-100);
501 assertEquals(0, child2.getLayoutX(), 1e-100);
502 assertEquals(0, child2.getLayoutY(), 1e-100);
503 assertEquals(100, child2.getLayoutBounds().getWidth(), 1e-100);
504 assertEquals(100, child2.getLayoutBounds().getHeight(), 1e-100);
505 }
506
507 @Test public void testStackPaneWithHorizontalBiasedChild() {
508 StackPane stack = new StackPane();
509
510 MockBiased biased = new MockBiased(Orientation.HORIZONTAL, 100,100);
511
512 ParentShim.getChildren(stack).add(biased);
513
514 assertEquals(100, stack.prefWidth(-1), 1e-100);
515 assertEquals(100, stack.prefHeight(-1), 1e-100);
516
517 stack.autosize();
518 stack.layout();
519 assertEquals(0, biased.getLayoutX(), 1e-100);
520 assertEquals(0, biased.getLayoutY(), 1e-100);
521 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
522 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
523
524 stack.resize(200, 200);
525 stack.layout();
526 assertEquals(0, biased.getLayoutX(), 1e-100);
527 assertEquals(75, biased.getLayoutY(), 1e-100);
528 assertEquals(200, biased.getLayoutBounds().getWidth(), 1e-100);
529 assertEquals(50, biased.getLayoutBounds().getHeight(), 1e-100);
530 }
531
532 @Test public void testStackPaneWithVerticalBiasedChild() {
533 StackPane stack = new StackPane();
534
535 MockBiased biased = new MockBiased(Orientation.VERTICAL, 100,100);
536
537 ParentShim.getChildren(stack).add(biased);
538
539 assertEquals(100, stack.prefWidth(-1), 1e-100);
540 assertEquals(100, stack.prefHeight(-1), 1e-100);
541
542 stack.autosize();
543 stack.layout();
544 assertEquals(0, biased.getLayoutX(), 1e-100);
545 assertEquals(0, biased.getLayoutY(), 1e-100);
546 assertEquals(100, biased.getLayoutBounds().getWidth(), 1e-100);
547 assertEquals(100, biased.getLayoutBounds().getHeight(), 1e-100);
548
549 stack.resize(200, 200);
550 stack.layout();
551 assertEquals(75, biased.getLayoutX(), 1e-100);
552 assertEquals(0, biased.getLayoutY(), 1e-100);
553 assertEquals(50, biased.getLayoutBounds().getWidth(), 1e-100);
554 assertEquals(200, biased.getLayoutBounds().getHeight(), 1e-100);
555 }
556
557 }
|