org.apache.fop.fo.properties.CommonBorderPaddingBackground Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of org.apache.fop Show documentation
Show all versions of org.apache.fop Show documentation
The core maven build properties
The newest version!
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/* $Id: CommonBorderPaddingBackground.java 1612817 2014-07-23 11:58:15Z lbernardo $ */
package org.apache.fop.fo.properties;
import java.awt.Color;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Arrays;
import org.apache.xmlgraphics.image.loader.ImageException;
import org.apache.xmlgraphics.image.loader.ImageInfo;
import org.apache.xmlgraphics.image.loader.ImageManager;
import org.apache.xmlgraphics.image.loader.ImageSessionContext;
import org.apache.fop.ResourceEventProducer;
import org.apache.fop.apps.FOUserAgent;
import org.apache.fop.datatypes.Length;
import org.apache.fop.datatypes.PercentBaseContext;
import org.apache.fop.datatypes.URISpecification;
import org.apache.fop.fo.Constants;
import org.apache.fop.fo.FObj;
import org.apache.fop.fo.PropertyList;
import org.apache.fop.fo.expr.PropertyException;
import org.apache.fop.util.CompareUtil;
/**
* Stores all common border and padding properties.
* See Sec. 7.7 of the XSL-FO Standard.
*/
public class CommonBorderPaddingBackground {
/**
* cache holding all canonical instances
* (w/ absolute background-position-* and padding-*)
*/
private static final PropertyCache CACHE
= new PropertyCache();
private int hash = -1;
/**
* The "background-attachment" property.
*/
public final int backgroundAttachment;
/**
* The "background-color" property.
*/
public final Color backgroundColor;
/**
* The "background-image" property.
*/
public final String backgroundImage;
/**
* The "background-repeat" property.
*/
public final int backgroundRepeat;
/**
* The "background-position-horizontal" property.
*/
public final Length backgroundPositionHorizontal;
/**
* The "background-position-vertical" property.
*/
public final Length backgroundPositionVertical;
public final Length backgroungImageTargetWidth;
public final Length backgroungImageTargetHeight;
private ImageInfo backgroundImageInfo;
/** the "before" edge */
public static final int BEFORE = 0;
/** the "after" edge */
public static final int AFTER = 1;
/** the "start" edge */
public static final int START = 2;
/** the "end" edge */
public static final int END = 3;
/**
* Utility class to express border info.
*/
public static final class BorderInfo {
/** cache holding all canonical instances */
private static final PropertyCache CACHE
= new PropertyCache();
private int mStyle; // Enum for border style
private Color mColor; // Border color
private CondLengthProperty mWidth;
private CondLengthProperty radiusStart;
private CondLengthProperty radiusEnd;
private int hash = -1;
/**
* Hidden constructor
*/
private BorderInfo(int style, CondLengthProperty width, Color color,
CondLengthProperty radiusStart, CondLengthProperty radiusEnd) {
mStyle = style;
mWidth = width;
mColor = color;
this.radiusStart = radiusStart;
this.radiusEnd = radiusEnd;
}
/**
* Returns a BorderInfo instance corresponding to the given values.
*
* @param style the border-style
* @param width the border-width
* @param color the border-color
* @param radiusStart the start radius for rounded borders
* @param radiusEnd the end radius for rounded borders
* @return a cached BorderInfo instance
*/
public static BorderInfo getInstance(int style, CondLengthProperty width, Color color,
CondLengthProperty radiusStart, CondLengthProperty radiusEnd) {
return CACHE.fetch(new BorderInfo(style, width, color, radiusStart, radiusEnd));
}
/**
* @return the border-style
*/
public int getStyle() {
return this.mStyle;
}
/**
* @return the border-color
*/
public Color getColor() {
return this.mColor;
}
/**
* @return the border-width
*/
public CondLengthProperty getWidth() {
return this.mWidth;
}
/**
* Convenience method returning the border-width,
* taking into account values of "none" and "hidden"
*
* @return the retained border-width
*/
public int getRetainedWidth() {
if ((mStyle == Constants.EN_NONE)
|| (mStyle == Constants.EN_HIDDEN)) {
return 0;
} else {
return mWidth.getLengthValue();
}
}
/**
* @return the border-*-start-radius
*/
public CondLengthProperty getRadiusStart() {
return this.radiusStart;
}
/**
* @return the border-*-end-radius
*/
public CondLengthProperty getRadiusEnd() {
return this.radiusEnd;
}
@Override
public String toString() {
StringBuffer sb = new StringBuffer("BorderInfo");
sb.append(" {");
sb.append(mStyle);
sb.append(", ");
sb.append(mColor);
sb.append(", ");
sb.append(mWidth);
sb.append(", ");
sb.append(radiusStart);
sb.append(", ");
sb.append(radiusEnd);
sb.append("}");
return sb.toString();
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof BorderInfo)) {
return false;
}
BorderInfo bi = (BorderInfo)obj;
return (this.mColor == bi.mColor
&& this.mStyle == bi.mStyle
&& this.mWidth == bi.mWidth
&& this.radiusStart == bi.radiusStart
&& this.radiusEnd == bi.radiusEnd);
}
@Override
public int hashCode() {
if (this.hash == -1) {
int hash = 17;
hash = 37 * hash + (mColor == null ? 0 : mColor.hashCode());
hash = 37 * hash + mStyle;
hash = 37 * hash + (mWidth == null ? 0 : mWidth.hashCode());
hash = 37 * hash + (radiusStart == null ? 0 : radiusStart.hashCode());
hash = 37 * hash + (radiusEnd == null ? 0 : radiusEnd.hashCode());
this.hash = hash;
}
return this.hash;
}
}
/**
* A border info with style "none". Used as a singleton, in the collapsing-border model,
* for elements which don't specify any border on some of their sides.
*/
private static final BorderInfo DEFAULT_BORDER_INFO = BorderInfo.getInstance(
Constants.EN_NONE, new ConditionalNullLength(), null, new ConditionalNullLength(),
new ConditionalNullLength());
/**
* A conditional length of value 0. Returned by the
* {@link CommonBorderPaddingBackground#getBorderInfo(int)} method when the
* corresponding border isn't specified, to avoid to callers painful checks for null.
*/
private static class ConditionalNullLength extends CondLengthProperty {
@Override
public Property getComponent(int cmpId) {
throw new UnsupportedOperationException();
}
@Override
public Property getConditionality() {
throw new UnsupportedOperationException();
}
@Override
public Length getLength() {
throw new UnsupportedOperationException();
}
@Override
public Property getLengthComponent() {
throw new UnsupportedOperationException();
}
@Override
public int getLengthValue() {
return 0;
}
@Override
public int getLengthValue(PercentBaseContext context) {
return 0;
}
@Override
public boolean isDiscard() {
return true;
}
@Override
public void setComponent(int cmpId, Property cmpnValue, boolean isDefault) {
throw new UnsupportedOperationException();
}
@Override
public String toString() {
return "CondLength[0mpt, discard]";
}
}
/**
* Returns a default BorderInfo of style none.
*
* @return a BorderInfo instance with style set to {@link Constants#EN_NONE}
*/
public static BorderInfo getDefaultBorderInfo() {
return DEFAULT_BORDER_INFO;
}
private BorderInfo[] borderInfo = new BorderInfo[4];
private CondLengthProperty[] padding = new CondLengthProperty[4];
/**
* Construct a CommonBorderPaddingBackground object.
*
* @param pList The PropertyList to get properties from.
* @throws PropertyException if there's an error while binding the properties
*/
CommonBorderPaddingBackground(PropertyList pList) throws PropertyException {
backgroundAttachment = pList.get(Constants.PR_BACKGROUND_ATTACHMENT).getEnum();
Color bc = pList.get(Constants.PR_BACKGROUND_COLOR).getColor(
pList.getFObj().getUserAgent());
if (bc.getAlpha() == 0) {
backgroundColor = null;
} else {
backgroundColor = bc;
}
String img = pList.get(Constants.PR_BACKGROUND_IMAGE).getString();
if (img == null || "none".equals(img)) {
backgroundImage = "";
backgroundRepeat = -1;
backgroundPositionHorizontal = null;
backgroundPositionVertical = null;
} else {
backgroundImage = img;
backgroundRepeat = pList.get(Constants.PR_BACKGROUND_REPEAT).getEnum();
backgroundPositionHorizontal = pList.get(
Constants.PR_BACKGROUND_POSITION_HORIZONTAL).getLength();
backgroundPositionVertical = pList.get(
Constants.PR_BACKGROUND_POSITION_VERTICAL).getLength();
}
backgroungImageTargetWidth = pList.get(Constants.PR_X_BACKGROUND_IMAGE_WIDTH).getLength();
backgroungImageTargetHeight = pList.get(Constants.PR_X_BACKGROUND_IMAGE_HEIGHT).getLength();
initBorderInfo(pList, BEFORE,
Constants.PR_BORDER_BEFORE_COLOR,
Constants.PR_BORDER_BEFORE_STYLE,
Constants.PR_BORDER_BEFORE_WIDTH,
Constants.PR_PADDING_BEFORE,
Constants.PR_X_BORDER_BEFORE_RADIUS_START,
Constants.PR_X_BORDER_BEFORE_RADIUS_END);
initBorderInfo(pList, AFTER,
Constants.PR_BORDER_AFTER_COLOR,
Constants.PR_BORDER_AFTER_STYLE,
Constants.PR_BORDER_AFTER_WIDTH,
Constants.PR_PADDING_AFTER,
Constants.PR_X_BORDER_AFTER_RADIUS_START,
Constants.PR_X_BORDER_AFTER_RADIUS_END);
initBorderInfo(pList, START,
Constants.PR_BORDER_START_COLOR,
Constants.PR_BORDER_START_STYLE,
Constants.PR_BORDER_START_WIDTH,
Constants.PR_PADDING_START,
Constants.PR_X_BORDER_START_RADIUS_BEFORE,
Constants.PR_X_BORDER_START_RADIUS_AFTER);
initBorderInfo(pList, END,
Constants.PR_BORDER_END_COLOR,
Constants.PR_BORDER_END_STYLE,
Constants.PR_BORDER_END_WIDTH,
Constants.PR_PADDING_END,
Constants.PR_X_BORDER_END_RADIUS_BEFORE,
Constants.PR_X_BORDER_END_RADIUS_AFTER);
}
/**
* Obtain a CommonBorderPaddingBackground instance based on the
* related property valus in the given {@link PropertyList}
*
* @param pList the {@link PropertyList} to use
* @return a CommonBorderPaddingBackground instance (cached if possible)
* @throws PropertyException in case of an error
*/
public static CommonBorderPaddingBackground getInstance(PropertyList pList) throws PropertyException {
CommonBorderPaddingBackground newInstance = new CommonBorderPaddingBackground(pList);
CommonBorderPaddingBackground cachedInstance = null;
/* if padding-* and background-position-* resolve to absolute lengths
* the whole instance can be cached */
if ((newInstance.padding[BEFORE] == null || newInstance.padding[BEFORE].getLength().isAbsolute())
&& (newInstance.padding[AFTER] == null || newInstance.padding[AFTER].getLength().isAbsolute())
&& (newInstance.padding[START] == null || newInstance.padding[START].getLength().isAbsolute())
&& (newInstance.padding[END] == null || newInstance.padding[END].getLength().isAbsolute())
&& (newInstance.backgroundPositionHorizontal == null || newInstance.backgroundPositionHorizontal
.isAbsolute())
&& (newInstance.backgroundPositionVertical == null || newInstance.backgroundPositionVertical
.isAbsolute())
&& (newInstance.backgroungImageTargetHeight == null || newInstance.backgroungImageTargetHeight
.isAbsolute())
&& (newInstance.backgroungImageTargetWidth == null || newInstance.backgroungImageTargetWidth
.isAbsolute())) {
cachedInstance = CACHE.fetch(newInstance);
}
synchronized (newInstance.backgroundImage.intern()) {
/* for non-cached, or not-yet-cached instances, preload the image */
if ((cachedInstance == null || cachedInstance == newInstance)
&& !("".equals(newInstance.backgroundImage))) {
//Additional processing: preload image
String uri = URISpecification.getURL(newInstance.backgroundImage);
FObj fobj = pList.getFObj();
FOUserAgent userAgent = pList.getFObj().getUserAgent();
ImageManager manager = userAgent.getImageManager();
ImageSessionContext sessionContext = userAgent.getImageSessionContext();
ImageInfo info;
try {
info = manager.getImageInfo(uri, sessionContext);
newInstance.backgroundImageInfo = info;
} catch (ImageException e) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
fobj.getUserAgent().getEventBroadcaster());
eventProducer.imageError(fobj, uri, e, fobj.getLocator());
} catch (FileNotFoundException fnfe) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
fobj.getUserAgent().getEventBroadcaster());
eventProducer.imageNotFound(fobj, uri, fnfe, fobj.getLocator());
} catch (IOException ioe) {
ResourceEventProducer eventProducer = ResourceEventProducer.Provider.get(
fobj.getUserAgent().getEventBroadcaster());
eventProducer.imageIOError(fobj, uri, ioe, fobj.getLocator());
}
}
}
return (cachedInstance != null ? cachedInstance : newInstance);
}
private void initBorderInfo(PropertyList pList, int side,
int colorProp, int styleProp, int widthProp, int paddingProp,
int radiusStartProp, int radiusEndProp)
throws PropertyException {
padding[side] = pList.get(paddingProp).getCondLength();
// If style = none, force width to 0, don't get Color (spec 7.7.20)
int style = pList.get(styleProp).getEnum();
FOUserAgent ua = pList.getFObj().getUserAgent();
setBorderInfo(BorderInfo.getInstance(style,
pList.get(widthProp).getCondLength(),
pList.get(colorProp).getColor(ua),
pList.get(radiusStartProp).getCondLength(),
pList.get(radiusEndProp).getCondLength()), side);
}
/**
* Sets a border.
* @param info the border information
* @param side the side to apply the info to
*/
private void setBorderInfo(BorderInfo info, int side) {
this.borderInfo[side] = info;
}
/**
* @param side the side to retrieve
* @return the border info for a side
*/
public BorderInfo getBorderInfo(int side) {
if (this.borderInfo[side] == null) {
return getDefaultBorderInfo();
} else {
return this.borderInfo[side];
}
}
/**
* @return the background image info object, null if there is
* no background image.
*/
public ImageInfo getImageInfo() {
return this.backgroundImageInfo;
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @return the width of the start-border, taking into account the specified conditionality
*/
public int getBorderStartWidth(boolean discard) {
return getBorderWidth(START, discard);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (end of a reference-area)
* @return the width of the end-border, taking into account the specified conditionality
*/
public int getBorderEndWidth(boolean discard) {
return getBorderWidth(END, discard);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @return the width of the before-border, taking into account the specified conditionality
*/
public int getBorderBeforeWidth(boolean discard) {
return getBorderWidth(BEFORE, discard);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (end of a reference-area)
* @return the width of the after-border, taking into account the specified conditionality
*/
public int getBorderAfterWidth(boolean discard) {
return getBorderWidth(AFTER, discard);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @param context the context to evaluate percentage values
* @return the width of the start-padding, taking into account the specified conditionality
*/
public int getPaddingStart(boolean discard, PercentBaseContext context) {
return getPadding(START, discard, context);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @param context the context to evaluate percentage values
* @return the width of the end-padding, taking into account the specified conditionality
*/
public int getPaddingEnd(boolean discard, PercentBaseContext context) {
return getPadding(END, discard, context);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @param context the context to evaluate percentage values
* @return the width of the before-padding, taking into account the specified conditionality
*/
public int getPaddingBefore(boolean discard, PercentBaseContext context) {
return getPadding(BEFORE, discard, context);
}
/**
* @param discard indicates whether the .conditionality component should be
* considered (start of a reference-area)
* @param context the context to evaluate percentage values
* @return the width of the after-padding, taking into account the specified conditionality
*/
public int getPaddingAfter(boolean discard, PercentBaseContext context) {
return getPadding(AFTER, discard, context);
}
/**
* @param side the side of the border
* @param discard indicates whether the .conditionality component should be considered (end of a
* reference-area)
* @return the width of the start-border, taking into account the specified conditionality
*/
public int getBorderWidth(int side, boolean discard) {
if ((borderInfo[side] == null)
|| (borderInfo[side].mStyle == Constants.EN_NONE)
|| (borderInfo[side].mStyle == Constants.EN_HIDDEN)
|| (discard && borderInfo[side].mWidth.isDiscard())) {
return 0;
} else {
return borderInfo[side].mWidth.getLengthValue();
}
}
/**
* Returns the border corner radius of the starting edge
* i.e. the edge either adjacent to the before or start border.
* @param side the border side
* @param discard indicates whether the .conditionality component should be
* considered (end of a reference-area)
* @param context the context for percentage calculations
* @return the border radius of the of the starting corner
*/
public int getBorderRadiusStart(int side, boolean discard, PercentBaseContext context) {
if (borderInfo[side] == null) {
return 0;
} else {
return borderInfo[side].radiusStart.getLengthValue(context);
}
}
/**
* Returns the border corner radius of the ending edge
* i.e. the edge either adjacent to the after or end border
* @param side the border side
* @param discard indicates whether the .conditionality component should be
* considered (end of a reference-area)
* @param context the context for percentage calculations
* @return the border radius of the of the ending corner
*/
public int getBorderRadiusEnd(int side, boolean discard, PercentBaseContext context) {
if (borderInfo[side] == null) {
return 0;
} else {
return borderInfo[side].radiusEnd.getLengthValue(context);
}
}
/**
* The border-color for the given side
*
* @param side one of {@link #BEFORE}, {@link #AFTER}, {@link #START}, {@link #END}
* @return the border-color for the given side
*/
public Color getBorderColor(int side) {
if (borderInfo[side] != null) {
return borderInfo[side].getColor();
} else {
return null;
}
}
/**
* The border-style for the given side
*
* @param side one of {@link #BEFORE}, {@link #AFTER}, {@link #START}, {@link #END}
* @return the border-style for the given side
*/
public int getBorderStyle(int side) {
if (borderInfo[side] != null) {
return borderInfo[side].mStyle;
} else {
return Constants.EN_NONE;
}
}
/**
* Return the padding for the given side, taking into account
* the conditionality and evaluating any percentages in the given
* context.
*
* @param side one of {@link #BEFORE}, {@link #AFTER}, {@link #START}, {@link #END}
* @param discard true if the conditionality component should be considered
* @param context the context for percentage-resolution
* @return the computed padding for the given side
*/
public int getPadding(int side, boolean discard, PercentBaseContext context) {
if ((padding[side] == null) || (discard && padding[side].isDiscard())) {
return 0;
} else {
return padding[side].getLengthValue(context);
}
}
/**
* Returns the CondLengthProperty for the padding on one side.
* @param side the side
* @return the requested CondLengthProperty
*/
public CondLengthProperty getPaddingLengthProperty(int side) {
return padding[side];
}
/**
* Return all the border and padding width in the inline progression
* dimension.
* @param discard the discard flag.
* @param context for percentage evaluation.
* @return all the padding and border width.
*/
public int getIPPaddingAndBorder(boolean discard, PercentBaseContext context) {
return getPaddingStart(discard, context)
+ getPaddingEnd(discard, context)
+ getBorderStartWidth(discard)
+ getBorderEndWidth(discard);
}
/**
* Return all the border and padding height in the block progression
* dimension.
* @param discard the discard flag.
* @param context for percentage evaluation
* @return all the padding and border height.
*/
public int getBPPaddingAndBorder(boolean discard, PercentBaseContext context) {
return getPaddingBefore(discard, context) + getPaddingAfter(discard, context)
+ getBorderBeforeWidth(discard) + getBorderAfterWidth(discard);
}
@Override
public String toString() {
return "CommonBordersAndPadding (Before, After, Start, End):\n"
+ "Borders: (" + getBorderBeforeWidth(false) + ", " + getBorderAfterWidth(false) + ", "
+ getBorderStartWidth(false) + ", " + getBorderEndWidth(false) + ")\n"
+ "Border Colors: (" + getBorderColor(BEFORE) + ", " + getBorderColor(AFTER) + ", "
+ getBorderColor(START) + ", " + getBorderColor(END) + ")\n"
+ "Padding: (" + getPaddingBefore(false, null) + ", " + getPaddingAfter(false, null)
+ ", " + getPaddingStart(false, null) + ", " + getPaddingEnd(false, null) + ")\n";
}
/**
* @return true if there is any kind of background to be painted
*/
public boolean hasBackground() {
return ((backgroundColor != null || getImageInfo() != null));
}
/** @return true if border is non-zero. */
public boolean hasBorder() {
return ((getBorderBeforeWidth(false) + getBorderAfterWidth(false)
+ getBorderStartWidth(false) + getBorderEndWidth(false)) > 0);
}
/**
* @param context for percentage based evaluation.
* @return true if padding is non-zero.
*/
public boolean hasPadding(PercentBaseContext context) {
return ((getPaddingBefore(false, context) + getPaddingAfter(false, context)
+ getPaddingStart(false, context) + getPaddingEnd(false, context)) > 0);
}
/** @return true if there are any borders defined. */
public boolean hasBorderInfo() {
return (borderInfo[BEFORE] != null || borderInfo[AFTER] != null
|| borderInfo[START] != null || borderInfo[END] != null);
}
/**
* Returns the "background-color" property.
* @return the "background-color" property.
*/
public Color getBackgroundColor() {
return backgroundColor;
}
/**
* Returns the "background-attachment" property.
* @return the "background-attachment" property.
*/
public int getBackgroundAttachment() {
return backgroundAttachment;
}
/**
* Returns the "background-image" property.
* @return the "background-image" property.
*/
public String getBackgroundImage() {
return backgroundImage;
}
/**
* Returns the "background-repeat" property.
* @return the "background-repeat" property.
*/
public int getBackgroundRepeat() {
return backgroundRepeat;
}
/**
* Returns the "background-position-horizontal" property.
* @return the "background-position-horizontal" property.
*/
public Length getBackgroundPositionHorizontal() {
return backgroundPositionHorizontal;
}
/**
* Returns the "background-position-vertical" property.
* @return the "background-position-vertical" property.
*/
public Length getBackgroundPositionVertical() {
return backgroundPositionVertical;
}
/**
* Returns the background image info
* @return the background image info
*/
public ImageInfo getBackgroundImageInfo() {
return backgroundImageInfo;
}
/**
* Returns the border info
* @return the border info
*/
public BorderInfo[] getBorderInfo() {
return borderInfo;
}
/**
* Returns the padding
* @return the padding
*/
public CondLengthProperty[] getPadding() {
return padding;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj instanceof CommonBorderPaddingBackground) {
CommonBorderPaddingBackground cbpb = (CommonBorderPaddingBackground)obj;
return (this.backgroundAttachment == cbpb.backgroundAttachment
&& CompareUtil.equal(backgroundColor, cbpb.backgroundColor)
&& CompareUtil.equal(backgroundImage, cbpb.backgroundImage)
&& CompareUtil.equal(backgroundPositionHorizontal, backgroundPositionHorizontal)
&& CompareUtil.equal(backgroundPositionVertical, cbpb.backgroundPositionVertical)
&& this.backgroundRepeat == cbpb.backgroundRepeat
&& Arrays.equals(borderInfo, cbpb.borderInfo)
&& Arrays.equals(padding, cbpb.padding));
} else {
return false;
}
}
@Override
public int hashCode() {
if (this.hash == -1) {
int hash = getHashCode(backgroundColor,
backgroundImage,
backgroundPositionHorizontal,
backgroundPositionVertical,
backgroungImageTargetWidth,
backgroungImageTargetHeight,
borderInfo[BEFORE],
borderInfo[AFTER],
borderInfo[START],
borderInfo[END],
padding[BEFORE],
padding[AFTER],
padding[START],
padding[END]);
hash = 37 * hash + backgroundAttachment;
hash = 37 * hash + backgroundRepeat;
this.hash = hash;
}
return this.hash;
}
private int getHashCode(Object... objects) {
int hash = 17;
for (Object o : objects) {
hash = 37 * hash + (o == null ? 0 : o.hashCode());
}
return hash;
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy