path: root/src/java/org/apache/fop/fo/properties/CommonBorderPaddingBackground.java

/*
 * 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$ */

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;

/**
 * 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<CommonBorderPaddingBackground> CACHE
            = new PropertyCache<CommonBorderPaddingBackground>();

    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<BorderInfo> CACHE
                = new PropertyCache<BorderInfo>();

        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
                    && this.backgroundColor == cbpb.backgroundColor
                    && this.backgroundImage.equals(cbpb.backgroundImage)
                    && this.backgroundPositionHorizontal == cbpb.backgroundPositionHorizontal
                    && this.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;
    }
}