diff options
Diffstat (limited to 'src/main/java/com/kitfox/svg/batik/MultipleGradientPaint.java')
| -rw-r--r-- | src/main/java/com/kitfox/svg/batik/MultipleGradientPaint.java | 236 |
1 files changed, 236 insertions, 0 deletions
diff --git a/src/main/java/com/kitfox/svg/batik/MultipleGradientPaint.java b/src/main/java/com/kitfox/svg/batik/MultipleGradientPaint.java new file mode 100644 index 0000000..9cd8c11 --- /dev/null +++ b/src/main/java/com/kitfox/svg/batik/MultipleGradientPaint.java @@ -0,0 +1,236 @@ +/*****************************************************************************
+ * Copyright (C) The Apache Software Foundation. All rights reserved. *
+ * ------------------------------------------------------------------------- *
+ * This software is published under the terms of the Apache Software License *
+ * version 1.1, a copy of which has been included with this distribution in *
+ * the LICENSE file. *
+ *****************************************************************************/
+
+package com.kitfox.svg.batik;
+
+import java.awt.Color;
+import java.awt.Paint;
+import java.awt.geom.AffineTransform;
+
+/** This is the superclass for Paints which use a multiple color
+ * gradient to fill in their raster. It provides storage for variables and
+ * enumerated values common to LinearGradientPaint and RadialGradientPaint.
+ *
+ *
+ * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans
+ * @author <a href="mailto:vincent.hardy@eng.sun.com">Vincent Hardy</a>
+ * @version $Id: MultipleGradientPaint.java,v 1.2 2004/09/27 09:27:27 kitfox Exp $
+ *
+ */
+
+public abstract class MultipleGradientPaint implements Paint {
+
+ /** Transparency. */
+ protected int transparency;
+
+ /** Gradient keyframe values in the range 0 to 1. */
+ protected float[] fractions;
+
+ /** Gradient colors. */
+ protected Color[] colors;
+
+ /** Transform to apply to gradient. */
+ protected AffineTransform gradientTransform;
+
+ /** The method to use when painting out of the gradient bounds. */
+ protected CycleMethodEnum cycleMethod;
+
+ /** The colorSpace in which to perform the interpolation. */
+ protected ColorSpaceEnum colorSpace;
+
+ /** Inner class to allow for typesafe enumerated ColorSpace values. */
+ public static class ColorSpaceEnum {
+ }
+
+ /** Inner class to allow for typesafe enumerated CycleMethod values. */
+ public static class CycleMethodEnum {
+ }
+
+ /** Indicates (if the gradient starts or ends inside the target region)
+ * to use the terminal colors to fill the remaining area. (default)
+ */
+ public static final CycleMethodEnum NO_CYCLE = new CycleMethodEnum();
+
+ /** Indicates (if the gradient starts or ends inside the target region),
+ * to cycle the gradient colors start-to-end, end-to-start to fill the
+ * remaining area.
+ */
+ public static final CycleMethodEnum REFLECT = new CycleMethodEnum();
+
+ /** Indicates (if the gradient starts or ends inside the target region),
+ * to cycle the gradient colors start-to-end, start-to-end to fill the
+ * remaining area.
+ */
+ public static final CycleMethodEnum REPEAT = new CycleMethodEnum();
+
+ /** Indicates that the color interpolation should occur in sRGB space.
+ * (default)
+ */
+ public static final ColorSpaceEnum SRGB = new ColorSpaceEnum();
+
+ /** Indicates that the color interpolation should occur in linearized
+ * RGB space.
+ */
+ public static final ColorSpaceEnum LINEAR_RGB = new ColorSpaceEnum();
+
+
+ /**
+ * Superclass constructor, typical user should never have to call this.
+ *
+ * @param fractions numbers ranging from 0.0 to 1.0 specifying the
+ * distribution of colors along the gradient
+ *
+ * @param colors array of colors corresponding to each fractional value
+ *
+ * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
+ *
+ * @param colorSpace which colorspace to use for interpolation,
+ * either SRGB or LINEAR_RGB
+ *
+ * @param gradientTransform transform to apply to the gradient
+ *
+ * @throws NullPointerException if arrays are null, or
+ * gradientTransform is null
+ *
+ * @throws IllegalArgumentException if fractions.length != colors.length,
+ * or if colors is less than 2 in size, or if an enumerated value is bad.
+ *
+ * @see java.awt.PaintContext
+ */
+ public MultipleGradientPaint(float[] fractions,
+ Color[] colors,
+ CycleMethodEnum cycleMethod,
+ ColorSpaceEnum colorSpace,
+ AffineTransform gradientTransform) {
+
+ if (fractions == null) {
+ throw new IllegalArgumentException("Fractions array cannot be " +
+ "null");
+ }
+
+ if (colors == null) {
+ throw new IllegalArgumentException("Colors array cannot be null");
+ }
+
+ if (fractions.length != colors.length) {
+ throw new IllegalArgumentException("Colors and fractions must " +
+ "have equal size");
+ }
+
+ if (colors.length < 2) {
+ throw new IllegalArgumentException("User must specify at least " +
+ "2 colors");
+ }
+
+ if ((colorSpace != LINEAR_RGB) &&
+ (colorSpace != SRGB)) {
+ throw new IllegalArgumentException("Invalid colorspace for " +
+ "interpolation.");
+ }
+
+ if ((cycleMethod != NO_CYCLE) &&
+ (cycleMethod != REFLECT) &&
+ (cycleMethod != REPEAT)) {
+ throw new IllegalArgumentException("Invalid cycle method.");
+ }
+
+ if (gradientTransform == null) {
+ throw new IllegalArgumentException("Gradient transform cannot be "+
+ "null.");
+ }
+
+ //copy the fractions array
+ this.fractions = new float[fractions.length];
+ System.arraycopy(fractions, 0, this.fractions, 0, fractions.length);
+
+ //copy the colors array
+ this.colors = new Color[colors.length];
+ System.arraycopy(colors, 0, this.colors, 0, colors.length);
+
+ //copy some flags
+ this.colorSpace = colorSpace;
+ this.cycleMethod = cycleMethod;
+
+ //copy the gradient transform
+ this.gradientTransform = (AffineTransform)gradientTransform.clone();
+
+ // Process transparency
+ boolean opaque = true;
+ for(int i=0; i<colors.length; i++){
+ opaque = opaque && (colors[i].getAlpha()==0xff);
+ }
+
+ if(opaque) {
+ transparency = OPAQUE;
+ }
+
+ else {
+ transparency = TRANSLUCENT;
+ }
+ }
+
+ /**
+ * Returns a copy of the array of colors used by this gradient.
+ * @return a copy of the array of colors used by this gradient
+ *
+ */
+ public Color[] getColors() {
+ Color colors[] = new Color[this.colors.length];
+ System.arraycopy(this.colors, 0, colors, 0, this.colors.length);
+ return colors;
+ }
+
+ /**
+ * Returns a copy of the array of floats used by this gradient
+ * to calculate color distribution.
+ * @return a copy of the array of floats used by this gradient to
+ * calculate color distribution
+ *
+ */
+ public float[] getFractions() {
+ float fractions[] = new float[this.fractions.length];
+ System.arraycopy(this.fractions, 0, fractions, 0, this.fractions.length);
+ return fractions;
+ }
+
+ /**
+ * Returns the transparency mode for this LinearGradientPaint.
+ * @return an integer value representing this LinearGradientPaint object's
+ * transparency mode.
+ * @see java.awt.Transparency
+ */
+ public int getTransparency() {
+ return transparency;
+ }
+
+ /**
+ * Returns the enumerated type which specifies cycling behavior.
+ * @return the enumerated type which specifies cycling behavior
+ */
+ public CycleMethodEnum getCycleMethod() {
+ return cycleMethod;
+ }
+
+ /**
+ * Returns the enumerated type which specifies color space for
+ * interpolation.
+ * @return the enumerated type which specifies color space for
+ * interpolation
+ */
+ public ColorSpaceEnum getColorSpace() {
+ return colorSpace;
+ }
+
+ /**
+ * Returns a copy of the transform applied to the gradient.
+ * @return a copy of the transform applied to the gradient.
+ */
+ public AffineTransform getTransform() {
+ return (AffineTransform)gradientTransform.clone();
+ }
+}
|