1 /*
2 * Copyright (c) 2012, 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 javafx.beans.NamedArg;
29 import javafx.css.CssMetaData;
30 import javafx.css.Styleable;
31 import javafx.geometry.Insets;
32 import javafx.scene.Node;
33 import javafx.scene.image.Image;
34 import javafx.scene.paint.Color;
35 import javafx.scene.paint.Paint;
36 import java.util.Arrays;
37 import java.util.Collections;
38 import java.util.List;
39 import com.sun.javafx.UnmodifiableArrayList;
40 import com.sun.javafx.css.SubCssMetaData;
41 import com.sun.javafx.css.converters.InsetsConverter;
42 import com.sun.javafx.css.converters.PaintConverter;
43 import com.sun.javafx.css.converters.URLConverter;
44 import com.sun.javafx.scene.layout.region.LayeredBackgroundPositionConverter;
45 import com.sun.javafx.scene.layout.region.LayeredBackgroundSizeConverter;
46 import com.sun.javafx.scene.layout.region.CornerRadiiConverter;
47 import com.sun.javafx.scene.layout.region.RepeatStruct;
48 import com.sun.javafx.scene.layout.region.RepeatStructConverter;
49 import com.sun.javafx.tk.Toolkit;
50
51 /**
52 * The Background of a {@link Region}. A Background is an immutable object which
53 * encapsulates the entire set of data required to render the background
54 * of a Region. Because this class is immutable, you can freely reuse the same
55 * Background on many different Regions. Please refer to
56 * {@link ../doc-files/cssref.html JavaFX CSS Reference} for a complete description
57 * of the CSS rules for styling the background of a Region.
58 * <p/>
59 * Every Background is comprised of {@link #getFills() fills} and / or
60 * {@link #getImages() images}. Neither list will ever be null, but either or
61 * both may be empty. Each defined {@link BackgroundFill} is rendered in order,
62 * followed by each defined {@link BackgroundImage}.
63 * <p/>
64 * The Background's {@link #getOutsets() outsets} define any extension of the drawing area of a Region
65 * which is necessary to account for all background drawing. These outsets are strictly
66 * defined by the BackgroundFills that are specified on this Background, if any, because
67 * all BackgroundImages are clipped to the drawing area, and do not define it. The
68 * outsets values are strictly non-negative.
69 *
70 * @since JavaFX 8.0
71 */
72 @SuppressWarnings("unchecked")
73 public final class Background {
74 static final CssMetaData<Node,Paint[]> BACKGROUND_COLOR =
75 new SubCssMetaData<>("-fx-background-color",
76 PaintConverter.SequenceConverter.getInstance(),
77 new Paint[] {Color.TRANSPARENT});
78
79 static final CssMetaData<Node,CornerRadii[]> BACKGROUND_RADIUS =
80 new SubCssMetaData<>("-fx-background-radius",
81 CornerRadiiConverter.getInstance(),
82 new CornerRadii[] {CornerRadii.EMPTY});
83
84 static final CssMetaData<Node,Insets[]> BACKGROUND_INSETS =
85 new SubCssMetaData<>("-fx-background-insets",
86 InsetsConverter.SequenceConverter.getInstance(),
87 new Insets[] {Insets.EMPTY});
88
89 static final CssMetaData<Node,Image[]> BACKGROUND_IMAGE =
90 new SubCssMetaData<>("-fx-background-image",
91 URLConverter.SequenceConverter.getInstance());
92
93 static final CssMetaData<Node,RepeatStruct[]> BACKGROUND_REPEAT =
94 new SubCssMetaData<>("-fx-background-repeat",
95 RepeatStructConverter.getInstance(),
96 new RepeatStruct[] {new RepeatStruct(BackgroundRepeat.REPEAT,
97 BackgroundRepeat.REPEAT) });
98
99 static final CssMetaData<Node,BackgroundPosition[]> BACKGROUND_POSITION =
100 new SubCssMetaData<>("-fx-background-position",
101 LayeredBackgroundPositionConverter.getInstance(),
102 new BackgroundPosition[] { BackgroundPosition.DEFAULT });
103
104 static final CssMetaData<Node,BackgroundSize[]> BACKGROUND_SIZE =
105 new SubCssMetaData<>("-fx-background-size",
106 LayeredBackgroundSizeConverter.getInstance(),
107 new BackgroundSize[] { BackgroundSize.DEFAULT } );
108
109 private static final List<CssMetaData<? extends Styleable, ?>> STYLEABLES =
110 (List<CssMetaData<? extends Styleable, ?>>) (List) Collections.unmodifiableList(
111 // Unchecked!
112 Arrays.asList(BACKGROUND_COLOR,
113 BACKGROUND_INSETS,
114 BACKGROUND_RADIUS,
115 BACKGROUND_IMAGE,
116 BACKGROUND_REPEAT,
117 BACKGROUND_POSITION,
118 BACKGROUND_SIZE));
119
120 /**
121 * @return The CssMetaData associated with this class, which may include the
122 * CssMetaData of its super classes.
123 */
124 public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
125 return STYLEABLES;
126 }
127
128 /**
129 * An empty Background, useful to use instead of null.
130 */
131 public static final Background EMPTY = new Background((BackgroundFill[])null, null);
132
133 /**
134 * The list of BackgroundFills which together define the filled portion
135 * of this Background. This List is unmodifiable and immutable. It
136 * will never be null. The elements of this list will also never be null.
137 */
138 public final List<BackgroundFill> getFills() { return fills; }
139 final List<BackgroundFill> fills;
140
141 /**
142 * The list of BackgroundImages which together define the image portion
143 * of this Background. This List is unmodifiable and immutable. It
144 * will never be null. The elements of this list will also never be null.
145 */
146 public final List<BackgroundImage> getImages() { return images; }
147 final List<BackgroundImage> images;
148
149 /**
150 * The outsets of this Background. This represents the largest
151 * bounding rectangle within which all drawing for the Background
152 * will take place. The outsets will never be negative, and represent
153 * the distance from the edge of the Region outward. Any BackgroundImages
154 * which would extend beyond the outsets will be clipped. Only the
155 * BackgroundFills contribute to the outsets.
156 */
157 public final Insets getOutsets() { return outsets; }
158 final Insets outsets;
159
160 /**
161 * Gets whether the background is empty. It is empty if there are no fills or images.
162 * @return true if the Background is empty, false otherwise.
163 */
164 public final boolean isEmpty() {
165 return fills.isEmpty() && images.isEmpty();
166 }
167
168 /**
169 * Specifies whether the Background has at least one opaque fill.
170 */
171 private final boolean hasOpaqueFill;
172
173 /**
174 * Package-private immutable fields referring to the opaque insets
175 * of this Background.
176 */
177 private final double opaqueFillTop, opaqueFillRight, opaqueFillBottom, opaqueFillLeft;
178 final boolean hasPercentageBasedOpaqueFills;
179
180 /**
181 * True if there are any fills that are in some way based on the size of the region.
182 * For example, if a CornerRadii on the fill is percentage based in either or both
183 * dimensions.
184 */
185 final boolean hasPercentageBasedFills;
186
187 /**
188 * The cached hash code computation for the Background. One very big
189 * reason for making Background immutable was to make it possible to
190 * cache and reuse the same Background instance for multiple
191 * Regions (for example, every un-hovered Button should have the same
192 * Background instance). To enable efficient caching, we cache the hash.
193 */
194 private final int hash;
195
196 /**
197 * Create a new Background by supplying an array of BackgroundFills.
198 * This array may be null, or may contain null values. Any null values
199 * will be ignored and will not contribute to the {@link #getFills() fills}
200 * or {@link #getOutsets() outsets}.
201 *
202 * @param fills The fills. This may be null, and may contain nulls. Any
203 * contained nulls are filtered out and not included in the
204 * final List of fills. A null array becomes an empty List.
205 */
206 public Background(final @NamedArg("fills") BackgroundFill... fills) {
207 this(fills, null);
208 }
209
210 /**
211 * Create a new Background by supplying an array of BackgroundImages.
212 * This array may be null, or may contain null values. Any null values will
213 * be ignored and will not contribute to the {@link #getImages() images}.
214 *
215 * @param images The images. This may be null, and may contain nulls. Any
216 * contained nulls are filtered out and not included in the
217 * final List of images. A null array becomes an empty List.
218 */
219 public Background(final @NamedArg("images") BackgroundImage... images) {
220 this(null, images);
221 }
222
223 /**
224 * Create a new Background supply two Lists, one for background fills and
225 * one for background images. Either list may be null, and may contain nulls.
226 * Any null values in these lists will be ignored and will not
227 * contribute to the {@link #getFills() fills}, {@link #getImages() images}, or
228 * {@link #getOutsets() outsets}.
229 *
230 * @param fills The fills. This may be null, and may contain nulls. Any
231 * contained nulls are filtered out and not included in the
232 * final List of fills. A null List becomes an empty List.
233 * @param images The images. This may be null, and may contain nulls. Any
234 * contained nulls are filtered out and not included in the
235 * final List of images. A null List becomes an empty List.
236 */
237 public Background(final @NamedArg("fills") List<BackgroundFill> fills, final @NamedArg("images") List<BackgroundImage> images) {
238 // NOTE: This constructor had to be supplied in order to cause a Builder
239 // to be auto-generated, because otherwise the types of the fills and images
240 // properties didn't match the types of the array based constructor parameters.
241 // So a Builder will use this constructor, while the CSS engine uses the
242 // array based constructor (for speed).
243 this(fills == null ? null : fills.toArray(new BackgroundFill[fills.size()]),
244 images == null ? null : images.toArray(new BackgroundImage[images.size()]));
245 }
246
247 /**
248 * Create a new Background by supplying two arrays, one for background fills,
249 * and one for background images. Either array may be null, and may contain null
250 * values. Any null values in these arrays will be ignored and will not
251 * contribute to the {@link #getFills() fills}, {@link #getImages() images}, or
252 * {@link #getOutsets() outsets}.
253 *
254 * @param fills The fills. This may be null, and may contain nulls. Any
255 * contained nulls are filtered out and not included in the
256 * final List of fills. A null array becomes an empty List.
257 * @param images The images. This may be null, and may contain nulls. Any
258 * contained nulls are filtered out and not included in the
259 * final List of images. A null array becomes an empty List.
260 */
261 public Background(final @NamedArg("fills") BackgroundFill[] fills, final @NamedArg("images") BackgroundImage[] images) {
262 // The cumulative insets
263 double outerTop = 0, outerRight = 0, outerBottom = 0, outerLeft = 0;
264 boolean hasPercentOpaqueInsets = false;
265 boolean hasPercentFillRadii = false;
266 boolean opaqueFill = false;
267
268 // If the fills is empty or null then we know we can just use the shared
269 // immutable empty list from Collections.
270 if (fills == null || fills.length == 0) {
271 this.fills = Collections.emptyList();
272 } else {
273 // We need to iterate over all of the supplied elements in the fills array.
274 // Each null element is ignored. Each non-null element is inspected to
275 // see if it contributes to the outsets.
276 final BackgroundFill[] noNulls = new BackgroundFill[fills.length];
277 int size = 0;
278 for (int i=0; i<fills.length; i++) {
279 final BackgroundFill fill = fills[i];
280 if (fill != null) {
281 noNulls[size++] = fill;
282 final Insets fillInsets = fill.getInsets();
283 final double fillTop = fillInsets.getTop();
284 final double fillRight = fillInsets.getRight();
285 final double fillBottom = fillInsets.getBottom();
286 final double fillLeft = fillInsets.getLeft();
287 outerTop = outerTop <= fillTop ? outerTop : fillTop; // min
288 outerRight = outerRight <= fillRight ? outerRight : fillRight; // min
289 outerBottom = outerBottom <= fillBottom ? outerBottom : fillBottom; // min
290 outerLeft = outerLeft <= fillLeft ? outerLeft : fillLeft; // min
291
292 // The common case is to NOT have percent based radii
293 final boolean b = fill.getRadii().hasPercentBasedRadii;
294 hasPercentFillRadii |= b;
295 if (fill.fill.isOpaque()) {
296 opaqueFill = true;
297 if (b) {
298 hasPercentOpaqueInsets = true;
299 }
300 }
301 }
302 }
303 this.fills = new UnmodifiableArrayList<>(noNulls, size);
304 }
305 hasPercentageBasedFills = hasPercentFillRadii;
306
307 // This ensures that we either have outsets of 0, if all the insets were positive,
308 // or a value greater than zero if they were negative.
309 outsets = new Insets(
310 Math.max(0, -outerTop),
311 Math.max(0, -outerRight),
312 Math.max(0, -outerBottom),
313 Math.max(0, -outerLeft));
314
315 // An null or empty images array results in an empty list
316 if (images == null || images.length == 0) {
317 this.images = Collections.emptyList();
318 } else {
319 // Filter out any null values and create an immutable array list
320 final BackgroundImage[] noNulls = new BackgroundImage[images.length];
321 int size = 0;
322 for (int i=0; i<images.length; i++) {
323 final BackgroundImage image = images[i];
324 if (image != null) noNulls[size++] = image;
325 }
326 this.images = new UnmodifiableArrayList<>(noNulls, size);
327 }
328
329 hasOpaqueFill = opaqueFill;
330 if (hasPercentOpaqueInsets) {
331 opaqueFillTop = Double.NaN;
332 opaqueFillRight = Double.NaN;
333 opaqueFillBottom = Double.NaN;
334 opaqueFillLeft = Double.NaN;
335 } else {
336 double[] trbl = new double[4];
337 computeOpaqueInsets(1, 1, true, trbl);
338 opaqueFillTop = trbl[0];
339 opaqueFillRight = trbl[1];
340 opaqueFillBottom = trbl[2];
341 opaqueFillLeft = trbl[3];
342 }
343 hasPercentageBasedOpaqueFills = hasPercentOpaqueInsets;
344
345 // Pre-compute the hash code. NOTE: all variables are prefixed with "this" so that we
346 // do not accidentally compute the hash based on the constructor arguments rather than
347 // based on the fields themselves!
348 int result = this.fills.hashCode();
349 result = 31 * result + this.images.hashCode();
350 hash = result;
351 }
352
353 /**
354 * Gets whether the fill of this Background is based on percentages (that is, relative to the
355 * size of the region being styled). Specifically, this returns true if any of the CornerRadii
356 * on any of the fills on this Background has a radius that is based on percentages.
357 *
358 * @return True if any CornerRadii of any BackgroundFill on this background would return true, false otherwise.
359 * @since JavaFX 8.0
360 */
361 public boolean isFillPercentageBased() {
362 return hasPercentageBasedFills;
363 }
364
365 /**
366 * Computes the opaque insets for a region with the specified width and height. This call
367 * must be made whenever the width or height of the region change, because the opaque insets
368 * are based on background fills, and the corner radii of a background fill can be percentage
369 * based. Thus, we need to potentially recompute the opaque insets whenever the width or
370 * height of the region change. On the other hand, if there are no percentage based corner
371 * radii, then we can simply return the pre-computed and cached answers.
372 *
373 * @param width The width of the region
374 * @param height The height of the region
375 * @param trbl A four-element array of doubles in order: top, right, bottom, left.
376 */
377 void computeOpaqueInsets(double width, double height, double[] trbl) {
378 computeOpaqueInsets(width, height, false, trbl);
379 }
380
381 /**
382 * Computes the opaque insets. The first time this is called from the constructor
383 * we want to take the long route through and compute everything, whether there are
384 * percentage based insets or not (the constructor ensures not to call it in the case
385 * that it has percentage based insets!). All other times, this is called by the other
386 * computeOpaqueInsets method with "firstTime" set to false, such that if we have
387 * percentage based insets, then we will bail early.
388 *
389 * This method takes into account both fills and images. Because images can be
390 * lazy loaded, we cannot pre-compute a bunch of things in the constructor for images
391 * the way we can with fills. Instead, each time the method is called, we have to
392 * inspect the images. However, we do have fast paths for cases where fills are used
393 * and not images.
394 *
395 * @param width The width of the region
396 * @param height The height of the region
397 * @param firstTime Whether this is being called from the constructor
398 * @param trbl A four-element array of doubles in order: top, right, bottom, left.
399 */
400 private void computeOpaqueInsets(double width, double height, boolean firstTime, double[] trbl) {
401 double opaqueRegionTop = Double.NaN,
402 opaqueRegionRight = Double.NaN,
403 opaqueRegionBottom = Double.NaN,
404 opaqueRegionLeft = Double.NaN;
405
406 // If during object construction we determined that there is an opaque fill, then we need
407 // to visit the fills and figure out which ones contribute to the opaque insets
408 if (hasOpaqueFill) {
409 // If during construction time we determined that none of the fills had a percentage based
410 // opaque inset, then we can just use the pre-computed values. This is worth doing since
411 // at this time all CSS based radii for BackgroundFills are literal values!
412 if (!firstTime && !hasPercentageBasedOpaqueFills) {
413 opaqueRegionTop = opaqueFillTop;
414 opaqueRegionRight = opaqueFillRight;
415 opaqueRegionBottom = opaqueFillBottom;
416 opaqueRegionLeft = opaqueFillLeft;
417 } else {
418 // NOTE: We know at this point that there is an opaque fill, and that at least one
419 // of them uses a percentage for at least one corner radius. Iterate over each
420 // BackgroundFill. If the fill is opaque, then we will compute the largest rectangle
421 // which will fit within its opaque area, taking the corner radii into account.
422 // Initialize them to the "I Don't Know" answer.
423
424 for (int i=0, max=fills.size(); i<max; i++) {
425 final BackgroundFill fill = fills.get(i);
426 final Insets fillInsets = fill.getInsets();
427 final double fillTop = fillInsets.getTop();
428 final double fillRight = fillInsets.getRight();
429 final double fillBottom = fillInsets.getBottom();
430 final double fillLeft = fillInsets.getLeft();
431
432 if (fill.fill.isOpaque()) {
433 // Some possible configurations:
434 // (a) rect1 is completely contained by rect2
435 // (b) rect2 is completely contained by rect1
436 // (c) rect1 is the same height as rect 2 and they overlap on the left or right
437 // (d) rect1 is the same width as rect 2 and they overlap on the top or bottom
438 // (e) they are disjoint or overlap in an unsupported manner.
439 final CornerRadii radii = fill.getRadii();
440 final double topLeftHorizontalRadius = radii.isTopLeftHorizontalRadiusAsPercentage() ?
441 width * radii.getTopLeftHorizontalRadius() : radii.getTopLeftHorizontalRadius();
442 final double topLeftVerticalRadius = radii.isTopLeftVerticalRadiusAsPercentage() ?
443 height * radii.getTopLeftVerticalRadius() : radii.getTopLeftVerticalRadius();
444 final double topRightVerticalRadius = radii.isTopRightVerticalRadiusAsPercentage() ?
445 height * radii.getTopRightVerticalRadius() : radii.getTopRightVerticalRadius();
446 final double topRightHorizontalRadius = radii.isTopRightHorizontalRadiusAsPercentage() ?
447 width * radii.getTopRightHorizontalRadius() : radii.getTopRightHorizontalRadius();
448 final double bottomRightHorizontalRadius = radii.isBottomRightHorizontalRadiusAsPercentage() ?
449 width * radii.getBottomRightHorizontalRadius() : radii.getBottomRightHorizontalRadius();
450 final double bottomRightVerticalRadius = radii.isBottomRightVerticalRadiusAsPercentage() ?
451 height * radii.getBottomRightVerticalRadius() : radii.getBottomRightVerticalRadius();
452 final double bottomLeftVerticalRadius = radii.isBottomLeftVerticalRadiusAsPercentage() ?
453 height * radii.getBottomLeftVerticalRadius() : radii.getBottomLeftVerticalRadius();
454 final double bottomLeftHorizontalRadius = radii.isBottomLeftHorizontalRadiusAsPercentage() ?
455 width * radii.getBottomLeftHorizontalRadius() : radii.getBottomLeftHorizontalRadius();
456
457 final double t = fillTop + (Math.max(topLeftVerticalRadius, topRightVerticalRadius) / 2);
458 final double r = fillRight + (Math.max(topRightHorizontalRadius, bottomRightHorizontalRadius) / 2);
459 final double b = fillBottom + (Math.max(bottomLeftVerticalRadius, bottomRightVerticalRadius) / 2);
460 final double l = fillLeft + (Math.max(topLeftHorizontalRadius, bottomLeftHorizontalRadius) / 2);
461 if (Double.isNaN(opaqueRegionTop)) {
462 // This only happens for the first opaque fill we encounter
463 opaqueRegionTop = t;
464 opaqueRegionRight = r;
465 opaqueRegionBottom = b;
466 opaqueRegionLeft = l;
467 } else {
468 final boolean largerTop = t >= opaqueRegionTop;
469 final boolean largerRight = r >= opaqueRegionRight;
470 final boolean largerBottom = b >= opaqueRegionBottom;
471 final boolean largerLeft = l >= opaqueRegionLeft;
472 if (largerTop && largerRight && largerBottom && largerLeft) {
473 // The new fill is completely contained within the existing rect, so no change
474 continue;
475 } else if (!largerTop && !largerRight && !largerBottom && !largerLeft) {
476 // The new fill completely contains the existing rect, so use these
477 // new values for our opaque region
478 opaqueRegionTop = fillTop;
479 opaqueRegionRight = fillRight;
480 opaqueRegionBottom = fillBottom;
481 opaqueRegionLeft = fillLeft;
482 } else if (l == opaqueRegionLeft && r == opaqueRegionRight) {
483 // The left and right insets are the same between the two rects, so just pick
484 // the smallest top and bottom
485 opaqueRegionTop = Math.min(t, opaqueRegionTop);
486 opaqueRegionBottom = Math.min(b, opaqueRegionBottom);
487 } else if (t == opaqueRegionTop && b == opaqueRegionBottom) {
488 // The top and bottom are the same between the two rects so just pick
489 // the smallest left and right
490 opaqueRegionLeft = Math.min(l, opaqueRegionLeft);
491 opaqueRegionRight = Math.min(r, opaqueRegionRight);
492 } else {
493 // They are disjoint or overlap in some other manner. So we will just
494 // ignore this region.
495 continue;
496 }
497 }
498 }
499 }
500 }
501 }
502
503 // Check the background images. Since the image of a BackgroundImage might load asynchronously
504 // and since we must inspect the image to check for opacity, we just have to visit all the
505 // images each time this method is called rather than pre-computing results. With some work
506 // we could end up caching the result eventually.
507 final Toolkit.ImageAccessor acc = Toolkit.getImageAccessor();
508 for (BackgroundImage bi : images) {
509 if (bi.opaque == null) {
510 // If the image is not yet loaded, just skip it
511 // Note: Unit test wants this to be com.sun.javafx.tk.PlatformImage, not com.sun.prism.Image
512 final com.sun.javafx.tk.PlatformImage platformImage = acc.getImageProperty(bi.image).get();
513 if (platformImage == null) continue;
514
515 // The image has been loaded, so update the opaque flag
516 if (platformImage instanceof com.sun.prism.Image) {
517 bi.opaque = ((com.sun.prism.Image)platformImage).isOpaque();
518 } else {
519 continue;
520 }
521 }
522
523 // At this point we know that we're processing an image which has already been resolved
524 // and we know whether it is opaque or not. Of course, we only care about processing
525 // opaque images.
526 if (bi.opaque) {
527 if (bi.size.cover ||
528 (bi.size.height == BackgroundSize.AUTO && bi.size.width == BackgroundSize.AUTO &&
529 bi.size.widthAsPercentage && bi.size.heightAsPercentage)) {
530 // If the size mode is "cover" or AUTO, AUTO, and percentage based, then we're done -- we can simply
531 // accumulate insets of "0"
532 opaqueRegionTop = Double.isNaN(opaqueRegionTop) ? 0 : Math.min(0, opaqueRegionTop);
533 opaqueRegionRight = Double.isNaN(opaqueRegionRight) ? 0 : Math.min(0, opaqueRegionRight);
534 opaqueRegionBottom = Double.isNaN(opaqueRegionBottom) ? 0 : Math.min(0, opaqueRegionBottom);
535 opaqueRegionLeft = Double.isNaN(opaqueRegionLeft) ? 0 : Math.min(0, opaqueRegionLeft);
536 break;
537 } else {
538 // Here we are taking into account all potential tiling cases including "contain". Basically,
539 // as long as the repeat is *not* SPACE, we know that we'll be touching every pixel, and we
540 // don't really care how big the tiles end up being. The only case where we care about the
541 // actual tile size is in the NO_REPEAT modes.
542
543 // If the repeatX or repeatY includes "SPACE" Then we bail, because we can't be happy about
544 // spaces strewn about within the region.
545 if (bi.repeatX == BackgroundRepeat.SPACE || bi.repeatY == BackgroundRepeat.SPACE) {
546 bi.opaque = false; // We'll treat it as false in the future
547 continue;
548 }
549
550 // If the repeatX and repeatY are "REPEAT" and/or "ROUND" (any combination thereof) then
551 // we know all pixels within the region width / height are being touched, so we can just
552 // set the opaqueRegion variables and we're done.
553 final boolean filledX = bi.repeatX == BackgroundRepeat.REPEAT || bi.repeatX == BackgroundRepeat.ROUND;
554 final boolean filledY = bi.repeatY == BackgroundRepeat.REPEAT || bi.repeatY == BackgroundRepeat.ROUND;
555 if (filledX && filledY) {
556 opaqueRegionTop = Double.isNaN(opaqueRegionTop) ? 0 : Math.min(0, opaqueRegionTop);
557 opaqueRegionRight = Double.isNaN(opaqueRegionRight) ? 0 : Math.min(0, opaqueRegionRight);
558 opaqueRegionBottom = Double.isNaN(opaqueRegionBottom) ? 0 : Math.min(0, opaqueRegionBottom);
559 opaqueRegionLeft = Double.isNaN(opaqueRegionLeft) ? 0 : Math.min(0, opaqueRegionLeft);
560 break;
561 }
562
563 // We know that one or the other dimension is not filled, so we have to compute the right
564 // width / height. This is basically a big copy/paste from NGRegion! Blah!
565 final double w = bi.size.widthAsPercentage ? bi.size.width * width : bi.size.width;
566 final double h = bi.size.heightAsPercentage ? bi.size.height * height : bi.size.height;
567 final double imgUnscaledWidth = bi.image.getWidth();
568 final double imgUnscaledHeight = bi.image.getHeight();
569
570 // Now figure out the width and height of each tile to be drawn. The actual image
571 // dimensions may be one thing, but we need to figure out what the size of the image
572 // in the destination is going to be.
573 final double tileWidth, tileHeight;
574 if (bi.size.contain) {
575 // In the case of "contain", we compute the destination size based on the largest
576 // possible scale such that the aspect ratio is maintained, yet one side of the
577 // region is completely filled.
578 final double scaleX = width / imgUnscaledWidth;
579 final double scaleY = height / imgUnscaledHeight;
580 final double scale = Math.min(scaleX, scaleY);
581 tileWidth = Math.ceil(scale * imgUnscaledWidth);
582 tileHeight = Math.ceil(scale * imgUnscaledHeight);
583 } else if (bi.size.width >= 0 && bi.size.height >= 0) {
584 // The width and height have been expressly defined. Note that AUTO is -1,
585 // and all other negative values are disallowed, so by checking >= 0, we
586 // are essentially saying "if neither is AUTO"
587 tileWidth = w;
588 tileHeight = h;
589 } else if (w >= 0) {
590 // In this case, the width is specified, but the height is AUTO
591 tileWidth = w;
592 final double scale = tileWidth / imgUnscaledWidth;
593 tileHeight = imgUnscaledHeight * scale;
594 } else if (h >= 0) {
595 // Here the height is specified and the width is AUTO
596 tileHeight = h;
597 final double scale = tileHeight / imgUnscaledHeight;
598 tileWidth = imgUnscaledWidth * scale;
599 } else {
600 // Both are auto.
601 tileWidth = imgUnscaledWidth;
602 tileHeight = imgUnscaledHeight;
603 }
604
605 opaqueRegionTop = Double.isNaN(opaqueRegionTop) ? 0 : Math.min(0, opaqueRegionTop);
606 opaqueRegionRight = Double.isNaN(opaqueRegionRight) ? (width - tileWidth) : Math.min(width - tileWidth, opaqueRegionRight);
607 opaqueRegionBottom = Double.isNaN(opaqueRegionBottom) ? (height - tileHeight) : Math.min(height - tileHeight, opaqueRegionBottom);
608 opaqueRegionLeft = Double.isNaN(opaqueRegionLeft) ? 0 : Math.min(0, opaqueRegionLeft);
609 }
610 }
611 }
612
613 trbl[0] = opaqueRegionTop;
614 trbl[1] = opaqueRegionRight;
615 trbl[2] = opaqueRegionBottom;
616 trbl[3] = opaqueRegionLeft;
617 }
618
619 /**
620 * @inheritDoc
621 */
622 @Override public boolean equals(Object o) {
623 if (this == o) return true;
624 if (o == null || getClass() != o.getClass()) return false;
625 Background that = (Background) o;
626 // Because the hash is cached, this can be a very fast check
627 if (hash != that.hash) return false;
628 if (!fills.equals(that.fills)) return false;
629 if (!images.equals(that.images)) return false;
630
631 return true;
632 }
633
634 /**
635 * @inheritDoc
636 */
637 @Override public int hashCode() {
638 return hash;
639 }
640 }