1 /*
2 * Copyright (c) 2010, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
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 com.sun.javafx.util.Utils;
29 import javafx.beans.InvalidationListener;
30 import javafx.beans.property.BooleanProperty;
31 import javafx.beans.property.DoubleProperty;
32 import javafx.beans.property.ObjectProperty;
33 import javafx.beans.property.ReadOnlyDoubleProperty;
34 import javafx.beans.property.ReadOnlyDoubleWrapper;
35 import javafx.beans.property.ReadOnlyObjectProperty;
36 import javafx.beans.property.ReadOnlyObjectPropertyBase;
37 import javafx.beans.value.ChangeListener;
38 import javafx.collections.ObservableList;
39 import javafx.css.CssMetaData;
40 import javafx.css.Styleable;
41 import javafx.css.StyleableBooleanProperty;
42 import javafx.css.StyleableDoubleProperty;
43 import javafx.css.StyleableObjectProperty;
44 import javafx.css.StyleableProperty;
45 import javafx.geometry.BoundingBox;
46 import javafx.geometry.Bounds;
47 import javafx.geometry.HPos;
48 import javafx.geometry.Insets;
49 import javafx.geometry.Orientation;
50 import javafx.geometry.VPos;
51 import javafx.scene.Node;
52 import javafx.scene.Parent;
53 import javafx.scene.image.Image;
54 import javafx.scene.shape.Shape;
55 import javafx.scene.shape.StrokeLineCap;
56 import javafx.scene.shape.StrokeLineJoin;
57 import javafx.scene.shape.StrokeType;
58 import javafx.util.Callback;
59 import java.util.ArrayList;
60 import java.util.Collections;
61 import java.util.Arrays;
62 import java.util.List;
63 import java.util.function.Function;
64 import com.sun.javafx.util.Logging;
65 import com.sun.javafx.util.TempState;
66 import com.sun.javafx.binding.ExpressionHelper;
67 import com.sun.javafx.css.converters.BooleanConverter;
68 import com.sun.javafx.css.converters.InsetsConverter;
69 import com.sun.javafx.css.converters.ShapeConverter;
70 import com.sun.javafx.css.converters.SizeConverter;
71 import com.sun.javafx.geom.BaseBounds;
72 import com.sun.javafx.geom.PickRay;
73 import com.sun.javafx.geom.RectBounds;
74 import com.sun.javafx.geom.Vec2d;
75 import com.sun.javafx.geom.transform.BaseTransform;
76 import com.sun.javafx.scene.DirtyBits;
77 import com.sun.javafx.scene.input.PickResultChooser;
78 import com.sun.javafx.sg.prism.NGNode;
79 import com.sun.javafx.sg.prism.NGRegion;
80 import com.sun.javafx.tk.Toolkit;
81 import sun.util.logging.PlatformLogger;
82 import sun.util.logging.PlatformLogger.Level;
83
84 /**
85 * Region is the base class for all JavaFX Node-based UI Controls, and all layout containers.
86 * It is a resizable Parent node which can be styled from CSS. It can have multiple backgrounds
87 * and borders. It is designed to support as much of the CSS3 specification for backgrounds
88 * and borders as is relevant to JavaFX.
89 * The full specification is available at <a href="http://www.w3.org/TR/2012/CR-css3-background-20120724/">the W3C</a>.
90 * <p/>
91 * Every Region has its layout bounds, which are specified to be (0, 0, width, height). A Region might draw outside
92 * these bounds. The content area of a Region is the area which is occupied for the layout of its children.
93 * This area is, by default, the same as the layout bounds of the Region, but can be modified by either the
94 * properties of a border (either with BorderStrokes or BorderImages), and by padding. The padding can
95 * be negative, such that the content area of a Region might extend beyond the layout bounds of the Region,
96 * but does not affect the layout bounds.
97 * <p/>
98 * A Region has a Background, and a Border, although either or both of these might be empty. The Background
99 * of a Region is made up of zero or more BackgroundFills, and zero or more BackgroundImages. Likewise, the
100 * border of a Region is defined by its Border, which is made up of zero or more BorderStrokes and
101 * zero or more BorderImages. All BackgroundFills are drawn first, followed by BackgroundImages, BorderStrokes,
102 * and finally BorderImages. The content is drawn above all backgrounds and borders. If a BorderImage is
103 * present (and loaded all images properly), then no BorderStrokes are actually drawn, although they are
104 * considered for computing the position of the content area (see the stroke width property of a BorderStroke).
105 * These semantics are in line with the CSS 3 specification. The purpose of these semantics are to allow an
106 * application to specify a fallback BorderStroke to be displayed in the case that an ImageStroke fails to
107 * download or load.
108 * <p/>
109 * By default a Region appears as a Rectangle. A BackgroundFill radii might cause the Rectangle to appear rounded.
110 * This affects not only making the visuals look like a rounded rectangle, but it also causes the picking behavior
111 * of the Region to act like a rounded rectangle, such that locations outside the corner radii are ignored. A
112 * Region can be made to use any shape, however, by specifing the {@code shape} property. If a shape is specified,
113 * then all BackgroundFills, BackgroundImages, and BorderStrokes will be applied to the shape. BorderImages are
114 * not used for Regions which have a shape specified.
115 * <p/>
116 * A Region with a shape
117 * <p/>
118 * Although the layout bounds of a Region are not influenced by any Border or Background, the content area
119 * insets and the picking area of the Region are. The {@code insets} of the Region define the distance
120 * between the edge of the layout bounds and the edge of the content area. For example, if the Region
121 * layout bounds are (x=0, y=0, width=200, height=100), and the insets are (top=10, right=20, bottom=30, left=40),
122 * then the content area bounds will be (x=40, y=10, width=140, height=60). A Region subclass which is laying
123 * out its children should compute and honor these content area bounds.
124 * <p/>
125 * By default a Region inherits the layout behavior of its superclass, {@link Parent},
126 * which means that it will resize any resizable child nodes to their preferred
127 * size, but will not reposition them. If an application needs more specific
128 * layout behavior, then it should use one of the Region subclasses:
129 * {@link StackPane}, {@link HBox}, {@link VBox}, {@link TilePane}, {@link FlowPane},
130 * {@link BorderPane}, {@link GridPane}, or {@link AnchorPane}.
131 * <p/>
132 * To implement a more custom layout, a Region subclass must override
133 * {@link #computePrefWidth(double) computePrefWidth}, {@link #computePrefHeight(double) computePrefHeight}, and
134 * {@link #layoutChildren() layoutChildren}. Note that {@link #layoutChildren() layoutChildren} is called automatically
135 * by the scene graph while executing a top-down layout pass and it should not be invoked directly by the
136 * region subclass.
137 * <p/>
138 * Region subclasses which layout their children will position nodes by setting
139 * {@link #setLayoutX(double) layoutX}/{@link #setLayoutY(double) layoutY} and do not alter
140 * {@link #setTranslateX(double) translateX}/{@link #setTranslateY(double) translateY}, which are reserved for
141 * adjustments and animation.
142 * @since JavaFX 2.0
143 */
144 public class
145 Region extends Parent {
146
147 /**
148 * Sentinel value which can be passed to a region's
149 * {@link #setMinWidth(double) setMinWidth},
150 * {@link #setMinHeight(double) setMinHeight},
151 * {@link #setMaxWidth(double) setMaxWidth} or
152 * {@link #setMaxHeight(double) setMaxHeight}
153 * methods to indicate that the preferred dimension should be used for that max and/or min constraint.
154 */
155 public static final double USE_PREF_SIZE = Double.NEGATIVE_INFINITY;
156
157 /**
158 * Sentinel value which can be passed to a region's
159 * {@link #setMinWidth(double) setMinWidth},
160 * {@link #setMinHeight(double) setMinHeight},
161 * {@link #setPrefWidth(double) setPrefWidth},
162 * {@link #setPrefHeight(double) setPrefHeight},
163 * {@link #setMaxWidth(double) setMaxWidth},
164 * {@link #setMaxHeight(double) setMaxHeight} methods
165 * to reset the region's size constraint back to it's intrinsic size returned
166 * by {@link #computeMinWidth(double) computeMinWidth}, {@link #computeMinHeight(double) computeMinHeight},
167 * {@link #computePrefWidth(double) computePrefWidth}, {@link #computePrefHeight(double) computePrefHeight},
168 * {@link #computeMaxWidth(double) computeMaxWidth}, or {@link #computeMaxHeight(double) computeMaxHeight}.
169 */
170 public static final double USE_COMPUTED_SIZE = -1;
171
172 static Vec2d TEMP_VEC2D = new Vec2d();
173
174 /***************************************************************************
175 * *
176 * Static convenience methods for layout *
177 * *
178 **************************************************************************/
179
180 /**
181 * Computes the value based on the given min and max values. We encode in this
182 * method the logic surrounding various edge cases, such as when the min is
183 * specified as greater than the max, or the max less than the min, or a pref
184 * value that exceeds either the max or min in their extremes.
185 * <p/>
186 * If the min is greater than the max, then we want to make sure the returned
187 * value is the min. In other words, in such a case, the min becomes the only
188 * acceptable return value.
189 * <p/>
190 * If the min and max values are well ordered, and the pref is less than the min
191 * then the min is returned. Likewise, if the values are well ordered and the
192 * pref is greater than the max, then the max is returned. If the pref lies
193 * between the min and the max, then the pref is returned.
194 *
195 *
196 * @param min The minimum bound
197 * @param pref The value to be clamped between the min and max
198 * @param max the maximum bound
199 * @return the size bounded by min, pref, and max.
200 */
201 static double boundedSize(double min, double pref, double max) {
202 double a = pref >= min ? pref : min;
203 double b = min >= max ? min : max;
204 return a <= b ? a : b;
205 }
206
207 double adjustWidthByMargin(double width, Insets margin) {
208 if (margin == null || margin == Insets.EMPTY) {
209 return width;
210 }
211 boolean isSnapToPixel = isSnapToPixel();
212 return width - snapSpace(margin.getLeft(), isSnapToPixel) - snapSpace(margin.getRight(), isSnapToPixel);
213 }
214
215 double adjustHeightByMargin(double height, Insets margin) {
216 if (margin == null || margin == Insets.EMPTY) {
217 return height;
218 }
219 boolean isSnapToPixel = isSnapToPixel();
220 return height - snapSpace(margin.getTop(), isSnapToPixel) - snapSpace(margin.getBottom(), isSnapToPixel);
221 }
222
223 /**
224 * If snapToPixel is true, then the value is rounded using Math.round. Otherwise,
225 * the value is simply returned. This method will surely be JIT'd under normal
226 * circumstances, however on an interpreter it would be better to inline this
227 * method. However the use of Math.round here, and Math.ceil in snapSize is
228 * not obvious, and so for code maintenance this logic is pulled out into
229 * a separate method.
230 *
231 * @param value The value that needs to be snapped
232 * @param snapToPixel Whether to snap to pixel
233 * @return value either as passed in or rounded based on snapToPixel
234 */
235 private static double snapSpace(double value, boolean snapToPixel) {
236 return snapToPixel ? Math.round(value) : value;
237 }
238
239 /**
240 * If snapToPixel is true, then the value is ceil'd using Math.ceil. Otherwise,
241 * the value is simply returned.
242 *
243 * @param value The value that needs to be snapped
244 * @param snapToPixel Whether to snap to pixel
245 * @return value either as passed in or ceil'd based on snapToPixel
246 */
247 private static double snapSize(double value, boolean snapToPixel) {
248 return snapToPixel ? Math.ceil(value) : value;
249 }
250
251 /**
252 * If snapToPixel is true, then the value is rounded using Math.round. Otherwise,
253 * the value is simply returned.
254 *
255 * @param value The value that needs to be snapped
256 * @param snapToPixel Whether to snap to pixel
257 * @return value either as passed in or rounded based on snapToPixel
258 */
259 private static double snapPosition(double value, boolean snapToPixel) {
260 return snapToPixel ? Math.round(value) : value;
261 }
262
263 private static double snapPortion(double value, boolean snapToPixel) {
264 if (snapToPixel) {
265 return value == 0 ? 0 :(value > 0 ? Math.max(1, Math.floor(value)) : Math.min(-1, Math.ceil(value)));
266 }
267 return value;
268 }
269
270 double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
271 Function<Integer, Double> positionToWidth,
272 double areaHeight, boolean fillHeight) {
273 return getAreaBaselineOffset(children, margins, positionToWidth, areaHeight, fillHeight, isSnapToPixel());
274 }
275
276 static double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
277 Function<Integer, Double> positionToWidth,
278 double areaHeight, boolean fillHeight, boolean snapToPixel) {
279 return getAreaBaselineOffset(children, margins, positionToWidth, areaHeight, fillHeight,
280 getMinBaselineComplement(children), snapToPixel);
281 }
282
283 double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
284 Function<Integer, Double> positionToWidth,
285 double areaHeight, final boolean fillHeight, double minComplement) {
286 return getAreaBaselineOffset(children, margins, positionToWidth, areaHeight, fillHeight, minComplement, isSnapToPixel());
287 }
288
289 static double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
290 Function<Integer, Double> positionToWidth,
291 double areaHeight, final boolean fillHeight, double minComplement, boolean snapToPixel) {
292 return getAreaBaselineOffset(children, margins, positionToWidth, areaHeight, t -> fillHeight, minComplement, snapToPixel);
293 }
294
295 double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
296 Function<Integer, Double> positionToWidth,
297 double areaHeight, Function<Integer, Boolean> fillHeight, double minComplement) {
298 return getAreaBaselineOffset(children, margins, positionToWidth, areaHeight, fillHeight, minComplement, isSnapToPixel());
299 }
300
301 /**
302 * Returns the baseline offset of provided children, with respect to the minimum complement, computed
303 * by {@link #getMinBaselineComplement(java.util.List)} from the same set of children.
304 * @param children the children with baseline alignment
305 * @param margins their margins (callback)
306 * @param positionToWidth callback for children widths (can return -1 if no bias is used)
307 * @param areaHeight height of the area to layout in
308 * @param fillHeight callback to specify children that has fillHeight constraint
309 * @param minComplement minimum complement
310 */
311 static double getAreaBaselineOffset(List<Node> children, Callback<Node, Insets> margins,
312 Function<Integer, Double> positionToWidth,
313 double areaHeight, Function<Integer, Boolean> fillHeight, double minComplement, boolean snapToPixel) {
314 double b = 0;
315 for (int i = 0;i < children.size(); ++i) {
316 Node n = children.get(i);
317 Insets margin = margins.call(n);
318 double top = margin != null? snapSpace(margin.getTop(), snapToPixel) : 0;
319 double bottom = (margin != null? snapSpace(margin.getBottom(), snapToPixel) : 0);
320 final double bo = n.getBaselineOffset();
321 if (bo == BASELINE_OFFSET_SAME_AS_HEIGHT) {
322 double alt = -1;
323 if (n.getContentBias() == Orientation.HORIZONTAL) {
324 alt = positionToWidth.apply(i);
325 }
326 if (fillHeight.apply(i)) {
327 // If the children fills it's height, than it's "preferred" height is the area without the complement and insets
328 b = Math.max(b, top + boundedSize(n.minHeight(alt), areaHeight - minComplement - top - bottom,
329 n.maxHeight(alt)));
330 } else {
331 // Otherwise, we must use the area without complement and insets as a maximum for the Node
332 b = Math.max(b, top + boundedSize(n.minHeight(alt), n.prefHeight(alt),
333 Math.min(n.maxHeight(alt), areaHeight - minComplement - top - bottom)));
334 }
335 } else {
336 b = Math.max(b, top + bo);
337 }
338 }
339 return b;
340 }
341
342 /**
343 * Return the minimum complement of baseline
344 * @param children
345 * @return
346 */
347 static double getMinBaselineComplement(List<Node> children) {
348 return getBaselineComplement(children, true, false);
349 }
350
351 /**
352 * Return the preferred complement of baseline
353 * @param children
354 * @return
355 */
356 static double getPrefBaselineComplement(List<Node> children) {
357 return getBaselineComplement(children, false, false);
358 }
359
360 /**
361 * Return the maximal complement of baseline
362 * @param children
363 * @return
364 */
365 static double getMaxBaselineComplement(List<Node> children) {
366 return getBaselineComplement(children, false, true);
367 }
368
369 private static double getBaselineComplement(List<Node> children, boolean min, boolean max) {
370 double bc = 0;
371 for (Node n : children) {
372 final double bo = n.getBaselineOffset();
373 if (bo == BASELINE_OFFSET_SAME_AS_HEIGHT) {
374 continue;
375 }
376 if (n.isResizable()) {
377 bc = Math.max(bc, (min ? n.minHeight(-1) : max ? n.maxHeight(-1) : n.prefHeight(-1)) - bo);
378 } else {
379 bc = Math.max(bc, n.getLayoutBounds().getHeight() - bo);
380 }
381 }
382 return bc;
383 }
384
385
386 static double computeXOffset(double width, double contentWidth, HPos hpos) {
387 switch(hpos) {
388 case LEFT:
389 return 0;
390 case CENTER:
391 return (width - contentWidth) / 2;
392 case RIGHT:
393 return width - contentWidth;
394 default:
395 throw new AssertionError("Unhandled hPos");
396 }
397 }
398
399 static double computeYOffset(double height, double contentHeight, VPos vpos) {
400 switch(vpos) {
401 case BASELINE:
402 case TOP:
403 return 0;
404 case CENTER:
405 return (height - contentHeight) / 2;
406 case BOTTOM:
407 return height - contentHeight;
408 default:
409 throw new AssertionError("Unhandled vPos");
410 }
411 }
412
413 static double[] createDoubleArray(int length, double value) {
414 double[] array = new double[length];
415 for (int i = 0; i < length; i++) {
416 array[i] = value;
417 }
418 return array;
419 }
420
421 /***************************************************************************
422 * *
423 * Constructors *
424 * *
425 **************************************************************************/
426
427 /**
428 * At the time that a Background or Border is set on a Region, we inspect any
429 * BackgroundImage or BorderImage objects, to see if the Image backing them
430 * is background loading and not yet complete, or is animated. In such cases
431 * we attach the imageChangeListener to them, so that when the image finishes,
432 * the Region will be redrawn. If the particular image object is not animating
433 * (but was just background loading), then we also remove the listener.
434 * We also are sure to remove this listener from any old BackgroundImage or
435 * BorderImage images in the background and border property invalidation code.
436 */
437 private InvalidationListener imageChangeListener = observable -> {
438 final ReadOnlyObjectPropertyBase imageProperty = (ReadOnlyObjectPropertyBase) observable;
439 final Image image = (Image) imageProperty.getBean();
440 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
441 if (image.getProgress() == 1 && !acc.isAnimation(image)) {
442 // We can go ahead and remove the listener since loading is done.
443 removeImageListener(image);
444 }
445 // Cause the region to repaint
446 impl_markDirty(DirtyBits.NODE_CONTENTS);
447 };
448
449 /**
450 * Creates a new Region with an empty Background and and empty Border. The
451 * Region defaults to having pickOnBounds set to true, meaning that any pick
452 * (mouse picking or touch picking etc) that occurs within the bounds in local
453 * of the Region will return true, regardless of whether the Region is filled
454 * or transparent.
455 */
456 public Region() {
457 super();
458 setPickOnBounds(true);
459 }
460
461 /***************************************************************************
462 * *
463 * Region properties *
464 * *
465 **************************************************************************/
466
467 /**
468 * Defines whether this region adjusts position, spacing, and size values of
469 * its children to pixel boundaries. This defaults to true, which is generally
470 * the expected behavior in order to have crisp user interfaces. A value of
471 * false will allow for fractional alignment, which may lead to "fuzzy"
472 * looking borders.
473 */
474 private BooleanProperty snapToPixel;
475 /**
476 * I'm using a super-lazy property pattern here, so as to only create the
477 * property object when needed for listeners or when being set from CSS,
478 * but also making sure that we only call requestParentLayout in the case
479 * that the snapToPixel value has actually changed, whether set via the setter
480 * or set via the property object.
481 */
482 private boolean _snapToPixel = true;
483 public final boolean isSnapToPixel() { return _snapToPixel; }
484 public final void setSnapToPixel(boolean value) {
485 if (snapToPixel == null) {
486 if (_snapToPixel != value) {
487 _snapToPixel = value;
488 updateSnappedInsets();
489 requestParentLayout();
490 }
491 } else {
492 snapToPixel.set(value);
493 }
494 }
495 public final BooleanProperty snapToPixelProperty() {
496 // Note: snapToPixel is virtually never set, and never listened to.
497 // Because of this, it works reasonably well as a lazy property,
498 // since this logic is just about never going to be called.
499 if (snapToPixel == null) {
500 snapToPixel = new StyleableBooleanProperty(_snapToPixel) {
501 @Override public Object getBean() { return Region.this; }
502 @Override public String getName() { return "snapToPixel"; }
503 @Override public CssMetaData<Region, Boolean> getCssMetaData() {
504 return StyleableProperties.SNAP_TO_PIXEL;
505 }
506 @Override public void invalidated() {
507 boolean value = get();
508 if (_snapToPixel != value) {
509 _snapToPixel = value;
510 updateSnappedInsets();
511 requestParentLayout();
512 }
513 }
514 };
515 }
516 return snapToPixel;
517 }
518
519 /**
520 * The top, right, bottom, and left padding around the region's content.
521 * This space will be included in the calculation of the region's
522 * minimum and preferred sizes. By default padding is Insets.EMPTY. Setting the
523 * value to null should be avoided.
524 */
525 private ObjectProperty<Insets> padding = new StyleableObjectProperty<Insets>(Insets.EMPTY) {
526 // Keep track of the last valid value for the sake of
527 // rollback in case padding is set to null. Note that
528 // Richard really does not like this pattern because
529 // it essentially means that binding the padding property
530 // is not possible since a binding expression could very
531 // easily produce an intermediate null value.
532
533 // Also note that because padding is set virtually everywhere via CSS, and CSS
534 // requires a property object in order to set it, there is no benefit to having
535 // lazy initialization here.
536
537 private Insets lastValidValue = Insets.EMPTY;
538
539 @Override public Object getBean() { return Region.this; }
540 @Override public String getName() { return "padding"; }
541 @Override public CssMetaData<Region, Insets> getCssMetaData() {
542 return StyleableProperties.PADDING;
543 }
544 @Override public void invalidated() {
545 final Insets newValue = get();
546 if (newValue == null) {
547 // rollback
548 if (isBound()) {
549 unbind();
550 }
551 set(lastValidValue);
552 throw new NullPointerException("cannot set padding to null");
553 } else if (!newValue.equals(lastValidValue)) {
554 lastValidValue = newValue;
555 insets.fireValueChanged();
556 }
557 }
558 };
559 public final void setPadding(Insets value) { padding.set(value); }
560 public final Insets getPadding() { return padding.get(); }
561 public final ObjectProperty<Insets> paddingProperty() { return padding; }
562
563 /**
564 * The background of the Region, which is made up of zero or more BackgroundFills, and
565 * zero or more BackgroundImages. It is possible for a Background to be empty, where it
566 * has neither fills nor images, and is semantically equivalent to null.
567 * @since JavaFX 8.0
568 */
569 private final ObjectProperty<Background> background = new StyleableObjectProperty<Background>(null) {
570 private Background old = null;
571 @Override public Object getBean() { return Region.this; }
572 @Override public String getName() { return "background"; }
573 @Override public CssMetaData<Region, Background> getCssMetaData() {
574 return StyleableProperties.BACKGROUND;
575 }
576
577 @Override protected void invalidated() {
578 final Background b = get();
579 if(old != null ? !old.equals(b) : b != null) {
580 // They are different! Both cannot be null
581 if (old == null || b == null || !old.getOutsets().equals(b.getOutsets())) {
582 // We have determined that the outsets of these two different background
583 // objects is different, and therefore the bounds have changed.
584 impl_geomChanged();
585 insets.fireValueChanged();
586 }
587
588 // If the Background is made up of any BackgroundImage objects, then we must
589 // inspect the images of those BackgroundImage objects to see if they are still
590 // being loaded in the background or if they are animated. If so, then we need
591 // to attach a listener, so that when the image finishes loading or changes,
592 // we can repaint the region.
593 if (b != null) {
594 for (BackgroundImage i : b.getImages()) {
595 final Image image = i.image;
596 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
597 if (acc.isAnimation(image) || image.getProgress() < 1) {
598 addImageListener(image);
599 }
600 }
601 }
602
603 // And we must remove this listener from any old images
604 if (old != null) {
605 for (BackgroundImage i : old.getImages()) {
606 removeImageListener(i.image);
607 }
608 }
609
610 // No matter what, the fill has changed, so we have to update it
611 impl_markDirty(DirtyBits.SHAPE_FILL);
612 cornersValid = false;
613 old = b;
614 }
615 }
616 };
617 public final void setBackground(Background value) { background.set(value); }
618 public final Background getBackground() { return background.get(); }
619 public final ObjectProperty<Background> backgroundProperty() { return background; }
620
621 /**
622 * The border of the Region, which is made up of zero or more BorderStrokes, and
623 * zero or more BorderImages. It is possible for a Border to be empty, where it
624 * has neither strokes nor images, and is semantically equivalent to null.
625 * @since JavaFX 8.0
626 */
627 private final ObjectProperty<Border> border = new StyleableObjectProperty<Border>(null) {
628 private Border old = null;
629 @Override public Object getBean() { return Region.this; }
630 @Override public String getName() { return "border"; }
631 @Override public CssMetaData<Region, Border> getCssMetaData() {
632 return StyleableProperties.BORDER;
633 }
634 @Override protected void invalidated() {
635 final Border b = get();
636 if(old != null ? !old.equals(b) : b != null) {
637 // They are different! Both cannot be null
638 if (old == null || b == null || !old.getOutsets().equals(b.getOutsets())) {
639 // We have determined that the outsets of these two different border
640 // objects is different, and therefore the bounds have changed.
641 impl_geomChanged();
642 }
643 if (old == null || b == null || !old.getInsets().equals(b.getInsets())) {
644 insets.fireValueChanged();
645 }
646
647 // If the Border is made up of any BorderImage objects, then we must
648 // inspect the images of those BorderImage objects to see if they are still
649 // being loaded in the background or if they are animated. If so, then we need
650 // to attach a listener, so that when the image finishes loading or changes,
651 // we can repaint the region.
652 if (b != null) {
653 for (BorderImage i : b.getImages()) {
654 final Image image = i.image;
655 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
656 if (acc.isAnimation(image) || image.getProgress() < 1) {
657 addImageListener(image);
658 }
659 }
660 }
661
662 // And we must remove this listener from any old images
663 if (old != null) {
664 for (BorderImage i : old.getImages()) {
665 removeImageListener(i.image);
666 }
667 }
668
669 // No matter what, the fill has changed, so we have to update it
670 impl_markDirty(DirtyBits.SHAPE_STROKE);
671 cornersValid = false;
672 old = b;
673 }
674 }
675 };
676 public final void setBorder(Border value) { border.set(value); }
677 public final Border getBorder() { return border.get(); }
678 public final ObjectProperty<Border> borderProperty() { return border; }
679
680 /**
681 * Adds the imageChangeListener to this image. This method was broken out and made
682 * package private for testing purposes.
683 *
684 * @param image a non-null image
685 */
686 void addImageListener(Image image) {
687 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
688 acc.getImageProperty(image).addListener(imageChangeListener);
689 }
690
691 /**
692 * Removes the imageChangeListener from this image. This method was broken out and made
693 * package private for testing purposes.
694 *
695 * @param image a non-null image
696 */
697 void removeImageListener(Image image) {
698 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
699 acc.getImageProperty(image).removeListener(imageChangeListener);
700 }
701
702 /**
703 * Defines the area of the region within which completely opaque pixels
704 * are drawn. This is used for various performance optimizations.
705 * The pixels within this area MUST BE fully opaque, or rendering
706 * artifacts will result. It is the responsibility of the application, either
707 * via code or via CSS, to ensure that the opaqueInsets is correct for
708 * a Region based on the backgrounds and borders of that region. The values
709 * for each of the insets must be real numbers, not NaN or Infinity. If
710 * no known insets exist, then the opaqueInsets should be set to null.
711 * @since JavaFX 8.0
712 */
713 public final ObjectProperty<Insets> opaqueInsetsProperty() {
714 if (opaqueInsets == null) {
715 opaqueInsets = new StyleableObjectProperty<Insets>() {
716 @Override public Object getBean() { return Region.this; }
717 @Override public String getName() { return "opaqueInsets"; }
718 @Override public CssMetaData<Region, Insets> getCssMetaData() {
719 return StyleableProperties.OPAQUE_INSETS;
720 }
721 @Override protected void invalidated() {
722 // This causes the background to be updated, which
723 // is the code block where we also compute the opaque insets
724 // since updating the background is super fast even when
725 // nothing has changed.
726 impl_markDirty(DirtyBits.SHAPE_FILL);
727 }
728 };
729 }
730 return opaqueInsets;
731 }
732 private ObjectProperty<Insets> opaqueInsets;
733 public final void setOpaqueInsets(Insets value) { opaqueInsetsProperty().set(value); }
734 public final Insets getOpaqueInsets() { return opaqueInsets == null ? null : opaqueInsets.get(); }
735
736 /**
737 * The insets of the Region define the distance from the edge of the region (its layout bounds,
738 * or (0, 0, width, height)) to the edge of the content area. All child nodes should be laid out
739 * within the content area. The insets are computed based on the Border which has been specified,
740 * if any, and also the padding.
741 * @since JavaFX 8.0
742 */
743 private final InsetsProperty insets = new InsetsProperty();
744 public final Insets getInsets() { return insets.get(); }
745 public final ReadOnlyObjectProperty<Insets> insetsProperty() { return insets; }
746 private final class InsetsProperty extends ReadOnlyObjectProperty<Insets> {
747 private Insets cache = null;
748 private ExpressionHelper<Insets> helper = null;
749
750 @Override public Object getBean() { return Region.this; }
751 @Override public String getName() { return "insets"; }
752
753 @Override public void addListener(InvalidationListener listener) {
754 helper = ExpressionHelper.addListener(helper, this, listener);
755 }
756
757 @Override public void removeListener(InvalidationListener listener) {
758 helper = ExpressionHelper.removeListener(helper, listener);
759 }
760
761 @Override public void addListener(ChangeListener<? super Insets> listener) {
762 helper = ExpressionHelper.addListener(helper, this, listener);
763 }
764
765 @Override public void removeListener(ChangeListener<? super Insets> listener) {
766 helper = ExpressionHelper.removeListener(helper, listener);
767 }
768
769 void fireValueChanged() {
770 cache = null;
771 updateSnappedInsets();
772 requestLayout();
773 ExpressionHelper.fireValueChangedEvent(helper);
774 }
775
776 @Override public Insets get() {
777 // If a shape is specified, then we don't really care whether there are any borders
778 // specified, since borders of shapes do not contribute to the insets.
779 if (_shape != null) return getPadding();
780
781 // If there is no border or the border has no insets itself, then the only thing
782 // affecting the insets is the padding, so we can just return it directly.
783 final Border b = getBorder();
784 if (b == null || Insets.EMPTY.equals(b.getInsets())) {
785 return getPadding();
786 }
787
788 // There is a border with some non-zero insets and we do not have a _shape, so we need
789 // to take the border's insets into account
790 if (cache == null) {
791 // Combine the padding and the border insets.
792 // TODO note that negative border insets were being ignored, but
793 // I'm not sure that that made sense or was reasonable, so I have
794 // changed it so that we just do simple math.
795 // TODO Stroke borders should NOT contribute to the insets. Ensure via tests.
796 final Insets borderInsets = b.getInsets();
797 final Insets paddingInsets = getPadding();
798 cache = new Insets(
799 borderInsets.getTop() + paddingInsets.getTop(),
800 borderInsets.getRight() + paddingInsets.getRight(),
801 borderInsets.getBottom() + paddingInsets.getBottom(),
802 borderInsets.getLeft() + paddingInsets.getLeft()
803 );
804 }
805 return cache;
806 }
807 };
808
809 /**
810 * cached results of snapped insets, this are used a lot during layout so makes sense
811 * to keep fast access cached copies here.
812 */
813 private double snappedTopInset = 0;
814 private double snappedRightInset = 0;
815 private double snappedBottomInset = 0;
816 private double snappedLeftInset = 0;
817
818 /** Called to update the cached snapped insets */
819 private void updateSnappedInsets() {
820 final Insets insets = getInsets();
821 if (_snapToPixel) {
822 snappedTopInset = Math.ceil(insets.getTop());
823 snappedRightInset = Math.ceil(insets.getRight());
824 snappedBottomInset = Math.ceil(insets.getBottom());
825 snappedLeftInset = Math.ceil(insets.getLeft());
826 } else {
827 snappedTopInset = insets.getTop();
828 snappedRightInset = insets.getRight();
829 snappedBottomInset = insets.getBottom();
830 snappedLeftInset = insets.getLeft();
831 }
832 }
833
834 /**
835 * The width of this resizable node. This property is set by the region's parent
836 * during layout and may not be set by the application. If an application
837 * needs to explicitly control the size of a region, it should override its
838 * preferred size range by setting the <code>minWidth</code>, <code>prefWidth</code>,
839 * and <code>maxWidth</code> properties.
840 */
841 private ReadOnlyDoubleWrapper width;
842
843 /**
844 * Because the width is very often set and very often read but only sometimes
845 * listened to, it is beneficial to use the super-lazy pattern property, where we
846 * only inflate the property object when widthProperty() is explicitly invoked.
847 */
848 private double _width;
849
850 // Note that it is OK for this method to be protected so long as the width
851 // property is never bound. Only Region could do so because only Region has
852 // access to a writable property for "width", but since there is now a protected
853 // set method, it is impossible for Region to ever bind this property.
854 protected void setWidth(double value) {
855 if(width == null) {
856 widthChanged(value);
857 } else {
858 width.set(value);
859 }
860 }
861
862 private void widthChanged(double value) {
863 // It is possible that somebody sets the width of the region to a value which
864 // it previously held. If this is the case, we want to avoid excessive layouts.
865 // Note that I have biased this for layout over binding, because the widthProperty
866 // is now going to recompute the width eagerly. The cost of excessive and
867 // unnecessary bounds changes, however, is relatively high.
868 if (value != _width) {
869 _width = value;
870 cornersValid = false;
871 boundingBox = null;
872 impl_layoutBoundsChanged();
873 impl_geomChanged();
874 impl_markDirty(DirtyBits.NODE_GEOMETRY);
875 setNeedsLayout(true);
876 requestParentLayout();
877 }
878 }
879
880 public final double getWidth() { return width == null ? _width : width.get(); }
881
882 public final ReadOnlyDoubleProperty widthProperty() {
883 if (width == null) {
884 width = new ReadOnlyDoubleWrapper(_width) {
885 @Override protected void invalidated() { widthChanged(get()); }
886 @Override public Object getBean() { return Region.this; }
887 @Override public String getName() { return "width"; }
888 };
889 }
890 return width.getReadOnlyProperty();
891 }
892
893 /**
894 * The height of this resizable node. This property is set by the region's parent
895 * during layout and may not be set by the application. If an application
896 * needs to explicitly control the size of a region, it should override its
897 * preferred size range by setting the <code>minHeight</code>, <code>prefHeight</code>,
898 * and <code>maxHeight</code> properties.
899 */
900 private ReadOnlyDoubleWrapper height;
901
902 /**
903 * Because the height is very often set and very often read but only sometimes
904 * listened to, it is beneficial to use the super-lazy pattern property, where we
905 * only inflate the property object when heightProperty() is explicitly invoked.
906 */
907 private double _height;
908
909 // Note that it is OK for this method to be protected so long as the height
910 // property is never bound. Only Region could do so because only Region has
911 // access to a writable property for "height", but since there is now a protected
912 // set method, it is impossible for Region to ever bind this property.
913 protected void setHeight(double value) {
914 if (height == null) {
915 heightChanged(value);
916 } else {
917 height.set(value);
918 }
919 }
920
921 private void heightChanged(double value) {
922 if (_height != value) {
923 _height = value;
924 cornersValid = false;
925 // It is possible that somebody sets the height of the region to a value which
926 // it previously held. If this is the case, we want to avoid excessive layouts.
927 // Note that I have biased this for layout over binding, because the heightProperty
928 // is now going to recompute the height eagerly. The cost of excessive and
929 // unnecessary bounds changes, however, is relatively high.
930 boundingBox = null;
931 // Note: although impl_geomChanged will usually also invalidate the
932 // layout bounds, that is not the case for Regions, and both must
933 // be called separately.
934 impl_geomChanged();
935 impl_layoutBoundsChanged();
936 // We use "NODE_GEOMETRY" to mean that the bounds have changed and
937 // need to be sync'd with the render tree
938 impl_markDirty(DirtyBits.NODE_GEOMETRY);
939 // Change of the height (or width) won't change the preferred size.
940 // So we don't need to flush the cache. We should however mark this node
941 // as needs layout to be internally layouted.
942 setNeedsLayout(true);
943 // This call is only needed when this was not called from the parent during the layout.
944 // Otherwise it would flush the cache of the parent, which is not necessary
945 requestParentLayout();
946 }
947 }
948
949 public final double getHeight() { return height == null ? _height : height.get(); }
950
951 public final ReadOnlyDoubleProperty heightProperty() {
952 if (height == null) {
953 height = new ReadOnlyDoubleWrapper(_height) {
954 @Override protected void invalidated() { heightChanged(get()); }
955 @Override public Object getBean() { return Region.this; }
956 @Override public String getName() { return "height"; }
957 };
958 }
959 return height.getReadOnlyProperty();
960 }
961
962 /**
963 * This class is reused for the min, pref, and max properties since
964 * they all performed the same function (to call requestParentLayout).
965 */
966 private final class MinPrefMaxProperty extends StyleableDoubleProperty {
967 private final String name;
968 private final CssMetaData<? extends Styleable, Number> cssMetaData;
969
970 MinPrefMaxProperty(String name, double initialValue, CssMetaData<? extends Styleable, Number> cssMetaData) {
971 super(initialValue);
972 this.name = name;
973 this.cssMetaData = cssMetaData;
974 }
975
976 @Override public void invalidated() { requestParentLayout(); }
977 @Override public Object getBean() { return Region.this; }
978 @Override public String getName() { return name; }
979
980 @Override
981 public CssMetaData<? extends Styleable, Number> getCssMetaData() {
982 return cssMetaData;
983 }
984 }
985
986 /**
987 * Property for overriding the region's computed minimum width.
988 * This should only be set if the region's internally computed minimum width
989 * doesn't meet the application's layout needs.
990 * <p>
991 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
992 * <code>minWidth(forHeight)</code> will return the region's internally
993 * computed minimum width.
994 * <p>
995 * Setting this value to the <code>USE_PREF_SIZE</code> flag will cause
996 * <code>minWidth(forHeight)</code> to return the region's preferred width,
997 * enabling applications to easily restrict the resizability of the region.
998 */
999 private DoubleProperty minWidth;
1000 private double _minWidth = USE_COMPUTED_SIZE;
1001 public final void setMinWidth(double value) {
1002 if (minWidth == null) {
1003 _minWidth = value;
1004 requestParentLayout();
1005 } else {
1006 minWidth.set(value);
1007 }
1008 }
1009 public final double getMinWidth() { return minWidth == null ? _minWidth : minWidth.get(); }
1010 public final DoubleProperty minWidthProperty() {
1011 if (minWidth == null) minWidth = new MinPrefMaxProperty("minWidth", _minWidth, StyleableProperties.MIN_WIDTH);
1012 return minWidth;
1013 }
1014
1015 /**
1016 * Property for overriding the region's computed minimum height.
1017 * This should only be set if the region's internally computed minimum height
1018 * doesn't meet the application's layout needs.
1019 * <p>
1020 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
1021 * <code>minHeight(forWidth)</code> will return the region's internally
1022 * computed minimum height.
1023 * <p>
1024 * Setting this value to the <code>USE_PREF_SIZE</code> flag will cause
1025 * <code>minHeight(forWidth)</code> to return the region's preferred height,
1026 * enabling applications to easily restrict the resizability of the region.
1027 *
1028 */
1029 private DoubleProperty minHeight;
1030 private double _minHeight = USE_COMPUTED_SIZE;
1031 public final void setMinHeight(double value) {
1032 if (minHeight == null) {
1033 _minHeight = value;
1034 requestParentLayout();
1035 } else {
1036 minHeight.set(value);
1037 }
1038 }
1039 public final double getMinHeight() { return minHeight == null ? _minHeight : minHeight.get(); }
1040 public final DoubleProperty minHeightProperty() {
1041 if (minHeight == null) minHeight = new MinPrefMaxProperty("minHeight", _minHeight, StyleableProperties.MIN_HEIGHT);
1042 return minHeight;
1043 }
1044
1045 /**
1046 * Convenience method for overriding the region's computed minimum width and height.
1047 * This should only be called if the region's internally computed minimum size
1048 * doesn't meet the application's layout needs.
1049 *
1050 * @see #setMinWidth
1051 * @see #setMinHeight
1052 * @param minWidth the override value for minimum width
1053 * @param minHeight the override value for minimum height
1054 */
1055 public void setMinSize(double minWidth, double minHeight) {
1056 setMinWidth(minWidth);
1057 setMinHeight(minHeight);
1058 }
1059
1060 /**
1061 * Property for overriding the region's computed preferred width.
1062 * This should only be set if the region's internally computed preferred width
1063 * doesn't meet the application's layout needs.
1064 * <p>
1065 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
1066 * <code>getPrefWidth(forHeight)</code> will return the region's internally
1067 * computed preferred width.
1068 */
1069 private DoubleProperty prefWidth;
1070 private double _prefWidth = USE_COMPUTED_SIZE;
1071 public final void setPrefWidth(double value) {
1072 if (prefWidth == null) {
1073 _prefWidth = value;
1074 requestParentLayout();
1075 } else {
1076 prefWidth.set(value);
1077 }
1078 }
1079 public final double getPrefWidth() { return prefWidth == null ? _prefWidth : prefWidth.get(); }
1080 public final DoubleProperty prefWidthProperty() {
1081 if (prefWidth == null) prefWidth = new MinPrefMaxProperty("prefWidth", _prefWidth, StyleableProperties.PREF_WIDTH);
1082 return prefWidth;
1083 }
1084
1085 /**
1086 * Property for overriding the region's computed preferred height.
1087 * This should only be set if the region's internally computed preferred height
1088 * doesn't meet the application's layout needs.
1089 * <p>
1090 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
1091 * <code>getPrefHeight(forWidth)</code> will return the region's internally
1092 * computed preferred width.
1093 */
1094 private DoubleProperty prefHeight;
1095 private double _prefHeight = USE_COMPUTED_SIZE;
1096 public final void setPrefHeight(double value) {
1097 if (prefHeight == null) {
1098 _prefHeight = value;
1099 requestParentLayout();
1100 } else {
1101 prefHeight.set(value);
1102 }
1103 }
1104 public final double getPrefHeight() { return prefHeight == null ? _prefHeight : prefHeight.get(); }
1105 public final DoubleProperty prefHeightProperty() {
1106 if (prefHeight == null) prefHeight = new MinPrefMaxProperty("prefHeight", _prefHeight, StyleableProperties.PREF_HEIGHT);
1107 return prefHeight;
1108 }
1109
1110 /**
1111 * Convenience method for overriding the region's computed preferred width and height.
1112 * This should only be called if the region's internally computed preferred size
1113 * doesn't meet the application's layout needs.
1114 *
1115 * @see #setPrefWidth
1116 * @see #setPrefHeight
1117 * @param prefWidth the override value for preferred width
1118 * @param prefHeight the override value for preferred height
1119 */
1120 public void setPrefSize(double prefWidth, double prefHeight) {
1121 setPrefWidth(prefWidth);
1122 setPrefHeight(prefHeight);
1123 }
1124
1125 /**
1126 * Property for overriding the region's computed maximum width.
1127 * This should only be set if the region's internally computed maximum width
1128 * doesn't meet the application's layout needs.
1129 * <p>
1130 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
1131 * <code>getMaxWidth(forHeight)</code> will return the region's internally
1132 * computed maximum width.
1133 * <p>
1134 * Setting this value to the <code>USE_PREF_SIZE</code> flag will cause
1135 * <code>getMaxWidth(forHeight)</code> to return the region's preferred width,
1136 * enabling applications to easily restrict the resizability of the region.
1137 */
1138 private DoubleProperty maxWidth;
1139 private double _maxWidth = USE_COMPUTED_SIZE;
1140 public final void setMaxWidth(double value) {
1141 if (maxWidth == null) {
1142 _maxWidth = value;
1143 requestParentLayout();
1144 } else {
1145 maxWidth.set(value);
1146 }
1147 }
1148 public final double getMaxWidth() { return maxWidth == null ? _maxWidth : maxWidth.get(); }
1149 public final DoubleProperty maxWidthProperty() {
1150 if (maxWidth == null) maxWidth = new MinPrefMaxProperty("maxWidth", _maxWidth, StyleableProperties.MAX_WIDTH);
1151 return maxWidth;
1152 }
1153
1154 /**
1155 * Property for overriding the region's computed maximum height.
1156 * This should only be set if the region's internally computed maximum height
1157 * doesn't meet the application's layout needs.
1158 * <p>
1159 * Defaults to the <code>USE_COMPUTED_SIZE</code> flag, which means that
1160 * <code>getMaxHeight(forWidth)</code> will return the region's internally
1161 * computed maximum height.
1162 * <p>
1163 * Setting this value to the <code>USE_PREF_SIZE</code> flag will cause
1164 * <code>getMaxHeight(forWidth)</code> to return the region's preferred height,
1165 * enabling applications to easily restrict the resizability of the region.
1166 */
1167 private DoubleProperty maxHeight;
1168 private double _maxHeight = USE_COMPUTED_SIZE;
1169 public final void setMaxHeight(double value) {
1170 if (maxHeight == null) {
1171 _maxHeight = value;
1172 requestParentLayout();
1173 } else {
1174 maxHeight.set(value);
1175 }
1176 }
1177 public final double getMaxHeight() { return maxHeight == null ? _maxHeight : maxHeight.get(); }
1178 public final DoubleProperty maxHeightProperty() {
1179 if (maxHeight == null) maxHeight = new MinPrefMaxProperty("maxHeight", _maxHeight, StyleableProperties.MAX_HEIGHT);
1180 return maxHeight;
1181 }
1182
1183 /**
1184 * Convenience method for overriding the region's computed maximum width and height.
1185 * This should only be called if the region's internally computed maximum size
1186 * doesn't meet the application's layout needs.
1187 *
1188 * @see #setMaxWidth
1189 * @see #setMaxHeight
1190 * @param maxWidth the override value for maximum width
1191 * @param maxHeight the override value for maximum height
1192 */
1193 public void setMaxSize(double maxWidth, double maxHeight) {
1194 setMaxWidth(maxWidth);
1195 setMaxHeight(maxHeight);
1196 }
1197
1198 /**
1199 * When specified, the {@code shape} will cause the region to be
1200 * rendered as the specified shape rather than as a rounded rectangle.
1201 * When null, the Region is rendered as a rounded rectangle. When rendered
1202 * as a Shape, any Background is used to fill the shape, although any
1203 * background insets are ignored as are background radii. Any BorderStrokes
1204 * defined are used for stroking the shape. Any BorderImages are ignored.
1205 *
1206 * @default null
1207 * @css shape SVG shape string
1208 * @since JavaFX 8.0
1209 */
1210 private ObjectProperty<Shape> shape = null;
1211 private Shape _shape;
1212 public final Shape getShape() { return shape == null ? _shape : shape.get(); }
1213 public final void setShape(Shape value) { shapeProperty().set(value); }
1214 public final ObjectProperty<Shape> shapeProperty() {
1215 if (shape == null) {
1216 shape = new ShapeProperty();
1217 }
1218 return shape;
1219 }
1220
1221 /**
1222 * An implementation for the ShapeProperty. This is also a ShapeChangeListener.
1223 */
1224 private final class ShapeProperty extends StyleableObjectProperty<Shape> implements Runnable {
1225 @Override public Object getBean() { return Region.this; }
1226 @Override public String getName() { return "shape"; }
1227 @Override public CssMetaData<Region, Shape> getCssMetaData() {
1228 return StyleableProperties.SHAPE;
1229 }
1230 @Override protected void invalidated() {
1231 final Shape value = get();
1232 if (_shape != value) {
1233 // The shape has changed. We need to add/remove listeners
1234 if (_shape != null) _shape.impl_setShapeChangeListener(null);
1235 if (value != null) value.impl_setShapeChangeListener(this);
1236 // Invalidate the bounds and such
1237 run();
1238 if (_shape == null || value == null) {
1239 // It either was null before, or is null now. In either case,
1240 // the result of the insets computation will have changed, and
1241 // we therefore need to fire that the insets value may have changed.
1242 insets.fireValueChanged();
1243 }
1244 // Update our reference to the old shape
1245 _shape = value;
1246 }
1247 }
1248
1249 @Override public void run() {
1250 impl_geomChanged();
1251 impl_markDirty(DirtyBits.REGION_SHAPE);
1252 }
1253 };
1254
1255 /**
1256 * Specifies whether the shape, if defined, is scaled to match the size of the Region.
1257 * {@code true} means the shape is scaled to fit the size of the Region, {@code false}
1258 * means the shape is at its source size, its positioning depends on the value of
1259 * {@code centerShape}.
1260 *
1261 * @default true
1262 * @css shape-size true | false
1263 * @since JavaFX 8.0
1264 */
1265 private BooleanProperty scaleShape = null;
1266 public final void setScaleShape(boolean value) { scaleShapeProperty().set(value); }
1267 public final boolean isScaleShape() { return scaleShape == null ? true : scaleShape.get(); }
1268 public final BooleanProperty scaleShapeProperty() {
1269 if (scaleShape == null) {
1270 scaleShape = new StyleableBooleanProperty(true) {
1271 @Override public Object getBean() { return Region.this; }
1272 @Override public String getName() { return "scaleShape"; }
1273 @Override public CssMetaData<Region, Boolean> getCssMetaData() {
1274 return StyleableProperties.SCALE_SHAPE;
1275 }
1276 @Override public void invalidated() {
1277 impl_geomChanged();
1278 impl_markDirty(DirtyBits.REGION_SHAPE);
1279 }
1280 };
1281 }
1282 return scaleShape;
1283 }
1284
1285 /**
1286 * Defines whether the shape is centered within the Region's width or height.
1287 * {@code true} means the shape centered within the Region's width and height,
1288 * {@code false} means the shape is positioned at its source position.
1289 *
1290 * @default true
1291 * @css position-shape true | false
1292 * @since JavaFX 8.0
1293 */
1294 private BooleanProperty centerShape = null;
1295 public final void setCenterShape(boolean value) { centerShapeProperty().set(value); }
1296 public final boolean isCenterShape() { return centerShape == null ? true : centerShape.get(); }
1297 public final BooleanProperty centerShapeProperty() {
1298 if (centerShape == null) {
1299 centerShape = new StyleableBooleanProperty(true) {
1300 @Override public Object getBean() { return Region.this; }
1301 @Override public String getName() { return "centerShape"; }
1302 @Override public CssMetaData<Region, Boolean> getCssMetaData() {
1303 return StyleableProperties.POSITION_SHAPE;
1304 }
1305 @Override public void invalidated() {
1306 impl_geomChanged();
1307 impl_markDirty(DirtyBits.REGION_SHAPE);
1308 }
1309 };
1310 }
1311 return centerShape;
1312 }
1313
1314 /**
1315 * Defines a hint to the system indicating that the Shape used to define the region's
1316 * background is stable and would benefit from caching.
1317 *
1318 * @default true
1319 * @css -fx-cache-shape true | false
1320 * @since JavaFX 8.0
1321 */
1322 private BooleanProperty cacheShape = null;
1323 public final void setCacheShape(boolean value) { cacheShapeProperty().set(value); }
1324 public final boolean isCacheShape() { return cacheShape == null ? true : cacheShape.get(); }
1325 public final BooleanProperty cacheShapeProperty() {
1326 if (cacheShape == null) {
1327 cacheShape = new StyleableBooleanProperty(true) {
1328 @Override public Object getBean() { return Region.this; }
1329 @Override public String getName() { return "cacheShape"; }
1330 @Override public CssMetaData<Region, Boolean> getCssMetaData() {
1331 return StyleableProperties.CACHE_SHAPE;
1332 }
1333 };
1334 }
1335 return cacheShape;
1336 }
1337
1338 /***************************************************************************
1339 * *
1340 * Layout *
1341 * *
1342 **************************************************************************/
1343
1344 /**
1345 * Returns <code>true</code> since all Regions are resizable.
1346 * @return whether this node can be resized by its parent during layout
1347 */
1348 @Override public boolean isResizable() {
1349 return true;
1350 }
1351
1352 /**
1353 * Invoked by the region's parent during layout to set the region's
1354 * width and height. <b>Applications should not invoke this method directly</b>.
1355 * If an application needs to directly set the size of the region, it should
1356 * override its size constraints by calling <code>setMinSize()</code>,
1357 * <code>setPrefSize()</code>, or <code>setMaxSize()</code> and it's parent
1358 * will honor those overrides during layout.
1359 *
1360 * @param width the target layout bounds width
1361 * @param height the target layout bounds height
1362 */
1363 @Override public void resize(double width, double height) {
1364 setWidth(width);
1365 setHeight(height);
1366 PlatformLogger logger = Logging.getLayoutLogger();
1367 if (logger.isLoggable(Level.FINER)) {
1368 logger.finer(this.toString() + " resized to " + width + " x " + height);
1369 }
1370 }
1371
1372 /**
1373 * Called during layout to determine the minimum width for this node.
1374 * Returns the value from <code>computeMinWidth(forHeight)</code> unless
1375 * the application overrode the minimum width by setting the minWidth property.
1376 *
1377 * @see #setMinWidth(double)
1378 * @return the minimum width that this node should be resized to during layout
1379 */
1380 @Override public final double minWidth(double height) {
1381 final double override = getMinWidth();
1382 if (override == USE_COMPUTED_SIZE) {
1383 return super.minWidth(height);
1384 } else if (override == USE_PREF_SIZE) {
1385 return prefWidth(height);
1386 }
1387 return Double.isNaN(override) || override < 0 ? 0 : override;
1388 }
1389
1390 /**
1391 * Called during layout to determine the minimum height for this node.
1392 * Returns the value from <code>computeMinHeight(forWidth)</code> unless
1393 * the application overrode the minimum height by setting the minHeight property.
1394 *
1395 * @see #setMinHeight
1396 * @return the minimum height that this node should be resized to during layout
1397 */
1398 @Override public final double minHeight(double width) {
1399 final double override = getMinHeight();
1400 if (override == USE_COMPUTED_SIZE) {
1401 return super.minHeight(width);
1402 } else if (override == USE_PREF_SIZE) {
1403 return prefHeight(width);
1404 }
1405 return Double.isNaN(override) || override < 0 ? 0 : override;
1406 }
1407
1408 /**
1409 * Called during layout to determine the preferred width for this node.
1410 * Returns the value from <code>computePrefWidth(forHeight)</code> unless
1411 * the application overrode the preferred width by setting the prefWidth property.
1412 *
1413 * @see #setPrefWidth
1414 * @return the preferred width that this node should be resized to during layout
1415 */
1416 @Override public final double prefWidth(double height) {
1417 final double override = getPrefWidth();
1418 if (override == USE_COMPUTED_SIZE) {
1419 return super.prefWidth(height);
1420 }
1421 return Double.isNaN(override) || override < 0 ? 0 : override;
1422 }
1423
1424 /**
1425 * Called during layout to determine the preferred height for this node.
1426 * Returns the value from <code>computePrefHeight(forWidth)</code> unless
1427 * the application overrode the preferred height by setting the prefHeight property.
1428 *
1429 * @see #setPrefHeight
1430 * @return the preferred height that this node should be resized to during layout
1431 */
1432 @Override public final double prefHeight(double width) {
1433 final double override = getPrefHeight();
1434 if (override == USE_COMPUTED_SIZE) {
1435 return super.prefHeight(width);
1436 }
1437 return Double.isNaN(override) || override < 0 ? 0 : override;
1438 }
1439
1440 /**
1441 * Called during layout to determine the maximum width for this node.
1442 * Returns the value from <code>computeMaxWidth(forHeight)</code> unless
1443 * the application overrode the maximum width by setting the maxWidth property.
1444 *
1445 * @see #setMaxWidth
1446 * @return the maximum width that this node should be resized to during layout
1447 */
1448 @Override public final double maxWidth(double height) {
1449 final double override = getMaxWidth();
1450 if (override == USE_COMPUTED_SIZE) {
1451 return computeMaxWidth(height);
1452 } else if (override == USE_PREF_SIZE) {
1453 return prefWidth(height);
1454 }
1455 return Double.isNaN(override) || override < 0 ? 0 : override;
1456 }
1457
1458 /**
1459 * Called during layout to determine the maximum height for this node.
1460 * Returns the value from <code>computeMaxHeight(forWidth)</code> unless
1461 * the application overrode the maximum height by setting the maxHeight property.
1462 *
1463 * @see #setMaxHeight
1464 * @return the maximum height that this node should be resized to during layout
1465 */
1466 @Override public final double maxHeight(double width) {
1467 final double override = getMaxHeight();
1468 if (override == USE_COMPUTED_SIZE) {
1469 return computeMaxHeight(width);
1470 } else if (override == USE_PREF_SIZE) {
1471 return prefHeight(width);
1472 }
1473 return Double.isNaN(override) || override < 0 ? 0 : override;
1474 }
1475
1476 /**
1477 * Computes the minimum width of this region.
1478 * Returns the sum of the left and right insets by default.
1479 * region subclasses should override this method to return an appropriate
1480 * value based on their content and layout strategy. If the subclass
1481 * doesn't have a VERTICAL content bias, then the height parameter can be
1482 * ignored.
1483 *
1484 * @return the computed minimum width of this region
1485 */
1486 @Override protected double computeMinWidth(double height) {
1487 return getInsets().getLeft() + getInsets().getRight();
1488 }
1489
1490 /**
1491 * Computes the minimum height of this region.
1492 * Returns the sum of the top and bottom insets by default.
1493 * Region subclasses should override this method to return an appropriate
1494 * value based on their content and layout strategy. If the subclass
1495 * doesn't have a HORIZONTAL content bias, then the width parameter can be
1496 * ignored.
1497 *
1498 * @return the computed minimum height for this region
1499 */
1500 @Override protected double computeMinHeight(double width) {
1501 return getInsets().getTop() + getInsets().getBottom();
1502 }
1503
1504 /**
1505 * Computes the preferred width of this region for the given height.
1506 * Region subclasses should override this method to return an appropriate
1507 * value based on their content and layout strategy. If the subclass
1508 * doesn't have a VERTICAL content bias, then the height parameter can be
1509 * ignored.
1510 *
1511 * @return the computed preferred width for this region
1512 */
1513 @Override protected double computePrefWidth(double height) {
1514 final double w = super.computePrefWidth(height);
1515 return getInsets().getLeft() + w + getInsets().getRight();
1516 }
1517
1518 /**
1519 * Computes the preferred height of this region for the given width;
1520 * Region subclasses should override this method to return an appropriate
1521 * value based on their content and layout strategy. If the subclass
1522 * doesn't have a HORIZONTAL content bias, then the width parameter can be
1523 * ignored.
1524 *
1525 * @return the computed preferred height for this region
1526 */
1527 @Override protected double computePrefHeight(double width) {
1528 final double h = super.computePrefHeight(width);
1529 return getInsets().getTop() + h + getInsets().getBottom();
1530 }
1531
1532 /**
1533 * Computes the maximum width for this region.
1534 * Returns Double.MAX_VALUE by default.
1535 * Region subclasses may override this method to return an different
1536 * value based on their content and layout strategy. If the subclass
1537 * doesn't have a VERTICAL content bias, then the height parameter can be
1538 * ignored.
1539 *
1540 * @return the computed maximum width for this region
1541 */
1542 protected double computeMaxWidth(double height) {
1543 return Double.MAX_VALUE;
1544 }
1545
1546 /**
1547 * Computes the maximum height of this region.
1548 * Returns Double.MAX_VALUE by default.
1549 * Region subclasses may override this method to return a different
1550 * value based on their content and layout strategy. If the subclass
1551 * doesn't have a HORIZONTAL content bias, then the width parameter can be
1552 * ignored.
1553 *
1554 * @return the computed maximum height for this region
1555 */
1556 protected double computeMaxHeight(double width) {
1557 return Double.MAX_VALUE;
1558 }
1559
1560 /**
1561 * If this region's snapToPixel property is true, returns a value rounded
1562 * to the nearest pixel, else returns the same value.
1563 * @param value the space value to be snapped
1564 * @return value rounded to nearest pixel
1565 */
1566 protected double snapSpace(double value) {
1567 return snapSpace(value, isSnapToPixel());
1568 }
1569
1570 /**
1571 * If this region's snapToPixel property is true, returns a value ceiled
1572 * to the nearest pixel, else returns the same value.
1573 * @param value the size value to be snapped
1574 * @return value ceiled to nearest pixel
1575 */
1576 protected double snapSize(double value) {
1577 return snapSize(value, isSnapToPixel());
1578 }
1579
1580 /**
1581 * If this region's snapToPixel property is true, returns a value rounded
1582 * to the nearest pixel, else returns the same value.
1583 * @param value the position value to be snapped
1584 * @return value rounded to nearest pixel
1585 */
1586 protected double snapPosition(double value) {
1587 return snapPosition(value, isSnapToPixel());
1588 }
1589
1590 double snapPortion(double value) {
1591 return snapPortion(value, isSnapToPixel());
1592 }
1593
1594
1595 /**
1596 * Utility method to get the top inset which includes padding and border
1597 * inset. Then snapped to whole pixels if isSnapToPixel() is true.
1598 *
1599 * @since JavaFX 8.0
1600 * @return Rounded up insets top
1601 */
1602 public final double snappedTopInset() {
1603 return snappedTopInset;
1604 }
1605
1606 /**
1607 * Utility method to get the bottom inset which includes padding and border
1608 * inset. Then snapped to whole pixels if isSnapToPixel() is true.
1609 *
1610 * @since JavaFX 8.0
1611 * @return Rounded up insets bottom
1612 */
1613 public final double snappedBottomInset() {
1614 return snappedBottomInset;
1615 }
1616
1617 /**
1618 * Utility method to get the left inset which includes padding and border
1619 * inset. Then snapped to whole pixels if isSnapToPixel() is true.
1620 *
1621 * @since JavaFX 8.0
1622 * @return Rounded up insets left
1623 */
1624 public final double snappedLeftInset() {
1625 return snappedLeftInset;
1626 }
1627
1628 /**
1629 * Utility method to get the right inset which includes padding and border
1630 * inset. Then snapped to whole pixels if isSnapToPixel() is true.
1631 *
1632 * @since JavaFX 8.0
1633 * @return Rounded up insets right
1634 */
1635 public final double snappedRightInset() {
1636 return snappedRightInset;
1637 }
1638
1639
1640 double computeChildMinAreaWidth(Node child, Insets margin) {
1641 return computeChildMinAreaWidth(child, -1, margin, -1, false);
1642 }
1643
1644 double computeChildMinAreaWidth(Node child, double baselineComplement, Insets margin, double height, boolean fillHeight) {
1645 final boolean snap = isSnapToPixel();
1646 double left = margin != null? snapSpace(margin.getLeft(), snap) : 0;
1647 double right = margin != null? snapSpace(margin.getRight(), snap) : 0;
1648 double alt = -1;
1649 if (height != -1 && child.isResizable() && child.getContentBias() == Orientation.VERTICAL) { // width depends on height
1650 double top = margin != null? snapSpace(margin.getTop(), snap) : 0;
1651 double bottom = (margin != null? snapSpace(margin.getBottom(), snap) : 0);
1652 double bo = child.getBaselineOffset();
1653 final double contentHeight = bo == BASELINE_OFFSET_SAME_AS_HEIGHT && baselineComplement != -1 ?
1654 height - top - bottom - baselineComplement :
1655 height - top - bottom;
1656 if (fillHeight) {
1657 alt = snapSize(boundedSize(
1658 child.minHeight(-1), contentHeight,
1659 child.maxHeight(-1)));
1660 } else {
1661 alt = snapSize(boundedSize(
1662 child.minHeight(-1),
1663 child.prefHeight(-1),
1664 Math.min(child.maxHeight(-1), contentHeight)));
1665 }
1666 }
1667 return left + snapSize(child.minWidth(alt)) + right;
1668 }
1669
1670 double computeChildMinAreaHeight(Node child, Insets margin) {
1671 return computeChildMinAreaHeight(child, -1, margin, -1);
1672 }
1673
1674 double computeChildMinAreaHeight(Node child, double minBaselineComplement, Insets margin, double width) {
1675 final boolean snap = isSnapToPixel();
1676 double top =margin != null? snapSpace(margin.getTop(), snap) : 0;
1677 double bottom = margin != null? snapSpace(margin.getBottom(), snap) : 0;
1678
1679 double alt = -1;
1680 if (child.isResizable() && child.getContentBias() == Orientation.HORIZONTAL) { // height depends on width
1681 double left = margin != null? snapSpace(margin.getLeft(), snap) : 0;
1682 double right = margin != null? snapSpace(margin.getRight(), snap) : 0;
1683 alt = snapSize(width != -1? boundedSize(child.minWidth(-1), width - left - right, child.maxWidth(-1)) :
1684 child.maxWidth(-1));
1685 }
1686
1687 // For explanation, see computeChildPrefAreaHeight
1688 if (minBaselineComplement != -1) {
1689 double baseline = child.getBaselineOffset();
1690 if (child.isResizable() && baseline == BASELINE_OFFSET_SAME_AS_HEIGHT) {
1691 return top + snapSize(child.minHeight(alt)) + bottom
1692 + minBaselineComplement;
1693 } else {
1694 return baseline + minBaselineComplement;
1695 }
1696 } else {
1697 return top + snapSize(child.minHeight(alt)) + bottom;
1698 }
1699 }
1700
1701 double computeChildPrefAreaWidth(Node child, Insets margin) {
1702 return computeChildPrefAreaWidth(child, -1, margin, -1, false);
1703 }
1704
1705 double computeChildPrefAreaWidth(Node child, double baselineComplement, Insets margin, double height, boolean fillHeight) {
1706 final boolean snap = isSnapToPixel();
1707 double left = margin != null? snapSpace(margin.getLeft(), snap) : 0;
1708 double right = margin != null? snapSpace(margin.getRight(), snap) : 0;
1709 double alt = -1;
1710 if (height != -1 && child.isResizable() && child.getContentBias() == Orientation.VERTICAL) { // width depends on height
1711 double top = margin != null? snapSpace(margin.getTop(), snap) : 0;
1712 double bottom = margin != null? snapSpace(margin.getBottom(), snap) : 0;
1713 double bo = child.getBaselineOffset();
1714 final double contentHeight = bo == BASELINE_OFFSET_SAME_AS_HEIGHT && baselineComplement != -1 ?
1715 height - top - bottom - baselineComplement :
1716 height - top - bottom;
1717 if (fillHeight) {
1718 alt = snapSize(boundedSize(
1719 child.minHeight(-1), contentHeight,
1720 child.maxHeight(-1)));
1721 } else {
1722 alt = snapSize(boundedSize(
1723 child.minHeight(-1),
1724 child.prefHeight(-1),
1725 Math.min(child.maxHeight(-1), contentHeight)));
1726 }
1727 }
1728 return left + snapSize(boundedSize(child.minWidth(alt), child.prefWidth(alt), child.maxWidth(alt))) + right;
1729 }
1730
1731 double computeChildPrefAreaHeight(Node child, Insets margin) {
1732 return computeChildPrefAreaHeight(child, -1, margin, -1);
1733 }
1734
1735 double computeChildPrefAreaHeight(Node child, double prefBaselineComplement, Insets margin, double width) {
1736 final boolean snap = isSnapToPixel();
1737 double top = margin != null? snapSpace(margin.getTop(), snap) : 0;
1738 double bottom = margin != null? snapSpace(margin.getBottom(), snap) : 0;
1739
1740 double alt = -1;
1741 if (child.isResizable() && child.getContentBias() == Orientation.HORIZONTAL) { // height depends on width
1742 double left = margin != null ? snapSpace(margin.getLeft(), snap) : 0;
1743 double right = margin != null ? snapSpace(margin.getRight(), snap) : 0;
1744 alt = snapSize(boundedSize(
1745 child.minWidth(-1), width != -1 ? width - left - right
1746 : child.prefWidth(-1), child.maxWidth(-1)));
1747 }
1748
1749 if (prefBaselineComplement != -1) {
1750 double baseline = child.getBaselineOffset();
1751 if (child.isResizable() && baseline == BASELINE_OFFSET_SAME_AS_HEIGHT) {
1752 // When baseline is same as height, the preferred height of the node will be above the baseline, so we need to add
1753 // the preferred complement to it
1754 return top + snapSize(boundedSize(child.minHeight(alt), child.prefHeight(alt), child.maxHeight(alt))) + bottom
1755 + prefBaselineComplement;
1756 } else {
1757 // For all other Nodes, it's just their baseline and the complement.
1758 // Note that the complement already contain the Node's preferred (or fixed) height
1759 return top + baseline + prefBaselineComplement + bottom;
1760 }
1761 } else {
1762 return top + snapSize(boundedSize(child.minHeight(alt), child.prefHeight(alt), child.maxHeight(alt))) + bottom;
1763 }
1764 }
1765
1766 double computeChildMaxAreaWidth(Node child, double baselineComplement, Insets margin, double height, boolean fillHeight) {
1767 double max = child.maxWidth(-1);
1768 if (max == Double.MAX_VALUE) {
1769 return max;
1770 }
1771 final boolean snap = isSnapToPixel();
1772 double left = margin != null? snapSpace(margin.getLeft(), snap) : 0;
1773 double right = margin != null? snapSpace(margin.getRight(), snap) : 0;
1774 double alt = -1;
1775 if (height != -1 && child.isResizable() && child.getContentBias() == Orientation.VERTICAL) { // width depends on height
1776 double top = margin != null? snapSpace(margin.getTop(), snap) : 0;
1777 double bottom = (margin != null? snapSpace(margin.getBottom(), snap) : 0);
1778 double bo = child.getBaselineOffset();
1779 final double contentHeight = bo == BASELINE_OFFSET_SAME_AS_HEIGHT && baselineComplement != -1 ?
1780 height - top - bottom - baselineComplement :
1781 height - top - bottom;
1782 if (fillHeight) {
1783 alt = snapSize(boundedSize(
1784 child.minHeight(-1), contentHeight,
1785 child.maxHeight(-1)));
1786 } else {
1787 alt = snapSize(boundedSize(
1788 child.minHeight(-1),
1789 child.prefHeight(-1),
1790 Math.min(child.maxHeight(-1), contentHeight)));
1791 }
1792 max = child.maxWidth(alt);
1793 }
1794 // if min > max, min wins, so still need to call boundedSize()
1795 return left + snapSize(boundedSize(child.minWidth(alt), max, Double.MAX_VALUE)) + right;
1796 }
1797
1798 double computeChildMaxAreaHeight(Node child, double maxBaselineComplement, Insets margin, double width) {
1799 double max = child.maxHeight(-1);
1800 if (max == Double.MAX_VALUE) {
1801 return max;
1802 }
1803
1804 final boolean snap = isSnapToPixel();
1805 double top = margin != null? snapSpace(margin.getTop(), snap) : 0;
1806 double bottom = margin != null? snapSpace(margin.getBottom(), snap) : 0;
1807 double alt = -1;
1808 if (child.isResizable() && child.getContentBias() == Orientation.HORIZONTAL) { // height depends on width
1809 double left = margin != null? snapSpace(margin.getLeft(), snap) : 0;
1810 double right = margin != null? snapSpace(margin.getRight(), snap) : 0;
1811 alt = snapSize(width != -1? boundedSize(child.minWidth(-1), width - left - right, child.maxWidth(-1)) :
1812 child.minWidth(-1));
1813 max = child.maxHeight(alt);
1814 }
1815 // For explanation, see computeChildPrefAreaHeight
1816 if (maxBaselineComplement != -1) {
1817 double baseline = child.getBaselineOffset();
1818 if (child.isResizable() && baseline == BASELINE_OFFSET_SAME_AS_HEIGHT) {
1819 return top + snapSize(boundedSize(child.minHeight(alt), child.maxHeight(alt), Double.MAX_VALUE)) + bottom
1820 + maxBaselineComplement;
1821 } else {
1822 return top + baseline + maxBaselineComplement + bottom;
1823 }
1824 } else {
1825 // if min > max, min wins, so still need to call boundedSize()
1826 return top + snapSize(boundedSize(child.minHeight(alt), max, Double.MAX_VALUE)) + bottom;
1827 }
1828 }
1829
1830 /* Max of children's minimum area widths */
1831
1832 double computeMaxMinAreaWidth(List<Node> children, Callback<Node, Insets> margins) {
1833 return getMaxAreaWidth(children, margins, new double[] { -1 }, false, true);
1834 }
1835
1836 double computeMaxMinAreaWidth(List<Node> children, Callback<Node, Insets> margins, double height, boolean fillHeight) {
1837 return getMaxAreaWidth(children, margins, new double[] { height }, fillHeight, true);
1838 }
1839
1840 double computeMaxMinAreaWidth(List<Node> children, Callback<Node, Insets> childMargins, double childHeights[], boolean fillHeight) {
1841 return getMaxAreaWidth(children, childMargins, childHeights, fillHeight, true);
1842 }
1843
1844 /* Max of children's minimum area heights */
1845
1846 double computeMaxMinAreaHeight(List<Node>children, Callback<Node, Insets> margins, VPos valignment) {
1847 return getMaxAreaHeight(children, margins, null, valignment, true);
1848 }
1849
1850 double computeMaxMinAreaHeight(List<Node>children, Callback<Node, Insets> margins, VPos valignment, double width) {
1851 return getMaxAreaHeight(children, margins, new double[] { width }, valignment, true);
1852 }
1853
1854 double computeMaxMinAreaHeight(List<Node>children, Callback<Node, Insets> childMargins, double childWidths[], VPos valignment) {
1855 return getMaxAreaHeight(children, childMargins, childWidths, valignment, true);
1856 }
1857
1858 /* Max of children's pref area widths */
1859
1860 double computeMaxPrefAreaWidth(List<Node>children, Callback<Node, Insets> margins) {
1861 return getMaxAreaWidth(children, margins, new double[] { -1 }, false, false);
1862 }
1863
1864 double computeMaxPrefAreaWidth(List<Node>children, Callback<Node, Insets> margins, double height,
1865 boolean fillHeight) {
1866 return getMaxAreaWidth(children, margins, new double[] { height }, fillHeight, false);
1867 }
1868
1869 double computeMaxPrefAreaWidth(List<Node>children, Callback<Node, Insets> childMargins,
1870 double childHeights[], boolean fillHeight) {
1871 return getMaxAreaWidth(children, childMargins, childHeights, fillHeight, false);
1872 }
1873
1874 /* Max of children's pref area heights */
1875
1876 double computeMaxPrefAreaHeight(List<Node>children, Callback<Node, Insets> margins, VPos valignment) {
1877 return getMaxAreaHeight(children, margins, null, valignment, false);
1878 }
1879
1880 double computeMaxPrefAreaHeight(List<Node>children, Callback<Node, Insets> margins, double width, VPos valignment) {
1881 return getMaxAreaHeight(children, margins, new double[] { width }, valignment, false);
1882 }
1883
1884 double computeMaxPrefAreaHeight(List<Node>children, Callback<Node, Insets> childMargins, double childWidths[], VPos valignment) {
1885 return getMaxAreaHeight(children, childMargins, childWidths, valignment, false);
1886 }
1887
1888 /**
1889 * Returns the size of a Node that should be placed in an area of the specified size,
1890 * bounded in it's min/max size, respecting bias.
1891 *
1892 * @param node the node
1893 * @param areaWidth the width of the bounding area where the node is going to be placed
1894 * @param areaHeight the height of the bounding area where the node is going to be placed
1895 * @param fillWidth if Node should try to fill the area width
1896 * @param fillHeight if Node should try to fill the area height
1897 * @param result Vec2d object for the result or null if new one should be created
1898 * @return Vec2d object with width(x parameter) and height (y parameter)
1899 */
1900 static Vec2d boundedNodeSizeWithBias(Node node, double areaWidth, double areaHeight,
1901 boolean fillWidth, boolean fillHeight, Vec2d result) {
1902 if (result == null) {
1903 result = new Vec2d();
1904 }
1905
1906 Orientation bias = node.getContentBias();
1907
1908 double childWidth = 0;
1909 double childHeight = 0;
1910
1911 if (bias == null) {
1912 childWidth = boundedSize(
1913 node.minWidth(-1), fillWidth ? areaWidth
1914 : Math.min(areaWidth, node.prefWidth(-1)),
1915 node.maxWidth(-1));
1916 childHeight = boundedSize(
1917 node.minHeight(-1), fillHeight ? areaHeight
1918 : Math.min(areaHeight, node.prefHeight(-1)),
1919 node.maxHeight(-1));
1920
1921 } else if (bias == Orientation.HORIZONTAL) {
1922 childWidth = boundedSize(
1923 node.minWidth(-1), fillWidth ? areaWidth
1924 : Math.min(areaWidth, node.prefWidth(-1)),
1925 node.maxWidth(-1));
1926 childHeight = boundedSize(
1927 node.minHeight(childWidth), fillHeight ? areaHeight
1928 : Math.min(areaHeight, node.prefHeight(childWidth)),
1929 node.maxHeight(childWidth));
1930
1931 } else { // bias == VERTICAL
1932 childHeight = boundedSize(
1933 node.minHeight(-1), fillHeight ? areaHeight
1934 : Math.min(areaHeight, node.prefHeight(-1)),
1935 node.maxHeight(-1));
1936 childWidth = boundedSize(
1937 node.minWidth(childHeight), fillWidth ? areaWidth
1938 : Math.min(areaWidth, node.prefWidth(childHeight)),
1939 node.maxWidth(childHeight));
1940 }
1941
1942 result.set(childWidth, childHeight);
1943 return result;
1944 }
1945
1946 /* utility method for computing the max of children's min or pref heights, taking into account baseline alignment */
1947 private double getMaxAreaHeight(List<Node> children, Callback<Node,Insets> childMargins, double childWidths[], VPos valignment, boolean minimum) {
1948 final double singleChildWidth = childWidths == null ? -1 : childWidths.length == 1 ? childWidths[0] : Double.NaN;
1949 if (valignment == VPos.BASELINE) {
1950 double maxAbove = 0;
1951 double maxBelow = 0;
1952 for (int i = 0, maxPos = children.size(); i < maxPos; i++) {
1953 final Node child = children.get(i);
1954 final double childWidth = Double.isNaN(singleChildWidth) ? childWidths[i] : singleChildWidth;
1955 Insets margin = childMargins.call(child);
1956 final double top = margin != null? snapSpace(margin.getTop()) : 0;
1957 final double bottom = margin != null? snapSpace(margin.getBottom()) : 0;
1958 final double baseline = child.getBaselineOffset();
1959
1960 final double childHeight = minimum? snapSize(child.minHeight(childWidth)) : snapSize(child.prefHeight(childWidth));
1961 if (baseline == BASELINE_OFFSET_SAME_AS_HEIGHT) {
1962 maxAbove = Math.max(maxAbove, childHeight + top);
1963 } else {
1964 maxAbove = Math.max(maxAbove, baseline + top);
1965 maxBelow = Math.max(maxBelow,
1966 snapSpace(minimum?snapSize(child.minHeight(childWidth)) : snapSize(child.prefHeight(childWidth))) -
1967 baseline + bottom);
1968 }
1969 }
1970 return maxAbove + maxBelow; //remind(aim): ceil this value?
1971 } else {
1972 double max = 0;
1973 for (int i = 0, maxPos = children.size(); i < maxPos; i++) {
1974 final Node child = children.get(i);
1975 Insets margin = childMargins.call(child);
1976 final double childWidth = Double.isNaN(singleChildWidth) ? childWidths[i] : singleChildWidth;
1977 max = Math.max(max, minimum?
1978 computeChildMinAreaHeight(child, -1, margin, childWidth) :
1979 computeChildPrefAreaHeight(child, -1, margin, childWidth));
1980 }
1981 return max;
1982 }
1983 }
1984
1985 /* utility method for computing the max of children's min or pref width, horizontal alignment is ignored for now */
1986 private double getMaxAreaWidth(List<javafx.scene.Node> children,
1987 Callback<Node, Insets> childMargins, double childHeights[], boolean fillHeight, boolean minimum) {
1988 final double singleChildHeight = childHeights == null ? -1 : childHeights.length == 1 ? childHeights[0] : Double.NaN;
1989
1990 double max = 0;
1991 for (int i = 0, maxPos = children.size(); i < maxPos; i++) {
1992 final Node child = children.get(i);
1993 final Insets margin = childMargins.call(child);
1994 final double childHeight = Double.isNaN(singleChildHeight) ? childHeights[i] : singleChildHeight;
1995 max = Math.max(max, minimum?
1996 computeChildMinAreaWidth(children.get(i), -1, margin, childHeight, fillHeight) :
1997 computeChildPrefAreaWidth(child, -1, margin, childHeight, fillHeight));
1998 }
1999 return max;
2000 }
2001
2002 /**
2003 * Utility method which positions the child within an area of this
2004 * region defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2005 * with a baseline offset relative to that area.
2006 * <p>
2007 * This function does <i>not</i> resize the node and uses the node's layout bounds
2008 * width and height to determine how it should be positioned within the area.
2009 * <p>
2010 * If the vertical alignment is {@code VPos.BASELINE} then it
2011 * will position the node so that its own baseline aligns with the passed in
2012 * {@code baselineOffset}, otherwise the baseline parameter is ignored.
2013 * <p>
2014 * If {@code snapToPixel} is {@code true} for this region, then the x/y position
2015 * values will be rounded to their nearest pixel boundaries.
2016 *
2017 * @param child the child being positioned within this region
2018 * @param areaX the horizontal offset of the layout area relative to this region
2019 * @param areaY the vertical offset of the layout area relative to this region
2020 * @param areaWidth the width of the layout area
2021 * @param areaHeight the height of the layout area
2022 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2023 * @param halignment the horizontal alignment for the child within the area
2024 * @param valignment the vertical alignment for the child within the area
2025 *
2026 */
2027 protected void positionInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
2028 double areaBaselineOffset, HPos halignment, VPos valignment) {
2029 positionInArea(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset,
2030 Insets.EMPTY, halignment, valignment, isSnapToPixel());
2031 }
2032
2033 /**
2034 * Utility method which positions the child within an area of this
2035 * region defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2036 * with a baseline offset relative to that area.
2037 * <p>
2038 * This function does <i>not</i> resize the node and uses the node's layout bounds
2039 * width and height to determine how it should be positioned within the area.
2040 * <p>
2041 * If the vertical alignment is {@code VPos.BASELINE} then it
2042 * will position the node so that its own baseline aligns with the passed in
2043 * {@code baselineOffset}, otherwise the baseline parameter is ignored.
2044 * <p>
2045 * If {@code snapToPixel} is {@code true} for this region, then the x/y position
2046 * values will be rounded to their nearest pixel boundaries.
2047 * <p>
2048 * If {@code margin} is non-null, then that space will be allocated around the
2049 * child within the layout area. margin may be null.
2050 *
2051 * @param child the child being positioned within this region
2052 * @param areaX the horizontal offset of the layout area relative to this region
2053 * @param areaY the vertical offset of the layout area relative to this region
2054 * @param areaWidth the width of the layout area
2055 * @param areaHeight the height of the layout area
2056 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2057 * @param margin the margin of space to be allocated around the child
2058 * @param halignment the horizontal alignment for the child within the area
2059 * @param valignment the vertical alignment for the child within the area
2060 *
2061 * @since JavaFX 8.0
2062 */
2063 public static void positionInArea(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
2064 double areaBaselineOffset, Insets margin, HPos halignment, VPos valignment, boolean isSnapToPixel) {
2065 Insets childMargin = margin != null? margin : Insets.EMPTY;
2066
2067 position(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset,
2068 snapSpace(childMargin.getTop(), isSnapToPixel),
2069 snapSpace(childMargin.getRight(), isSnapToPixel),
2070 snapSpace(childMargin.getBottom(), isSnapToPixel),
2071 snapSpace(childMargin.getLeft(), isSnapToPixel),
2072 halignment, valignment, isSnapToPixel);
2073 }
2074
2075 /**
2076 * Utility method which lays out the child within an area of this
2077 * region defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2078 * with a baseline offset relative to that area.
2079 * <p>
2080 * If the child is resizable, this method will resize it to fill the specified
2081 * area unless the node's maximum size prevents it. If the node's maximum
2082 * size preference is less than the area size, the maximum size will be used.
2083 * If node's maximum is greater than the area size, then the node will be
2084 * resized to fit within the area, unless its minimum size prevents it.
2085 * <p>
2086 * If the child has a non-null contentBias, then this method will use it when
2087 * resizing the child. If the contentBias is horizontal, it will set its width
2088 * first to the area's width (up to the child's max width limit) and then pass
2089 * that value to compute the child's height. If child's contentBias is vertical,
2090 * then it will set its height to the area height (up to child's max height limit)
2091 * and pass that height to compute the child's width. If the child's contentBias
2092 * is null, then it's width and height have no dependencies on each other.
2093 * <p>
2094 * If the child is not resizable (Shape, Group, etc) then it will only be
2095 * positioned and not resized.
2096 * <p>
2097 * If the child's resulting size differs from the area's size (either
2098 * because it was not resizable or it's sizing preferences prevented it), then
2099 * this function will align the node relative to the area using horizontal and
2100 * vertical alignment values.
2101 * If valignment is {@code VPos.BASELINE} then the node's baseline will be aligned
2102 * with the area baseline offset parameter, otherwise the baseline parameter
2103 * is ignored.
2104 * <p>
2105 * If {@code snapToPixel} is {@code true} for this region, then the resulting x,y
2106 * values will be rounded to their nearest pixel boundaries and the
2107 * width/height values will be ceiled to the next pixel boundary.
2108 *
2109 * @param child the child being positioned within this region
2110 * @param areaX the horizontal offset of the layout area relative to this region
2111 * @param areaY the vertical offset of the layout area relative to this region
2112 * @param areaWidth the width of the layout area
2113 * @param areaHeight the height of the layout area
2114 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2115 * @param halignment the horizontal alignment for the child within the area
2116 * @param valignment the vertical alignment for the child within the area
2117 *
2118 */
2119 protected void layoutInArea(Node child, double areaX, double areaY,
2120 double areaWidth, double areaHeight,
2121 double areaBaselineOffset,
2122 HPos halignment, VPos valignment) {
2123 layoutInArea(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset,
2124 Insets.EMPTY, halignment, valignment);
2125 }
2126
2127 /**
2128 * Utility method which lays out the child within an area of this
2129 * region defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2130 * with a baseline offset relative to that area.
2131 * <p>
2132 * If the child is resizable, this method will resize it to fill the specified
2133 * area unless the node's maximum size prevents it. If the node's maximum
2134 * size preference is less than the area size, the maximum size will be used.
2135 * If node's maximum is greater than the area size, then the node will be
2136 * resized to fit within the area, unless its minimum size prevents it.
2137 * <p>
2138 * If the child has a non-null contentBias, then this method will use it when
2139 * resizing the child. If the contentBias is horizontal, it will set its width
2140 * first to the area's width (up to the child's max width limit) and then pass
2141 * that value to compute the child's height. If child's contentBias is vertical,
2142 * then it will set its height to the area height (up to child's max height limit)
2143 * and pass that height to compute the child's width. If the child's contentBias
2144 * is null, then it's width and height have no dependencies on each other.
2145 * <p>
2146 * If the child is not resizable (Shape, Group, etc) then it will only be
2147 * positioned and not resized.
2148 * <p>
2149 * If the child's resulting size differs from the area's size (either
2150 * because it was not resizable or it's sizing preferences prevented it), then
2151 * this function will align the node relative to the area using horizontal and
2152 * vertical alignment values.
2153 * If valignment is {@code VPos.BASELINE} then the node's baseline will be aligned
2154 * with the area baseline offset parameter, otherwise the baseline parameter
2155 * is ignored.
2156 * <p>
2157 * If {@code margin} is non-null, then that space will be allocated around the
2158 * child within the layout area. margin may be null.
2159 * <p>
2160 * If {@code snapToPixel} is {@code true} for this region, then the resulting x,y
2161 * values will be rounded to their nearest pixel boundaries and the
2162 * width/height values will be ceiled to the next pixel boundary.
2163 *
2164 * @param child the child being positioned within this region
2165 * @param areaX the horizontal offset of the layout area relative to this region
2166 * @param areaY the vertical offset of the layout area relative to this region
2167 * @param areaWidth the width of the layout area
2168 * @param areaHeight the height of the layout area
2169 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2170 * @param margin the margin of space to be allocated around the child
2171 * @param halignment the horizontal alignment for the child within the area
2172 * @param valignment the vertical alignment for the child within the area
2173 */
2174 protected void layoutInArea(Node child, double areaX, double areaY,
2175 double areaWidth, double areaHeight,
2176 double areaBaselineOffset,
2177 Insets margin,
2178 HPos halignment, VPos valignment) {
2179 layoutInArea(child, areaX, areaY, areaWidth, areaHeight,
2180 areaBaselineOffset, margin, true, true, halignment, valignment);
2181 }
2182
2183 /**
2184 * Utility method which lays out the child within an area of this
2185 * region defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2186 * with a baseline offset relative to that area.
2187 * <p>
2188 * If the child is resizable, this method will use {@code fillWidth} and {@code fillHeight}
2189 * to determine whether to resize it to fill the area or keep the child at its
2190 * preferred dimension. If fillWidth/fillHeight are true, then this method
2191 * will only resize the child up to its max size limits. If the node's maximum
2192 * size preference is less than the area size, the maximum size will be used.
2193 * If node's maximum is greater than the area size, then the node will be
2194 * resized to fit within the area, unless its minimum size prevents it.
2195 * <p>
2196 * If the child has a non-null contentBias, then this method will use it when
2197 * resizing the child. If the contentBias is horizontal, it will set its width
2198 * first and then pass that value to compute the child's height. If child's
2199 * contentBias is vertical, then it will set its height first
2200 * and pass that value to compute the child's width. If the child's contentBias
2201 * is null, then it's width and height have no dependencies on each other.
2202 * <p>
2203 * If the child is not resizable (Shape, Group, etc) then it will only be
2204 * positioned and not resized.
2205 * <p>
2206 * If the child's resulting size differs from the area's size (either
2207 * because it was not resizable or it's sizing preferences prevented it), then
2208 * this function will align the node relative to the area using horizontal and
2209 * vertical alignment values.
2210 * If valignment is {@code VPos.BASELINE} then the node's baseline will be aligned
2211 * with the area baseline offset parameter, otherwise the baseline parameter
2212 * is ignored.
2213 * <p>
2214 * If {@code margin} is non-null, then that space will be allocated around the
2215 * child within the layout area. margin may be null.
2216 * <p>
2217 * If {@code snapToPixel} is {@code true} for this region, then the resulting x,y
2218 * values will be rounded to their nearest pixel boundaries and the
2219 * width/height values will be ceiled to the next pixel boundary.
2220 *
2221 * @param child the child being positioned within this region
2222 * @param areaX the horizontal offset of the layout area relative to this region
2223 * @param areaY the vertical offset of the layout area relative to this region
2224 * @param areaWidth the width of the layout area
2225 * @param areaHeight the height of the layout area
2226 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2227 * @param margin the margin of space to be allocated around the child
2228 * @param fillWidth whether or not the child should be resized to fill the area width or kept to its preferred width
2229 * @param fillHeight whether or not the child should e resized to fill the area height or kept to its preferred height
2230 * @param halignment the horizontal alignment for the child within the area
2231 * @param valignment the vertical alignment for the child within the area
2232 */
2233 protected void layoutInArea(Node child, double areaX, double areaY,
2234 double areaWidth, double areaHeight,
2235 double areaBaselineOffset,
2236 Insets margin, boolean fillWidth, boolean fillHeight,
2237 HPos halignment, VPos valignment) {
2238 layoutInArea(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset, margin, fillWidth, fillHeight, halignment, valignment, isSnapToPixel());
2239 }
2240
2241 /**
2242 * Utility method which lays out the child within an area of it's
2243 * parent defined by {@code areaX}, {@code areaY}, {@code areaWidth} x {@code areaHeight},
2244 * with a baseline offset relative to that area.
2245 * <p>
2246 * If the child is resizable, this method will use {@code fillWidth} and {@code fillHeight}
2247 * to determine whether to resize it to fill the area or keep the child at its
2248 * preferred dimension. If fillWidth/fillHeight are true, then this method
2249 * will only resize the child up to its max size limits. If the node's maximum
2250 * size preference is less than the area size, the maximum size will be used.
2251 * If node's maximum is greater than the area size, then the node will be
2252 * resized to fit within the area, unless its minimum size prevents it.
2253 * <p>
2254 * If the child has a non-null contentBias, then this method will use it when
2255 * resizing the child. If the contentBias is horizontal, it will set its width
2256 * first and then pass that value to compute the child's height. If child's
2257 * contentBias is vertical, then it will set its height first
2258 * and pass that value to compute the child's width. If the child's contentBias
2259 * is null, then it's width and height have no dependencies on each other.
2260 * <p>
2261 * If the child is not resizable (Shape, Group, etc) then it will only be
2262 * positioned and not resized.
2263 * <p>
2264 * If the child's resulting size differs from the area's size (either
2265 * because it was not resizable or it's sizing preferences prevented it), then
2266 * this function will align the node relative to the area using horizontal and
2267 * vertical alignment values.
2268 * If valignment is {@code VPos.BASELINE} then the node's baseline will be aligned
2269 * with the area baseline offset parameter, otherwise the baseline parameter
2270 * is ignored.
2271 * <p>
2272 * If {@code margin} is non-null, then that space will be allocated around the
2273 * child within the layout area. margin may be null.
2274 * <p>
2275 * If {@code snapToPixel} is {@code true} for this region, then the resulting x,y
2276 * values will be rounded to their nearest pixel boundaries and the
2277 * width/height values will be ceiled to the next pixel boundary.
2278 *
2279 * @param child the child being positioned within this region
2280 * @param areaX the horizontal offset of the layout area relative to this region
2281 * @param areaY the vertical offset of the layout area relative to this region
2282 * @param areaWidth the width of the layout area
2283 * @param areaHeight the height of the layout area
2284 * @param areaBaselineOffset the baseline offset to be used if VPos is BASELINE
2285 * @param margin the margin of space to be allocated around the child
2286 * @param fillWidth whether or not the child should be resized to fill the area width or kept to its preferred width
2287 * @param fillHeight whether or not the child should e resized to fill the area height or kept to its preferred height
2288 * @param halignment the horizontal alignment for the child within the area
2289 * @param valignment the vertical alignment for the child within the area
2290 * @param isSnapToPixel whether to snap size and position to pixels
2291 * @since JavaFX 8.0
2292 */
2293 public static void layoutInArea(Node child, double areaX, double areaY,
2294 double areaWidth, double areaHeight,
2295 double areaBaselineOffset,
2296 Insets margin, boolean fillWidth, boolean fillHeight,
2297 HPos halignment, VPos valignment, boolean isSnapToPixel) {
2298
2299 Insets childMargin = margin != null ? margin : Insets.EMPTY;
2300
2301 double top = snapSpace(childMargin.getTop(), isSnapToPixel);
2302 double bottom = snapSpace(childMargin.getBottom(), isSnapToPixel);
2303 double left = snapSpace(childMargin.getLeft(), isSnapToPixel);
2304 double right = snapSpace(childMargin.getRight(), isSnapToPixel);
2305
2306 if (valignment == VPos.BASELINE) {
2307 double bo = child.getBaselineOffset();
2308 if (bo == BASELINE_OFFSET_SAME_AS_HEIGHT) {
2309 if (child.isResizable()) {
2310 // Everything below the baseline is like an "inset". The Node with BASELINE_OFFSET_SAME_AS_HEIGHT cannot
2311 // be resized to this area
2312 bottom += snapSpace(areaHeight - areaBaselineOffset, isSnapToPixel);
2313 } else {
2314 top = snapSpace(areaBaselineOffset - child.getLayoutBounds().getHeight(), isSnapToPixel);
2315 }
2316 } else {
2317 top = snapSpace(areaBaselineOffset - bo, isSnapToPixel);
2318 }
2319 }
2320
2321
2322 if (child.isResizable()) {
2323 Vec2d size = boundedNodeSizeWithBias(child, areaWidth - left - right, areaHeight - top - bottom,
2324 fillWidth, fillHeight, TEMP_VEC2D);
2325 child.resize(snapSize(size.x, isSnapToPixel),snapSize(size.y, isSnapToPixel));
2326 }
2327 position(child, areaX, areaY, areaWidth, areaHeight, areaBaselineOffset,
2328 top, right, bottom, left, halignment, valignment, isSnapToPixel);
2329 }
2330
2331 private static void position(Node child, double areaX, double areaY, double areaWidth, double areaHeight,
2332 double areaBaselineOffset,
2333 double topMargin, double rightMargin, double bottomMargin, double leftMargin,
2334 HPos hpos, VPos vpos, boolean isSnapToPixel) {
2335 final double xoffset = leftMargin + computeXOffset(areaWidth - leftMargin - rightMargin,
2336 child.getLayoutBounds().getWidth(), hpos);
2337 final double yoffset;
2338 if (vpos == VPos.BASELINE) {
2339 double bo = child.getBaselineOffset();
2340 if (bo == BASELINE_OFFSET_SAME_AS_HEIGHT) {
2341 // We already know the layout bounds at this stage, so we can use them
2342 yoffset = areaBaselineOffset - child.getLayoutBounds().getHeight();
2343 } else {
2344 yoffset = areaBaselineOffset - bo;
2345 }
2346 } else {
2347 yoffset = topMargin + computeYOffset(areaHeight - topMargin - bottomMargin,
2348 child.getLayoutBounds().getHeight(), vpos);
2349 }
2350 final double x = snapPosition(areaX + xoffset, isSnapToPixel);
2351 final double y = snapPosition(areaY + yoffset, isSnapToPixel);
2352
2353 child.relocate(x,y);
2354 }
2355
2356 /**************************************************************************
2357 * *
2358 * PG Implementation *
2359 * *
2360 **************************************************************************/
2361
2362 /** @treatAsPrivate */
2363 @Override public void impl_updatePeer() {
2364 // TODO I think we have a bug, where if you create a Region with an Image that hasn't
2365 // been loaded, we have no listeners on that image so as to cause a pulse & repaint
2366 // to happen once the image is loaded. We just assume the image has been loaded
2367 // (since when the image is created using new Image(url) or CSS it happens eagerly).
2368 super.impl_updatePeer();
2369 if (_shape != null) _shape.impl_syncPeer();
2370 NGRegion pg = impl_getPeer();
2371
2372 if (!cornersValid) {
2373 validateCorners();
2374 }
2375
2376 final boolean sizeChanged = impl_isDirty(DirtyBits.NODE_GEOMETRY);
2377 if (sizeChanged) {
2378 pg.setSize((float)getWidth(), (float)getHeight());
2379 }
2380
2381 // NOTE: The order here is very important. There is logic in NGRegion which determines
2382 // whether we can cache an image representing this region, and for this to work correctly,
2383 // the shape must be specified before the background which is before the border.
2384 final boolean shapeChanged = impl_isDirty(DirtyBits.REGION_SHAPE);
2385 if (shapeChanged) {
2386 pg.updateShape(_shape, isScaleShape(), isCenterShape(), isCacheShape());
2387 }
2388
2389 // The normalized corners can always be updated since they require no
2390 // processing at the NG layer.
2391 pg.updateFillCorners(normalizedFillCorners);
2392 final boolean backgroundChanged = impl_isDirty(DirtyBits.SHAPE_FILL);
2393 final Background bg = getBackground();
2394 if (backgroundChanged) {
2395 pg.updateBackground(bg);
2396 }
2397
2398 // This will be true if an image that makes up the background or border of this
2399 // region has changed, such that we need to redraw the region.
2400 if (impl_isDirty(DirtyBits.NODE_CONTENTS)) {
2401 pg.imagesUpdated();
2402 }
2403
2404 // The normalized corners can always be updated since they require no
2405 // processing at the NG layer.
2406 pg.updateStrokeCorners(normalizedStrokeCorners);
2407 if (impl_isDirty(DirtyBits.SHAPE_STROKE)) {
2408 pg.updateBorder(getBorder());
2409 }
2410
2411 // TODO given the note above, this *must* be called when an image which makes up the
2412 // background images and border images changes (is loaded) if it was being loaded asynchronously
2413 // Also note, one day we can add support for automatic opaque insets determination for border images.
2414 // However right now it is impractical because the image pixel format is almost undoubtedly going
2415 // to have alpha, and so without inspecting the source image's actual pixels for the filled center
2416 // we can't automatically determine whether the interior is filled.
2417 if (sizeChanged || backgroundChanged || shapeChanged) {
2418 // These are the opaque insets, as specified by the developer in code or CSS. If null,
2419 // then we must compute the opaque insets. If not null, then we will still compute the
2420 // opaque insets and combine them with these insets, as appropriate. We do ignore these
2421 // developer specified insets in cases where we know without a doubt that the developer
2422 // gave us bad data.
2423 final Insets i = getOpaqueInsets();
2424
2425 // If the background is determined by a shape, then we don't attempt to calculate the
2426 // opaque insets. If the developer specified opaque insets, we will use them, otherwise
2427 // we will make sure the opaque insets are cleared
2428 if (_shape != null) {
2429 if (i != null) {
2430 pg.setOpaqueInsets((float) i.getTop(), (float) i.getRight(),
2431 (float) i.getBottom(), (float) i.getLeft());
2432 } else {
2433 pg.setOpaqueInsets(Float.NaN, Float.NaN, Float.NaN, Float.NaN);
2434 }
2435 } else {
2436 // This is a rectangle (not shape) region. The opaque insets must be calculated,
2437 // even if the developer has supplied their own opaque insets. The first (and cheapest)
2438 // check is whether the region has any backgrounds at all. If not, then
2439 // we will ignore the developer supplied insets because they are clearly wrong.
2440 if (bg == null || bg.isEmpty()) {
2441 pg.setOpaqueInsets(Float.NaN, Float.NaN, Float.NaN, Float.NaN);
2442 } else {
2443 // There is a background, so it is conceivable that there are
2444 // opaque insets. From this point on, we have to honor the developer's supplied
2445 // insets, only expanding them if we know for certain the opaque insets are
2446 // bigger than what was supplied by the developer. Start by defining our initial
2447 // values for top, right, bottom, and left. If the developer supplied us
2448 // insets, use those. Otherwise initialize to NaN. Note that the developer may
2449 // also have given us NaN values (so we'd have to check for these anyway). We use
2450 // NaN to mean "not defined".
2451 final double[] trbl = new double[4];
2452 bg.computeOpaqueInsets(getWidth(), getHeight(), trbl);
2453
2454 if (i != null) {
2455 trbl[0] = Double.isNaN(trbl[0]) ? i.getTop() : Double.isNaN(i.getTop()) ? trbl[0] : Math.min(trbl[0], i.getTop());
2456 trbl[1] = Double.isNaN(trbl[1]) ? i.getRight() : Double.isNaN(i.getRight()) ? trbl[1] : Math.min(trbl[1], i.getRight());
2457 trbl[2] = Double.isNaN(trbl[2]) ? i.getBottom() : Double.isNaN(i.getBottom()) ? trbl[2] : Math.min(trbl[2], i.getBottom());
2458 trbl[3] = Double.isNaN(trbl[3]) ? i.getLeft() : Double.isNaN(i.getLeft()) ? trbl[3] : Math.min(trbl[3], i.getLeft());
2459 }
2460
2461 // Now set the insets onto the peer. Passing NaN here is perfectly
2462 // acceptable (even encouraged, to mean "unknown" or "disabled").
2463 pg.setOpaqueInsets((float) trbl[0], (float) trbl[1], (float) trbl[2], (float) trbl[3]);
2464 }
2465 }
2466 }
2467 }
2468
2469 /** @treatAsPrivate */
2470 @Override public NGNode impl_createPeer() {
2471 return new NGRegion();
2472 }
2473
2474 /**
2475 * Transform x, y in local Region coordinates to local coordinates of scaled/centered shape and
2476 * check if the shape contains the coordinates.
2477 * The transformations here are basically an inversion of transformations being done in NGShape#resizeShape.
2478 */
2479 private boolean shapeContains(com.sun.javafx.geom.Shape shape,
2480 final double x, final double y,
2481 double topOffset, double rightOffset, double bottomOffset, double leftOffset) {
2482 double resX = x;
2483 double resY = y;
2484 // The bounds of the shape, before any centering / scaling takes place
2485 final RectBounds bounds = shape.getBounds();
2486 if (isScaleShape()) {
2487 // Modify the transform to scale the shape so that it will fit
2488 // within the insets.
2489 resX -= leftOffset;
2490 resY -= topOffset;
2491
2492 //denominator represents the width and height of the box within which the new shape must fit.
2493 resX *= bounds.getWidth() / (getWidth() - leftOffset - rightOffset);
2494 resY *= bounds.getHeight() / (getHeight() - topOffset - bottomOffset);
2495
2496 // If we also need to center it, we need to adjust the transform so as to place
2497 // the shape in the center of the bounds
2498 if (isCenterShape()) {
2499 resX += bounds.getMinX();
2500 resY += bounds.getMinY();
2501 }
2502 } else if (isCenterShape()) {
2503 // We are only centering. In this case, what we want is for the
2504 // original shape to be centered. If there are offsets (insets)
2505 // then we must pre-scale about the center to account for it.
2506
2507 double boundsWidth = bounds.getWidth();
2508 double boundsHeight = bounds.getHeight();
2509
2510 double scaleFactorX = boundsWidth / (boundsWidth - leftOffset - rightOffset);
2511 double scaleFactorY = boundsHeight / (boundsHeight - topOffset - bottomOffset);
2512
2513 //This is equivalent to:
2514 // translate(bounds.getMinX(), bounds.getMinY())
2515 // scale(scaleFactorX, scaleFactorY)
2516 // translate(-bounds.getMinX(), -bounds.getMinY())
2517 // translate(-leftOffset - (getWidth() - boundsWidth)/2 + bounds.getMinX(),
2518 // -topOffset - (getHeight() - boundsHeight)/2 + bounds.getMinY());
2519 // which is an inversion of an transformation done to the shape
2520 // This gives us
2521 //
2522 //resX = resX * scaleFactorX - scaleFactorX * bounds.getMinX() - scaleFactorX * (leftOffset + (getWidth() - boundsWidth) / 2 - bounds.getMinX()) + bounds.getMinX();
2523 //resY = resY * scaleFactorY - scaleFactorY * bounds.getMinY() - scaleFactorY * (topOffset + (getHeight() - boundsHeight) / 2 - bounds.getMinY()) + bounds.getMinY();
2524 //
2525 // which can further reduced to
2526
2527 resX = scaleFactorX * (resX -(leftOffset + (getWidth() - boundsWidth) / 2)) + bounds.getMinX();
2528 resY = scaleFactorY * (resY -(topOffset + (getHeight() - boundsHeight) / 2)) + bounds.getMinY();
2529
2530 } else if (topOffset != 0 || rightOffset != 0 || bottomOffset != 0 || leftOffset != 0) {
2531 // We are neither centering nor scaling, but we still have to resize the
2532 // shape because we have to fit within the bounds defined by the offsets
2533 double scaleFactorX = bounds.getWidth() / (bounds.getWidth() - leftOffset - rightOffset);
2534 double scaleFactorY = bounds.getHeight() / (bounds.getHeight() - topOffset - bottomOffset);
2535
2536 // This is equivalent to:
2537 // translate(bounds.getMinX(), bounds.getMinY())
2538 // scale(scaleFactorX, scaleFactorY)
2539 // translate(-bounds.getMinX(), -bounds.getMinY())
2540 // translate(-leftOffset, -topOffset)
2541 //
2542 // which is an inversion of an transformation done to the shape
2543 // This gives us
2544 //
2545 //resX = resX * scaleFactorX - scaleFactorX * leftOffset - scaleFactorX * bounds.getMinX() + bounds.getMinX();
2546 //resY = resY * scaleFactorY - scaleFactorY * topOffset - scaleFactorY * bounds.getMinY() + bounds.getMinY();
2547 //
2548 // which can be further reduceD to
2549 resX = scaleFactorX * (resX - leftOffset - bounds.getMinX()) + bounds.getMinX();
2550 resY = scaleFactorY * (resY - topOffset - bounds.getMinY()) + bounds.getMinY();
2551
2552 }
2553 return shape.contains((float)resX, (float)resY);
2554 }
2555
2556 /**
2557 * @treatAsPrivate implementation detail
2558 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
2559 */
2560 @Deprecated
2561 @Override protected boolean impl_computeContains(double localX, double localY) {
2562 // NOTE: This method only gets called if a quick check of bounds has already
2563 // occurred, so there is no need to test against bound again. We know that the
2564 // point (localX, localY) falls within the bounds of this node, now we need
2565 // to determine if it falls within the geometry of this node.
2566 // Also note that because Region defaults pickOnBounds to true, this code is
2567 // not usually executed. It will only be executed if pickOnBounds is set to false.
2568
2569 final double x2 = getWidth();
2570 final double y2 = getHeight();
2571
2572 final Background background = getBackground();
2573 // First check the shape. Shape could be impacted by scaleShape & positionShape properties.
2574 if (_shape != null) {
2575 if (background != null && !background.getFills().isEmpty()) {
2576 final List<BackgroundFill> fills = background.getFills();
2577 double topO = Double.MAX_VALUE;
2578 double leftO = Double.MAX_VALUE;
2579 double bottomO = Double.MAX_VALUE;
2580 double rightO = Double.MAX_VALUE;
2581 for (int i = 0, max = fills.size(); i < max; i++) {
2582 BackgroundFill bf = fills.get(0);
2583 topO = Math.min(topO, bf.getInsets().getTop());
2584 leftO = Math.min(leftO, bf.getInsets().getLeft());
2585 bottomO = Math.min(bottomO, bf.getInsets().getBottom());
2586 rightO = Math.min(rightO, bf.getInsets().getRight());
2587 }
2588 return shapeContains(_shape.impl_configShape(), localX, localY, topO, leftO, bottomO, rightO);
2589 }
2590 return false;
2591 }
2592
2593 // OK, there was no background shape, so I'm going to work on the principle of
2594 // nested rounded rectangles. We'll start by checking the backgrounds. The
2595 // first background which passes the test is good enough for us!
2596 if (background != null) {
2597 final List<BackgroundFill> fills = background.getFills();
2598 for (int i = 0, max = fills.size(); i < max; i++) {
2599 final BackgroundFill bgFill = fills.get(i);
2600 if (contains(localX, localY, 0, 0, x2, y2, bgFill.getInsets(), getNormalizedFillCorner(i))) {
2601 return true;
2602 }
2603 }
2604 }
2605
2606 // If we are here then either there were no background fills or there were no background
2607 // fills which contained the point, and the region is not defined by a shape.
2608 final Border border = getBorder();
2609 if (border != null) {
2610 // Check all the stroke borders first. If the pick occurs on any stroke border
2611 // then we consider the contains test to have passed. Semantically we will treat a Region
2612 // with a border as if it were a rectangle with a stroke but no fill.
2613 final List<BorderStroke> strokes = border.getStrokes();
2614 for (int i=0, max=strokes.size(); i<max; i++) {
2615 final BorderStroke strokeBorder = strokes.get(i);
2616 if (contains(localX, localY, 0, 0, x2, y2, strokeBorder.getWidths(), false, strokeBorder.getInsets(),
2617 getNormalizedStrokeCorner(i))) {
2618 return true;
2619 }
2620 }
2621
2622 // Check the image borders. We treat the image border as though it is opaque.
2623 final List<BorderImage> images = border.getImages();
2624 for (int i = 0, max = images.size(); i < max; i++) {
2625 final BorderImage borderImage = images.get(i);
2626 if (contains(localX, localY, 0, 0, x2, y2, borderImage.getWidths(), borderImage.isFilled(),
2627 borderImage.getInsets(), CornerRadii.EMPTY)) {
2628 return true;
2629 }
2630 }
2631 }
2632 return false;
2633 }
2634
2635 /**
2636 * Basically we will perform two contains tests. For a point to be on the stroke, it must
2637 * be within the outermost edge of the stroke, but outside the innermost edge of the stroke.
2638 * Unless it is filled, in which case it is really just a normal contains test.
2639 *
2640 * @param px The x position of the point to test
2641 * @param py The y position of the point to test
2642 * @param x1 The x1 position of the bounds to test
2643 * @param y1 The y1 position of the bounds to test
2644 * @param x2 The x2 position of the bounds to test
2645 * @param y2 The y2 position of the bounds to test
2646 * @param widths The widths of the stroke on each side
2647 * @param filled Whether the area is filled or is just stroked
2648 * @param insets The insets to apply to (x1,y1)-(x2,y2) to get the final bounds to test
2649 * @param rad The corner radii to test with. Must not be null.
2650 * @param maxRadius The maximum possible radius value
2651 * @return True if (px, py) is within the stroke, taking into account insets and corner radii.
2652 */
2653 private boolean contains(final double px, final double py,
2654 final double x1, final double y1, final double x2, final double y2,
2655 BorderWidths widths, boolean filled,
2656 final Insets insets, final CornerRadii rad) {
2657 if (filled) {
2658 if (contains(px, py, x1, y1, x2, y2, insets, rad)) {
2659 return true;
2660 }
2661 } else {
2662 boolean insideOuterEdge = contains(px, py, x1, y1, x2, y2, insets, rad);
2663 if (insideOuterEdge) {
2664 boolean outsideInnerEdge = !contains(px, py,
2665 x1 + (widths.isLeftAsPercentage() ? getWidth() * widths.getLeft() : widths.getLeft()),
2666 y1 + (widths.isTopAsPercentage() ? getHeight() * widths.getTop() : widths.getTop()),
2667 x2 - (widths.isRightAsPercentage() ? getWidth() * widths.getRight() : widths.getRight()),
2668 y2 - (widths.isBottomAsPercentage() ? getHeight() * widths.getBottom() : widths.getBottom()),
2669 insets, rad);
2670 if (outsideInnerEdge) return true;
2671 }
2672 }
2673 return false;
2674 }
2675
2676 /**
2677 * Determines whether the point (px, py) is contained within the the bounds (x1, y1)-(x2, y2),
2678 * after taking into account the insets and the corner radii.
2679 *
2680 * @param px The x position of the point to test
2681 * @param py The y position of the point to test
2682 * @param x1 The x1 position of the bounds to test
2683 * @param y1 The y1 position of the bounds to test
2684 * @param x2 The x2 position of the bounds to test
2685 * @param y2 The y2 position of the bounds to test
2686 * @param insets The insets to apply to (x1,y1)-(x2,y2) to get the final bounds to test
2687 * @param rad The corner radii to test with. Must not be null.
2688 * @param maxRadius The maximum possible radius value
2689 * @return True if (px, py) is within the bounds, taking into account insets and corner radii.
2690 */
2691 private boolean contains(final double px, final double py,
2692 final double x1, final double y1, final double x2, final double y2,
2693 final Insets insets, CornerRadii rad) {
2694 // These four values are the x0, y0, x1, y1 bounding box after
2695 // having taken into account the insets of this particular
2696 // background fill.
2697 final double rrx0 = x1 + insets.getLeft();
2698 final double rry0 = y1 + insets.getTop();
2699 final double rrx1 = x2 - insets.getRight();
2700 final double rry1 = y2 - insets.getBottom();
2701
2702 // assert rad.hasPercentBasedRadii == false;
2703
2704 // Check for trivial rejection - point is inside bounding rectangle
2705 if (px >= rrx0 && py >= rry0 && px <= rrx1 && py <= rry1) {
2706 // The point was within the index bounding box. Now we need to analyze the
2707 // corner radii to see if the point lies within the corners or not. If the
2708 // point is within a corner then we reject this one.
2709 final double tlhr = rad.getTopLeftHorizontalRadius();
2710 if (rad.isUniform() && tlhr == 0) {
2711 // This is a simple square! Since we know the point is already within
2712 // the insets of this fill, we can simply return true.
2713 return true;
2714 } else {
2715 final double tlvr = rad.getTopLeftVerticalRadius();
2716 final double trhr = rad.getTopRightHorizontalRadius();
2717 final double trvr = rad.getTopRightVerticalRadius();
2718 final double blhr = rad.getBottomLeftHorizontalRadius();
2719 final double blvr = rad.getBottomLeftVerticalRadius();
2720 final double brhr = rad.getBottomRightHorizontalRadius();
2721 final double brvr = rad.getBottomRightVerticalRadius();
2722
2723 // The four corners can each be described as a quarter of an ellipse
2724 double centerX, centerY, a, b;
2725
2726 if (px <= rrx0 + tlhr && py <= rry0 + tlvr) {
2727 // Point is in the top left corner
2728 centerX = rrx0 + tlhr;
2729 centerY = rry0 + tlvr;
2730 a = tlhr;
2731 b = tlvr;
2732 } else if (px >= rrx1 - trhr && py <= rry0 + trvr) {
2733 // Point is in the top right corner
2734 centerX = rrx1 - trhr;
2735 centerY = rry0 + trvr;
2736 a = trhr;
2737 b = trvr;
2738 } else if (px >= rrx1 - brhr && py >= rry1 - brvr) {
2739 // Point is in the bottom right corner
2740 centerX = rrx1 - brhr;
2741 centerY = rry1 - brvr;
2742 a = brhr;
2743 b = brvr;
2744 } else if (px <= rrx0 + blhr && py >= rry1 - blvr) {
2745 // Point is in the bottom left corner
2746 centerX = rrx0 + blhr;
2747 centerY = rry1 - blvr;
2748 a = blhr;
2749 b = blvr;
2750 } else {
2751 // The point must have been in the solid body someplace
2752 return true;
2753 }
2754
2755 double x = px - centerX;
2756 double y = py - centerY;
2757 double result = ((x*x)/(a*a) + (y*y)/(b*b));
2758 // The .0000001 is fudge to help in cases where double arithmetic isn't quite right
2759 if (result - .0000001 <= 1) return true;
2760 }
2761 }
2762 return false;
2763 }
2764
2765 /*
2766 * The normalized corner radii are unmodifiable List objects shared between
2767 * the NG layer and the FX layer. As cached shadow copies of the objects
2768 * in the BackgroundFill and BorderStroke objects they should be considered
2769 * read-only and will only be updated by replacing the original objects
2770 * when validation is needed.
2771 */
2772 private boolean cornersValid; // = false
2773 private List<CornerRadii> normalizedFillCorners; // = null
2774 private List<CornerRadii> normalizedStrokeCorners; // = null
2775
2776 /**
2777 * Returns the normalized absolute radii for the indicated BackgroundFill,
2778 * taking the current size of the region into account to eliminate any
2779 * percentage-based measurements and to scale the radii to prevent
2780 * overflowing the width or height.
2781 *
2782 * @param i the index of the BackgroundFill whose radii will be normalized.
2783 * @return the normalized (non-percentage, non-overflowing) radii
2784 */
2785 private CornerRadii getNormalizedFillCorner(int i) {
2786 if (!cornersValid) {
2787 validateCorners();
2788 }
2789 return (normalizedFillCorners == null
2790 ? getBackground().getFills().get(i).getRadii()
2791 : normalizedFillCorners.get(i));
2792 }
2793
2794 /**
2795 * Returns the normalized absolute radii for the indicated BorderStroke,
2796 * taking the current size of the region into account to eliminate any
2797 * percentage-based measurements and to scale the radii to prevent
2798 * overflowing the width or height.
2799 *
2800 * @param i the index of the BorderStroke whose radii will be normalized.
2801 * @return the normalized (non-percentage, non-overflowing) radii
2802 */
2803 private CornerRadii getNormalizedStrokeCorner(int i) {
2804 if (!cornersValid) {
2805 validateCorners();
2806 }
2807 return (normalizedStrokeCorners == null
2808 ? getBorder().getStrokes().get(i).getRadii()
2809 : normalizedStrokeCorners.get(i));
2810 }
2811
2812 /**
2813 * This method validates all CornerRadii objects in both the set of
2814 * BackgroundFills and BorderStrokes and saves the normalized values
2815 * into the private fields above.
2816 */
2817 private void validateCorners() {
2818 final double width = getWidth();
2819 final double height = getHeight();
2820 List<CornerRadii> newFillCorners = null;
2821 List<CornerRadii> newStrokeCorners = null;
2822 final Background background = getBackground();
2823 final List<BackgroundFill> fills = background == null ? Collections.EMPTY_LIST : background.getFills();
2824 for (int i = 0; i < fills.size(); i++) {
2825 final BackgroundFill fill = fills.get(i);
2826 final CornerRadii origRadii = fill.getRadii();
2827 final Insets origInsets = fill.getInsets();
2828 final CornerRadii newRadii = normalize(origRadii, origInsets, width, height);
2829 if (origRadii != newRadii) {
2830 if (newFillCorners == null) {
2831 newFillCorners = Arrays.asList(new CornerRadii[fills.size()]);
2832 }
2833 newFillCorners.set(i, newRadii);
2834 }
2835 }
2836 final Border border = getBorder();
2837 final List<BorderStroke> strokes = (border == null ? Collections.EMPTY_LIST : border.getStrokes());
2838 for (int i = 0; i < strokes.size(); i++) {
2839 final BorderStroke stroke = strokes.get(i);
2840 final CornerRadii origRadii = stroke.getRadii();
2841 final Insets origInsets = stroke.getInsets();
2842 final CornerRadii newRadii = normalize(origRadii, origInsets, width, height);
2843 if (origRadii != newRadii) {
2844 if (newStrokeCorners == null) {
2845 newStrokeCorners = Arrays.asList(new CornerRadii[strokes.size()]);
2846 }
2847 newStrokeCorners.set(i, newRadii);
2848 }
2849 }
2850 if (newFillCorners != null) {
2851 for (int i = 0; i < fills.size(); i++) {
2852 if (newFillCorners.get(i) == null) {
2853 newFillCorners.set(i, fills.get(i).getRadii());
2854 }
2855 }
2856 newFillCorners = Collections.unmodifiableList(newFillCorners);
2857 }
2858 if (newStrokeCorners != null) {
2859 for (int i = 0; i < strokes.size(); i++) {
2860 if (newStrokeCorners.get(i) == null) {
2861 newStrokeCorners.set(i, strokes.get(i).getRadii());
2862 }
2863 }
2864 newStrokeCorners = Collections.unmodifiableList(newStrokeCorners);
2865 }
2866 normalizedFillCorners = newFillCorners;
2867 normalizedStrokeCorners = newStrokeCorners;
2868 cornersValid = true;
2869 }
2870
2871 /**
2872 * Return a version of the radii that is not percentage based and is scaled to
2873 * fit the indicated inset rectangle without overflow.
2874 * This method may return the original CornerRadii if none of the radii
2875 * values in the given object are percentages or require scaling.
2876 *
2877 * @param radii The radii.
2878 * @param insets The insets for the associated background or stroke.
2879 * @param width The width of the region before insets are applied.
2880 * @param height The height of the region before insets are applied.
2881 * @return Normalized radii.
2882 */
2883 private static CornerRadii normalize(CornerRadii radii, Insets insets, double width, double height) {
2884 width -= insets.getLeft() + insets.getRight();
2885 height -= insets.getTop() + insets.getBottom();
2886 if (width <= 0 || height <= 0) return CornerRadii.EMPTY;
2887 double tlvr = radii.getTopLeftVerticalRadius();
2888 double tlhr = radii.getTopLeftHorizontalRadius();
2889 double trvr = radii.getTopRightVerticalRadius();
2890 double trhr = radii.getTopRightHorizontalRadius();
2891 double brvr = radii.getBottomRightVerticalRadius();
2892 double brhr = radii.getBottomRightHorizontalRadius();
2893 double blvr = radii.getBottomLeftVerticalRadius();
2894 double blhr = radii.getBottomLeftHorizontalRadius();
2895 if (radii.hasPercentBasedRadii) {
2896 if (radii.isTopLeftVerticalRadiusAsPercentage()) tlvr *= height;
2897 if (radii.isTopLeftHorizontalRadiusAsPercentage()) tlhr *= width;
2898 if (radii.isTopRightVerticalRadiusAsPercentage()) trvr *= height;
2899 if (radii.isTopRightHorizontalRadiusAsPercentage()) trhr *= width;
2900 if (radii.isBottomRightVerticalRadiusAsPercentage()) brvr *= height;
2901 if (radii.isBottomRightHorizontalRadiusAsPercentage()) brhr *= width;
2902 if (radii.isBottomLeftVerticalRadiusAsPercentage()) blvr *= height;
2903 if (radii.isBottomLeftHorizontalRadiusAsPercentage()) blhr *= width;
2904 }
2905 double scale = 1.0;
2906 if (tlhr + trhr > width) { scale = Math.min(scale, width / (tlhr + trhr)); }
2907 if (blhr + brhr > width) { scale = Math.min(scale, width / (blhr + brhr)); }
2908 if (tlvr + blvr > height) { scale = Math.min(scale, height / (tlvr + blvr)); }
2909 if (trvr + brvr > height) { scale = Math.min(scale, height / (trvr + brvr)); }
2910 if (scale < 1.0) {
2911 tlvr *= scale; tlhr *= scale;
2912 trvr *= scale; trhr *= scale;
2913 brvr *= scale; brhr *= scale;
2914 blvr *= scale; blhr *= scale;
2915 }
2916 if (radii.hasPercentBasedRadii || scale < 1.0) {
2917 return new CornerRadii(tlhr, tlvr, trvr, trhr, brhr, brvr, blvr, blhr,
2918 false, false, false, false, false, false, false, false);
2919 }
2920 return radii;
2921 }
2922
2923 /**
2924 * Some skins relying on this
2925 * @treatAsPrivate implementation detail
2926 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
2927 */
2928 @Deprecated
2929 @Override protected void impl_pickNodeLocal(PickRay pickRay, PickResultChooser result) {
2930
2931 double boundsDistance = impl_intersectsBounds(pickRay);
2932
2933 if (!Double.isNaN(boundsDistance)) {
2934 ObservableList<Node> children = getChildren();
2935 for (int i = children.size()-1; i >= 0; i--) {
2936 children.get(i).impl_pickNode(pickRay, result);
2937 if (result.isClosed()) {
2938 return;
2939 }
2940 }
2941
2942 impl_intersects(pickRay, result);
2943 }
2944 }
2945
2946 private Bounds boundingBox;
2947
2948 /**
2949 * The layout bounds of this region: {@code 0, 0 width x height}
2950 *
2951 * @treatAsPrivate implementation detail
2952 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
2953 */
2954 @Deprecated
2955 @Override protected final Bounds impl_computeLayoutBounds() {
2956 if (boundingBox == null) {
2957 // we reuse the bounding box if the width and height haven't changed.
2958 boundingBox = new BoundingBox(0, 0, 0, getWidth(), getHeight(), 0);
2959 }
2960 return boundingBox;
2961 }
2962
2963 /**
2964 * @treatAsPrivate implementation detail
2965 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
2966 */
2967 @Deprecated
2968 @Override final protected void impl_notifyLayoutBoundsChanged() {
2969 // override Node's default behavior of having a geometric bounds change
2970 // trigger a change in layoutBounds. For Resizable nodes, layoutBounds
2971 // is unrelated to geometric bounds.
2972 }
2973
2974 private BaseBounds computeShapeBounds(BaseBounds bounds)
2975 {
2976 com.sun.javafx.geom.Shape s = _shape.impl_configShape();
2977
2978 float[] bbox = {
2979 Float.POSITIVE_INFINITY, Float.POSITIVE_INFINITY,
2980 Float.NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY,
2981 };
2982
2983 Background bg = getBackground();
2984 if (bg != null) {
2985 final RectBounds sBounds = s.getBounds();
2986 final Insets bgOutsets = bg.getOutsets();
2987 bbox[0] = sBounds.getMinX() - (float) bgOutsets.getLeft();
2988 bbox[1] = sBounds.getMinY() - (float) bgOutsets.getTop();
2989 bbox[2] = sBounds.getMaxX() + (float) bgOutsets.getBottom();
2990 bbox[3] = sBounds.getMaxY() + (float) bgOutsets.getRight();
2991 }
2992
2993 final Border b = getBorder();
2994 if (b != null && b.getStrokes().size() > 0) {
2995 for (BorderStroke bs : b.getStrokes()) {
2996 // This order of border strokes is used in NGRegion.renderAsShape/setBorderStyle
2997 BorderStrokeStyle bss = bs.getTopStyle() != null ? bs.getTopStyle() :
2998 bs.getLeftStyle() != null ? bs.getLeftStyle() :
2999 bs.getBottomStyle() != null ? bs.getBottomStyle() :
3000 bs.getRightStyle() != null ? bs.getRightStyle() : null;
3001
3002 if (bss == null || bss == BorderStrokeStyle.NONE) {
3003 continue;
3004 }
3005
3006 final StrokeType type = bss.getType();
3007 double sw = Math.max(bs.getWidths().top, 0d);
3008 StrokeLineCap cap = bss.getLineCap();
3009 StrokeLineJoin join = bss.getLineJoin();
3010 float miterlimit = (float) Math.max(bss.getMiterLimit(), 1d);
3011 Toolkit.getToolkit().accumulateStrokeBounds(
3012 s,
3013 bbox, type, sw,
3014 cap, join, miterlimit, BaseTransform.IDENTITY_TRANSFORM);
3015
3016 }
3017 }
3018
3019 if (bbox[2] < bbox[0] || bbox[3] < bbox[1]) {
3020 return bounds.makeEmpty();
3021 }
3022
3023 return bounds.deriveWithNewBounds(bbox[0], bbox[1], 0.0f,
3024 bbox[2], bbox[3], 0.0f);
3025 }
3026
3027 /**
3028 * @treatAsPrivate implementation detail
3029 * @deprecated This is an internal API that is not intended for use and will be removed in the next version
3030 */
3031 @Deprecated
3032 @Override public BaseBounds impl_computeGeomBounds(BaseBounds bounds, BaseTransform tx) {
3033 // Unlike Group, a Region has its own intrinsic geometric bounds, even if it has no children.
3034 // The bounds of the Region must take into account any backgrounds and borders and how
3035 // they are used to draw the Region. The geom bounds must always take into account
3036 // all pixels drawn (because the geom bounds forms the basis of the dirty regions).
3037 // Note that the layout bounds of a Region is not based on the geom bounds.
3038
3039 // Define some variables to hold the top-left and bottom-right corners of the bounds
3040 double bx1 = 0;
3041 double by1 = 0;
3042 double bx2 = getWidth();
3043 double by2 = getHeight();
3044
3045 // If the shape is defined, then the top-left and bottom-right corner positions
3046 // need to be redefined
3047 if (_shape != null && isScaleShape() == false) {
3048 // We will hijack the bounds here temporarily just to compute the shape bounds
3049 final BaseBounds shapeBounds = computeShapeBounds(bounds);
3050 final double shapeWidth = shapeBounds.getWidth();
3051 final double shapeHeight = shapeBounds.getHeight();
3052 if (isCenterShape()) {
3053 bx1 = (bx2 - shapeWidth) / 2;
3054 by1 = (by2 - shapeHeight) / 2;
3055 bx2 = bx1 + shapeWidth;
3056 by2 = by1 + shapeHeight;
3057 } else {
3058 bx1 = shapeBounds.getMinX();
3059 by1 = shapeBounds.getMinY();
3060 bx2 = shapeBounds.getMaxX();
3061 by2 = shapeBounds.getMaxY();
3062 }
3063 } else {
3064 // Expand the bounds to include the outsets from the background and border.
3065 // The outsets are the opposite of insets -- a measure of distance from the
3066 // edge of the Region outward. The outsets cannot, however, be negative.
3067 final Background background = getBackground();
3068 final Border border = getBorder();
3069 final Insets backgroundOutsets = background == null ? Insets.EMPTY : background.getOutsets();
3070 final Insets borderOutsets = border == null ? Insets.EMPTY : border.getOutsets();
3071 bx1 -= Math.max(backgroundOutsets.getLeft(), borderOutsets.getLeft());
3072 by1 -= Math.max(backgroundOutsets.getTop(), borderOutsets.getTop());
3073 bx2 += Math.max(backgroundOutsets.getRight(), borderOutsets.getRight());
3074 by2 += Math.max(backgroundOutsets.getBottom(), borderOutsets.getBottom());
3075 }
3076 // NOTE: Okay to call impl_computeGeomBounds with tx even in the 3D case
3077 // since Parent.impl_computeGeomBounds does handle 3D correctly.
3078 BaseBounds cb = super.impl_computeGeomBounds(bounds, tx);
3079 /*
3080 * This is a work around for RT-7680. Parent returns invalid bounds from
3081 * impl_computeGeomBounds when it has no children or if all its children
3082 * have invalid bounds. If RT-7680 were fixed, then we could omit this
3083 * first branch of the if and only use the else since the correct value
3084 * would be computed.
3085 */
3086 if (cb.isEmpty()) {
3087 // There are no children bounds, so
3088 bounds = bounds.deriveWithNewBounds(
3089 (float)bx1, (float)by1, 0.0f,
3090 (float)bx2, (float)by2, 0.0f);
3091 bounds = tx.transform(bounds, bounds);
3092 return bounds;
3093 } else {
3094 // Union with children's bounds
3095 BaseBounds tempBounds = TempState.getInstance().bounds;
3096 tempBounds = tempBounds.deriveWithNewBounds(
3097 (float)bx1, (float)by1, 0.0f,
3098 (float)bx2, (float)by2, 0.0f);
3099 BaseBounds bb = tx.transform(tempBounds, tempBounds);
3100 cb = cb.deriveWithUnion(bb);
3101 return cb;
3102 }
3103 }
3104
3105 /***************************************************************************
3106 * *
3107 * CSS *
3108 * *
3109 **************************************************************************/
3110
3111 /**
3112 * An implementation may specify its own user-agent styles for this Region, and its children,
3113 * by overriding this method. These styles are used in addition to whatever user-agent stylesheets
3114 * are in use. This provides a mechanism for third parties to introduce styles for custom controls.
3115 * <p>
3116 * The URL is a hierarchical URI of the form [scheme:][//authority][path]. If the URL
3117 * does not have a [scheme:] component, the URL is considered to be the [path] component only.
3118 * Any leading '/' character of the [path] is ignored and the [path] is treated as a path relative to
3119 * the root of the application's classpath.
3120 * </p>
3121 * <code><pre>
3122 *
3123 * package com.example.javafx.app;
3124 *
3125 * import javafx.application.Application;
3126 * import javafx.scene.Group;
3127 * import javafx.scene.Scene;
3128 * import javafx.stage.Stage;
3129 *
3130 * public class MyApp extends Application {
3131 *
3132 * {@literal @}Override public void start(Stage stage) {
3133 * Scene scene = new Scene(new Group());
3134 * scene.getStylesheets().add("/com/example/javafx/app/mystyles.css");
3135 * stage.setScene(scene);
3136 * stage.show();
3137 * }
3138 *
3139 * public static void main(String[] args) {
3140 * launch(args);
3141 * }
3142 * }
3143 * </pre></code>
3144 * For additional information about using CSS with the scene graph,
3145 * see the <a href="../doc-files/cssref.html">CSS Reference Guide</a>.
3146 *
3147 * @return A string URL
3148 * @since JavaFX 8u40
3149 */
3150 public String getUserAgentStylesheet() {
3151 return null;
3152 }
3153
3154 /**
3155 * Super-lazy instantiation pattern from Bill Pugh.
3156 * @treatAsPrivate implementation detail
3157 */
3158 private static class StyleableProperties {
3159 private static final CssMetaData<Region,Insets> PADDING =
3160 new CssMetaData<Region,Insets>("-fx-padding",
3161 InsetsConverter.getInstance(), Insets.EMPTY) {
3162
3163 @Override public boolean isSettable(Region node) {
3164 return node.padding == null || !node.padding.isBound();
3165 }
3166
3167 @Override public StyleableProperty<Insets> getStyleableProperty(Region node) {
3168 return (StyleableProperty<Insets>)node.paddingProperty();
3169 }
3170 };
3171
3172 private static final CssMetaData<Region,Insets> OPAQUE_INSETS =
3173 new CssMetaData<Region,Insets>("-fx-opaque-insets",
3174 InsetsConverter.getInstance(), null) {
3175
3176 @Override
3177 public boolean isSettable(Region node) {
3178 return node.opaqueInsets == null || !node.opaqueInsets.isBound();
3179 }
3180
3181 @Override
3182 public StyleableProperty<Insets> getStyleableProperty(Region node) {
3183 return (StyleableProperty<Insets>)node.opaqueInsetsProperty();
3184 }
3185
3186 };
3187
3188 private static final CssMetaData<Region,Background> BACKGROUND =
3189 new CssMetaData<Region,Background>("-fx-region-background",
3190 BackgroundConverter.INSTANCE,
3191 null,
3192 false,
3193 Background.getClassCssMetaData()) {
3194
3195 @Override public boolean isSettable(Region node) {
3196 return !node.background.isBound();
3197 }
3198
3199 @Override public StyleableProperty<Background> getStyleableProperty(Region node) {
3200 return (StyleableProperty<Background>)node.background;
3201 }
3202 };
3203
3204 private static final CssMetaData<Region,Border> BORDER =
3205 new CssMetaData<Region,Border>("-fx-region-border",
3206 BorderConverter.getInstance(),
3207 null,
3208 false,
3209 Border.getClassCssMetaData()) {
3210
3211 @Override public boolean isSettable(Region node) {
3212 return !node.background.isBound();
3213 }
3214
3215 @Override public StyleableProperty<Border> getStyleableProperty(Region node) {
3216 return (StyleableProperty<Border>)node.border;
3217 }
3218 };
3219
3220 private static final CssMetaData<Region,Shape> SHAPE =
3221 new CssMetaData<Region,Shape>("-fx-shape",
3222 ShapeConverter.getInstance()) {
3223
3224 @Override public boolean isSettable(Region node) {
3225 // isSettable depends on node.shape, not node.shapeContent
3226 return node.shape == null || !node.shape.isBound();
3227 }
3228
3229 @Override public StyleableProperty<Shape> getStyleableProperty(Region node) {
3230 return (StyleableProperty<Shape>)node.shapeProperty();
3231 }
3232 };
3233
3234 private static final CssMetaData<Region, Boolean> SCALE_SHAPE =
3235 new CssMetaData<Region,Boolean>("-fx-scale-shape",
3236 BooleanConverter.getInstance(), Boolean.TRUE){
3237
3238 @Override public boolean isSettable(Region node) {
3239 return node.scaleShape == null || !node.scaleShape.isBound();
3240 }
3241
3242 @Override public StyleableProperty<Boolean> getStyleableProperty(Region node) {
3243 return (StyleableProperty<Boolean>)node.scaleShapeProperty();
3244 }
3245 };
3246
3247 private static final CssMetaData<Region,Boolean> POSITION_SHAPE =
3248 new CssMetaData<Region,Boolean>("-fx-position-shape",
3249 BooleanConverter.getInstance(), Boolean.TRUE){
3250
3251 @Override public boolean isSettable(Region node) {
3252 return node.centerShape == null || !node.centerShape.isBound();
3253 }
3254
3255 @Override public StyleableProperty<Boolean> getStyleableProperty(Region node) {
3256 return (StyleableProperty<Boolean>)node.centerShapeProperty();
3257 }
3258 };
3259
3260 private static final CssMetaData<Region,Boolean> CACHE_SHAPE =
3261 new CssMetaData<Region,Boolean>("-fx-cache-shape",
3262 BooleanConverter.getInstance(), Boolean.TRUE){
3263
3264 @Override public boolean isSettable(Region node) {
3265 return node.cacheShape == null || !node.cacheShape.isBound();
3266 }
3267
3268 @Override public StyleableProperty<Boolean> getStyleableProperty(Region node) {
3269 return (StyleableProperty<Boolean>)node.cacheShapeProperty();
3270 }
3271 };
3272
3273 private static final CssMetaData<Region, Boolean> SNAP_TO_PIXEL =
3274 new CssMetaData<Region,Boolean>("-fx-snap-to-pixel",
3275 BooleanConverter.getInstance(), Boolean.TRUE){
3276
3277 @Override public boolean isSettable(Region node) {
3278 return node.snapToPixel == null ||
3279 !node.snapToPixel.isBound();
3280 }
3281
3282 @Override public StyleableProperty<Boolean> getStyleableProperty(Region node) {
3283 return (StyleableProperty<Boolean>)node.snapToPixelProperty();
3284 }
3285 };
3286
3287 private static final CssMetaData<Region, Number> MIN_HEIGHT =
3288 new CssMetaData<Region,Number>("-fx-min-height",
3289 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3290
3291 @Override public boolean isSettable(Region node) {
3292 return node.minHeight == null ||
3293 !node.minHeight.isBound();
3294 }
3295
3296 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3297 return (StyleableProperty<Number>)node.minHeightProperty();
3298 }
3299 };
3300
3301 private static final CssMetaData<Region, Number> PREF_HEIGHT =
3302 new CssMetaData<Region,Number>("-fx-pref-height",
3303 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3304
3305 @Override public boolean isSettable(Region node) {
3306 return node.prefHeight == null ||
3307 !node.prefHeight.isBound();
3308 }
3309
3310 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3311 return (StyleableProperty<Number>)node.prefHeightProperty();
3312 }
3313 };
3314
3315 private static final CssMetaData<Region, Number> MAX_HEIGHT =
3316 new CssMetaData<Region,Number>("-fx-max-height",
3317 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3318
3319 @Override public boolean isSettable(Region node) {
3320 return node.maxHeight == null ||
3321 !node.maxHeight.isBound();
3322 }
3323
3324 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3325 return (StyleableProperty<Number>)node.maxHeightProperty();
3326 }
3327 };
3328
3329 private static final CssMetaData<Region, Number> MIN_WIDTH =
3330 new CssMetaData<Region,Number>("-fx-min-width",
3331 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3332
3333 @Override public boolean isSettable(Region node) {
3334 return node.minWidth == null ||
3335 !node.minWidth.isBound();
3336 }
3337
3338 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3339 return (StyleableProperty<Number>)node.minWidthProperty();
3340 }
3341 };
3342
3343 private static final CssMetaData<Region, Number> PREF_WIDTH =
3344 new CssMetaData<Region,Number>("-fx-pref-width",
3345 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3346
3347 @Override public boolean isSettable(Region node) {
3348 return node.prefWidth == null ||
3349 !node.prefWidth.isBound();
3350 }
3351
3352 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3353 return (StyleableProperty<Number>)node.prefWidthProperty();
3354 }
3355 };
3356
3357 private static final CssMetaData<Region, Number> MAX_WIDTH =
3358 new CssMetaData<Region,Number>("-fx-max-width",
3359 SizeConverter.getInstance(), USE_COMPUTED_SIZE){
3360
3361 @Override public boolean isSettable(Region node) {
3362 return node.maxWidth == null ||
3363 !node.maxWidth.isBound();
3364 }
3365
3366 @Override public StyleableProperty<Number> getStyleableProperty(Region node) {
3367 return (StyleableProperty<Number>)node.maxWidthProperty();
3368 }
3369 };
3370
3371 private static final List<CssMetaData<? extends Styleable, ?>> STYLEABLES;
3372 static {
3373
3374 final List<CssMetaData<? extends Styleable, ?>> styleables =
3375 new ArrayList<CssMetaData<? extends Styleable, ?>>(Parent.getClassCssMetaData());
3376 styleables.add(PADDING);
3377 styleables.add(BACKGROUND);
3378 styleables.add(BORDER);
3379 styleables.add(OPAQUE_INSETS);
3380 styleables.add(SHAPE);
3381 styleables.add(SCALE_SHAPE);
3382 styleables.add(POSITION_SHAPE);
3383 styleables.add(SNAP_TO_PIXEL);
3384 styleables.add(MIN_WIDTH);
3385 styleables.add(PREF_WIDTH);
3386 styleables.add(MAX_WIDTH);
3387 styleables.add(MIN_HEIGHT);
3388 styleables.add(PREF_HEIGHT);
3389 styleables.add(MAX_HEIGHT);
3390 STYLEABLES = Collections.unmodifiableList(styleables);
3391 }
3392 }
3393
3394 /**
3395 * @return The CssMetaData associated with this class, which may include the
3396 * CssMetaData of its super classes.
3397 * @since JavaFX 8.0
3398 */
3399 public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
3400 return StyleableProperties.STYLEABLES;
3401 }
3402
3403 /**
3404 * {@inheritDoc}
3405 *
3406 * @since JavaFX 8.0
3407 */
3408
3409
3410 @Override
3411 public List<CssMetaData<? extends Styleable, ?>> getCssMetaData() {
3412 return getClassCssMetaData();
3413 }
3414
3415 }