w3c.css.properties.svg.SVGBasicStyle Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of cssvalidator Show documentation
Backend for the W3C CSS Validation Service
There is a newer version: 1.0.8
//
// $Id$
// From Sijtsche de Jong
//
// COPYRIGHT (c) 1995-2002 World Wide Web Consortium, (MIT, INRIA, Keio University)
// Please first read the full copyright statement at
// http://www.w3.org/Consortium/Legal/copyright-software-19980720

package org.w3c.css.properties.svg;

import org.w3c.css.properties.css.CssClipPath;
import org.w3c.css.properties.css.CssClipRule;
import org.w3c.css.properties.css.CssColorInterpolation;
import org.w3c.css.properties.css.CssColorProfile;
import org.w3c.css.properties.css.CssColorRendering;
import org.w3c.css.properties.css.CssEnableBackground;
import org.w3c.css.properties.css.CssFillOpacity;
import org.w3c.css.properties.css.CssGlyphOrientationHorizontal;
import org.w3c.css.properties.css.CssGlyphOrientationVertical;
import org.w3c.css.properties.css.CssImageRendering;
import org.w3c.css.properties.css.CssKerning;
import org.w3c.css.properties.css.CssMask;
import org.w3c.css.properties.css.CssPointerEvents;
import org.w3c.css.properties.css.CssShapeRendering;
import org.w3c.css.properties.css.CssStopColor;
import org.w3c.css.properties.css.CssStopOpacity;
import org.w3c.css.properties.css.CssStrokeOpacity;
import org.w3c.css.properties.css.CssTextAnchor;
import org.w3c.css.properties.css.CssTextRendering;

public class SVGBasicStyle extends SVGTinyStyle {

    public CssColorInterpolation cssColorInterpolation;
    public CssColorRendering cssColorRendering;
    public CssShapeRendering cssShapeRendering;
    public CssTextRendering cssTextRendering;
    public CssImageRendering cssImageRendering;
    public CssTextAnchor cssTextAnchor;
    public CssFillOpacity cssFillOpacity;
    public CssStrokeOpacity cssStrokeOpacity;
    public CssKerning cssKerning;
    public CssClipPath cssClipPath;
    public CssClipRule cssClipRule;
    public CssMask cssMask;
    public CssColorProfile cssColorProfile;
    public CssPointerEvents cssPointerEvents;
    public CssStopOpacity cssStopOpacity;
    public CssStopColor cssStopColor;
    public CssGlyphOrientationHorizontal cssGlyphOrientationHorizontal;
    public CssGlyphOrientationVertical cssGlyphOrientationVertical;
    public CssEnableBackground cssEnableBackground;

    public CssColorInterpolation getColorInterpolation() {
        if (cssColorInterpolation == null) {
            cssColorInterpolation =
                    (CssColorInterpolation) style.CascadingOrder(new CssColorInterpolation(),
                            style, selector);
        }
        return cssColorInterpolation;
    }

    public CssImageRendering getImageRendering() {
        if (cssImageRendering == null) {
            cssImageRendering =
                    (CssImageRendering) style.CascadingOrder(new CssImageRendering(),
                            style, selector);
        }
        return cssImageRendering;
    }

    public CssColorRendering getColorRendering() {
        if (cssColorRendering == null) {
            cssColorRendering =
                    (CssColorRendering) style.CascadingOrder(new CssColorRendering(),
                            style, selector);
        }
        return cssColorRendering;
    }

    public CssShapeRendering getShapeRendering() {
        if (cssShapeRendering == null) {
            cssShapeRendering =
                    (CssShapeRendering) style.CascadingOrder(new CssShapeRendering(),
                            style, selector);
        }
        return cssShapeRendering;
    }

    public CssTextRendering getTextRendering() {
        if (cssTextRendering == null) {
            cssTextRendering =
                    (CssTextRendering) style.CascadingOrder(new CssTextRendering(),
                            style, selector);
        }
        return cssTextRendering;
    }

    public CssTextAnchor getTextAnchor() {
        if (cssTextAnchor == null) {
            cssTextAnchor =
                    (CssTextAnchor) style.CascadingOrder(new CssTextAnchor(),
                            style, selector);
        }
        return cssTextAnchor;
    }

    public CssFillOpacity getFillOpacity() {
        if (cssFillOpacity == null) {
            cssFillOpacity =
                    (CssFillOpacity) style.CascadingOrder(new CssFillOpacity(),
                            style, selector);
        }
        return cssFillOpacity;
    }

    public CssStrokeOpacity getStrokeOpacity() {
        if (cssStrokeOpacity == null) {
            cssStrokeOpacity =
                    (CssStrokeOpacity) style.CascadingOrder(new CssStrokeOpacity(),
                            style, selector);
        }
        return cssStrokeOpacity;
    }

    public CssKerning getKerning() {
        if (cssKerning == null) {
            cssKerning =
                    (CssKerning) style.CascadingOrder(new CssKerning(),
                            style, selector);
        }
        return cssKerning;
    }

    public CssClipPath getClipPath() {
        if (cssClipPath == null) {
            cssClipPath =
                    (CssClipPath) style.CascadingOrder(new CssClipPath(),
                            style, selector);
        }
        return cssClipPath;
    }

    public CssClipRule getClipRule() {
        if (cssClipRule == null) {
            cssClipRule =
                    (CssClipRule) style.CascadingOrder(new CssClipRule(),
                            style, selector);
        }
        return cssClipRule;
    }

    public CssMask getMask() {
        if (cssMask == null) {
            cssMask =
                    (CssMask) style.CascadingOrder(new CssMask(),
                            style, selector);
        }
        return cssMask;
    }

    public CssColorProfile getColorProfile() {
        if (cssColorProfile == null) {
            cssColorProfile =
                    (CssColorProfile) style.CascadingOrder(new CssColorProfile(),
                            style, selector);
        }
        return cssColorProfile;
    }

    public CssPointerEvents getPointerEvents() {
        if (cssPointerEvents == null) {
            cssPointerEvents =
                    (CssPointerEvents) style.CascadingOrder(new CssPointerEvents(),
                            style, selector);
        }
        return cssPointerEvents;
    }

    public CssStopOpacity getStopOpacity() {
        if (cssStopOpacity == null) {
            cssStopOpacity =
                    (CssStopOpacity) style.CascadingOrder(new CssStopOpacity(),
                            style, selector);
        }
        return cssStopOpacity;
    }

    public CssStopColor getStopColor() {
        if (cssStopColor == null) {
            cssStopColor =
                    (CssStopColor) style.CascadingOrder(new CssStopColor(),
                            style, selector);
        }
        return cssStopColor;
    }

    public CssGlyphOrientationHorizontal getGlyphOrientationHorizontal() {
        if (cssGlyphOrientationHorizontal == null) {
            cssGlyphOrientationHorizontal =
                    (CssGlyphOrientationHorizontal) style.CascadingOrder(new CssGlyphOrientationHorizontal(),
                            style, selector);
        }
        return cssGlyphOrientationHorizontal;
    }

    public CssGlyphOrientationVertical getGlyphOrientationVertical() {
        if (cssGlyphOrientationVertical == null) {
            cssGlyphOrientationVertical =
                    (CssGlyphOrientationVertical) style.CascadingOrder(new CssGlyphOrientationVertical(),
                            style, selector);
        }
        return cssGlyphOrientationVertical;
    }

    public CssEnableBackground getEnableBackground() {
        if (cssEnableBackground == null) {
            cssEnableBackground =
                    (CssEnableBackground) style.CascadingOrder(new CssEnableBackground(),
                            style, selector);
        }
        return cssEnableBackground;
    }

}