Java tutorial
/* * Copyright (c) 2006, 2011, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package java.awt; import java.awt.geom.AffineTransform; import java.awt.image.ColorModel; import java.lang.ref.SoftReference; import java.util.Arrays; /** * 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 * {@code LinearGradientPaint} and {@code RadialGradientPaint}. * * @author Nicholas Talian, Vincent Hardy, Jim Graham, Jerry Evans * @since 1.6 */ public abstract class MultipleGradientPaint implements Paint { /** The method to use when painting outside the gradient bounds. * @since 1.6 */ public static enum CycleMethod { /** * Use the terminal colors to fill the remaining area. */ NO_CYCLE, /** * Cycle the gradient colors start-to-end, end-to-start * to fill the remaining area. */ REFLECT, /** * Cycle the gradient colors start-to-end, start-to-end * to fill the remaining area. */ REPEAT } /** The color space in which to perform the gradient interpolation. * @since 1.6 */ public static enum ColorSpaceType { /** * Indicates that the color interpolation should occur in sRGB space. */ SRGB, /** * Indicates that the color interpolation should occur in linearized * RGB space. */ LINEAR_RGB } /** The transparency of this paint object. */ final int transparency; /** Gradient keyframe values in the range 0 to 1. */ final float[] fractions; /** Gradient colors. */ final Color[] colors; /** Transform to apply to gradient. */ final AffineTransform gradientTransform; /** The method to use when painting outside the gradient bounds. */ final CycleMethod cycleMethod; /** The color space in which to perform the gradient interpolation. */ final ColorSpaceType colorSpace; /** * The following fields are used only by MultipleGradientPaintContext * to cache certain values that remain constant and do not need to be * recalculated for each context created from this paint instance. */ ColorModel model; float[] normalizedIntervals; boolean isSimpleLookup; SoftReference<int[][]> gradients; SoftReference<int[]> gradient; int fastGradientArraySize; /** * Package-private constructor. * * @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 {@code NO_CYCLE}, {@code REFLECT}, * or {@code REPEAT} * @param colorSpace which color space to use for interpolation, * either {@code SRGB} or {@code LINEAR_RGB} * @param gradientTransform transform to apply to the gradient * * @throws NullPointerException * if {@code fractions} array is null, * or {@code colors} array is null, * or {@code gradientTransform} is null, * or {@code cycleMethod} is null, * or {@code colorSpace} is null * @throws IllegalArgumentException * if {@code fractions.length != colors.length}, * or {@code colors} is less than 2 in size, * or a {@code fractions} value is less than 0.0 or greater than 1.0, * or the {@code fractions} are not provided in strictly increasing order */ MultipleGradientPaint(float[] fractions, Color[] colors, CycleMethod cycleMethod, ColorSpaceType colorSpace, AffineTransform gradientTransform) { if (fractions == null) { throw new NullPointerException("Fractions array cannot be null"); } if (colors == null) { throw new NullPointerException("Colors array cannot be null"); } if (cycleMethod == null) { throw new NullPointerException("Cycle method cannot be null"); } if (colorSpace == null) { throw new NullPointerException("Color space cannot be null"); } if (gradientTransform == null) { throw new NullPointerException("Gradient transform 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"); } // check that values are in the proper range and progress // in increasing order from 0 to 1 float previousFraction = -1.0f; for (float currentFraction : fractions) { if (currentFraction < 0f || currentFraction > 1f) { throw new IllegalArgumentException( "Fraction values must " + "be in the range 0 to 1: " + currentFraction); } if (currentFraction <= previousFraction) { throw new IllegalArgumentException( "Keyframe fractions " + "must be increasing: " + currentFraction); } previousFraction = currentFraction; } // We have to deal with the cases where the first gradient stop is not // equal to 0 and/or the last gradient stop is not equal to 1. // In both cases, create a new point and replicate the previous // extreme point's color. boolean fixFirst = false; boolean fixLast = false; int len = fractions.length; int off = 0; if (fractions[0] != 0f) { // first stop is not equal to zero, fix this condition fixFirst = true; len++; off++; } if (fractions[fractions.length - 1] != 1f) { // last stop is not equal to one, fix this condition fixLast = true; len++; } this.fractions = new float[len]; System.arraycopy(fractions, 0, this.fractions, off, fractions.length); this.colors = new Color[len]; System.arraycopy(colors, 0, this.colors, off, colors.length); if (fixFirst) { this.fractions[0] = 0f; this.colors[0] = colors[0]; } if (fixLast) { this.fractions[len - 1] = 1f; this.colors[len - 1] = colors[colors.length - 1]; } // copy some flags this.colorSpace = colorSpace; this.cycleMethod = cycleMethod; // copy the gradient transform this.gradientTransform = new AffineTransform(gradientTransform); // determine transparency boolean opaque = true; for (int i = 0; i < colors.length; i++) { opaque = opaque && (colors[i].getAlpha() == 0xff); } this.transparency = opaque ? OPAQUE : TRANSLUCENT; } /** * Returns a copy of the array of floats used by this gradient * to calculate color distribution. * The returned array always has 0 as its first value and 1 as its * last value, with increasing values in between. * * @return a copy of the array of floats used by this gradient to * calculate color distribution */ public final float[] getFractions() { return Arrays.copyOf(fractions, fractions.length); } /** * Returns a copy of the array of colors used by this gradient. * The first color maps to the first value in the fractions array, * and the last color maps to the last value in the fractions array. * * @return a copy of the array of colors used by this gradient */ public final Color[] getColors() { return Arrays.copyOf(colors, colors.length); } /** * Returns the enumerated type which specifies cycling behavior. * * @return the enumerated type which specifies cycling behavior */ public final CycleMethod getCycleMethod() { return cycleMethod; } /** * Returns the enumerated type which specifies color space for * interpolation. * * @return the enumerated type which specifies color space for * interpolation */ public final ColorSpaceType getColorSpace() { return colorSpace; } /** * Returns a copy of the transform applied to the gradient. * * <p> * Note that if no transform is applied to the gradient * when it is created, the identity transform is used. * * @return a copy of the transform applied to the gradient */ public final AffineTransform getTransform() { return new AffineTransform(gradientTransform); } /** * Returns the transparency mode for this {@code Paint} object. * * @return {@code OPAQUE} if all colors used by this * {@code Paint} object are opaque, * {@code TRANSLUCENT} if at least one of the * colors used by this {@code Paint} object is not opaque. * @see java.awt.Transparency */ public final int getTransparency() { return transparency; } }