Java Code Examples for java.awt.MultipleGradientPaint.CycleMethod#NO_CYCLE

private Paint createPaint(PaintType type, int startx, int starty,
                          int w, int h)
{
    // make sure that the blue color doesn't show up when filling a
    // w by h rect
    w++; h++;

    int endx = startx + w;
    int endy = starty + h;
    Rectangle2D.Float r = new Rectangle2D.Float(startx, starty, w, h);
    switch (type) {
        case COLOR: return Color.red;
        case GRADIENT: return
            new GradientPaint(startx, starty, Color.red,
                              endx, endy, Color.green);
        case LINEAR_GRADIENT: return
            new LinearGradientPaint(startx, starty, endx, endy,
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue });
        case RADIAL_GRADIENT: return
            new RadialGradientPaint(startx, starty,
                (float)Math.sqrt(w * w + h * h),
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue },
                CycleMethod.NO_CYCLE);
        case TEXTURE: {
            BufferedImage bi =
                new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = (Graphics2D) bi.getGraphics();
            g.setPaint(createPaint(PaintType.LINEAR_GRADIENT, 0, 0, w, h));
            g.fillRect(0, 0, w, h);
            return new TexturePaint(bi, r);
        }
    }
    return Color.green;
}
 

private Paint createPaint(PaintType type, int startx, int starty,
                          int w, int h)
{
    // make sure that the blue color doesn't show up when filling a
    // w by h rect
    w++; h++;

    int endx = startx + w;
    int endy = starty + h;
    Rectangle2D.Float r = new Rectangle2D.Float(startx, starty, w, h);
    switch (type) {
        case COLOR: return Color.red;
        case GRADIENT: return
            new GradientPaint(startx, starty, Color.red,
                              endx, endy, Color.green);
        case LINEAR_GRADIENT: return
            new LinearGradientPaint(startx, starty, endx, endy,
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue });
        case RADIAL_GRADIENT: return
            new RadialGradientPaint(startx, starty,
                (float)Math.sqrt(w * w + h * h),
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue },
                CycleMethod.NO_CYCLE);
        case TEXTURE: {
            BufferedImage bi =
                new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = (Graphics2D) bi.getGraphics();
            g.setPaint(createPaint(PaintType.LINEAR_GRADIENT, 0, 0, w, h));
            g.fillRect(0, 0, w, h);
            return new TexturePaint(bi, r);
        }
    }
    return Color.green;
}
 

private Paint createPaint(PaintType type, int startx, int starty,
                          int w, int h)
{
    // make sure that the blue color doesn't show up when filling a
    // w by h rect
    w++; h++;

    int endx = startx + w;
    int endy = starty + h;
    Rectangle2D.Float r = new Rectangle2D.Float(startx, starty, w, h);
    switch (type) {
        case COLOR: return Color.red;
        case GRADIENT: return
            new GradientPaint(startx, starty, Color.red,
                              endx, endy, Color.green);
        case LINEAR_GRADIENT: return
            new LinearGradientPaint(startx, starty, endx, endy,
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue });
        case RADIAL_GRADIENT: return
            new RadialGradientPaint(startx, starty,
                (float)Math.sqrt(w * w + h * h),
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue },
                CycleMethod.NO_CYCLE);
        case TEXTURE: {
            BufferedImage bi =
                new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = (Graphics2D) bi.getGraphics();
            g.setPaint(createPaint(PaintType.LINEAR_GRADIENT, 0, 0, w, h));
            g.fillRect(0, 0, w, h);
            return new TexturePaint(bi, r);
        }
    }
    return Color.green;
}
 

private Paint createPaint(PaintType type, int startx, int starty,
                          int w, int h)
{
    // make sure that the blue color doesn't show up when filling a
    // w by h rect
    w++; h++;

    int endx = startx + w;
    int endy = starty + h;
    Rectangle2D.Float r = new Rectangle2D.Float(startx, starty, w, h);
    switch (type) {
        case COLOR: return Color.red;
        case GRADIENT: return
            new GradientPaint(startx, starty, Color.red,
                              endx, endy, Color.green);
        case LINEAR_GRADIENT: return
            new LinearGradientPaint(startx, starty, endx, endy,
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue });
        case RADIAL_GRADIENT: return
            new RadialGradientPaint(startx, starty,
                (float)Math.sqrt(w * w + h * h),
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue },
                CycleMethod.NO_CYCLE);
        case TEXTURE: {
            BufferedImage bi =
                new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = (Graphics2D) bi.getGraphics();
            g.setPaint(createPaint(PaintType.LINEAR_GRADIENT, 0, 0, w, h));
            g.fillRect(0, 0, w, h);
            return new TexturePaint(bi, r);
        }
    }
    return Color.green;
}
 

private Paint createPaint(PaintType type, int startx, int starty,
                          int w, int h)
{
    // make sure that the blue color doesn't show up when filling a
    // w by h rect
    w++; h++;

    int endx = startx + w;
    int endy = starty + h;
    Rectangle2D.Float r = new Rectangle2D.Float(startx, starty, w, h);
    switch (type) {
        case COLOR: return Color.red;
        case GRADIENT: return
            new GradientPaint(startx, starty, Color.red,
                              endx, endy, Color.green);
        case LINEAR_GRADIENT: return
            new LinearGradientPaint(startx, starty, endx, endy,
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue });
        case RADIAL_GRADIENT: return
            new RadialGradientPaint(startx, starty,
                (float)Math.sqrt(w * w + h * h),
                new float[] { 0.0f, 0.999f, 1.0f },
                new Color[] { Color.red, Color.green, Color.blue },
                CycleMethod.NO_CYCLE);
        case TEXTURE: {
            BufferedImage bi =
                new BufferedImage(w, h, BufferedImage.TYPE_INT_RGB);
            Graphics2D g = (Graphics2D) bi.getGraphics();
            g.setPaint(createPaint(PaintType.LINEAR_GRADIENT, 0, 0, w, h));
            g.fillRect(0, 0, w, h);
            return new TexturePaint(bi, r);
        }
    }
    return Color.green;
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @returns integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

/**
 * Constructor for RadialGradientPaintContext.
 *
 * @param paint the {@code RadialGradientPaint} from which this context
 *              is created
 * @param cm the {@code ColorModel} that receives
 *           the {@code Paint} data (this is used only as a hint)
 * @param deviceBounds the device space bounding box of the
 *                     graphics primitive being rendered
 * @param userBounds the user space bounding box of the
 *                   graphics primitive being rendered
 * @param t the {@code AffineTransform} from user
 *          space into device space (gradientTransform should be
 *          concatenated with this)
 * @param hints the hints that the context object uses to choose
 *              between rendering alternatives
 * @param cx the center X coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param cy the center Y coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param r the radius of the circle defining the extents of the
 *          color gradient
 * @param fx the X coordinate in user space to which the first color
 *           is mapped
 * @param fy the Y coordinate in user space to which the first color
 *           is mapped
 * @param fractions the fractions specifying the gradient distribution
 * @param colors the gradient colors
 * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
 * @param colorSpace which colorspace to use for interpolation,
 *                   either SRGB or LINEAR_RGB
 */
RadialGradientPaintContext(RadialGradientPaint paint,
                           ColorModel cm,
                           Rectangle deviceBounds,
                           Rectangle2D userBounds,
                           AffineTransform t,
                           RenderingHints hints,
                           float cx, float cy,
                           float r,
                           float fx, float fy,
                           float[] fractions,
                           Color[] colors,
                           CycleMethod cycleMethod,
                           ColorSpaceType colorSpace)
{
    super(paint, cm, deviceBounds, userBounds, t, hints,
          fractions, colors, cycleMethod, colorSpace);

    // copy some parameters
    centerX = cx;
    centerY = cy;
    focusX = fx;
    focusY = fy;
    radius = r;

    this.isSimpleFocus = (focusX == centerX) && (focusY == centerY);
    this.isNonCyclic = (cycleMethod == CycleMethod.NO_CYCLE);

    // for use in the quadractic equation
    radiusSq = radius * radius;

    float dX = focusX - centerX;
    float dY = focusY - centerY;

    double distSq = (dX * dX) + (dY * dY);

    // test if distance from focus to center is greater than the radius
    if (distSq > radiusSq * SCALEBACK) {
        // clamp focus to radius
        float scalefactor = (float)Math.sqrt(radiusSq * SCALEBACK / distSq);
        dX = dX * scalefactor;
        dY = dY * scalefactor;
        focusX = centerX + dX;
        focusY = centerY + dY;
    }

    // calculate the solution to be used in the case where X == focusX
    // in cyclicCircularGradientFillRaster()
    trivial = (float)Math.sqrt(radiusSq - (dX * dX));

    // constant parts of X, Y user space coordinates
    constA = a02 - centerX;
    constB = a12 - centerY;

    // constant second order delta for simple loop
    gDeltaDelta = 2 * ( a00 *  a00 +  a10 *  a10) / radiusSq;
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @returns integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @returns integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @return integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

/**
 * Constructor for RadialGradientPaintContext.
 *
 * @param paint the {@code RadialGradientPaint} from which this context
 *              is created
 * @param cm the {@code ColorModel} that receives
 *           the {@code Paint} data (this is used only as a hint)
 * @param deviceBounds the device space bounding box of the
 *                     graphics primitive being rendered
 * @param userBounds the user space bounding box of the
 *                   graphics primitive being rendered
 * @param t the {@code AffineTransform} from user
 *          space into device space (gradientTransform should be
 *          concatenated with this)
 * @param hints the hints that the context object uses to choose
 *              between rendering alternatives
 * @param cx the center X coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param cy the center Y coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param r the radius of the circle defining the extents of the
 *          color gradient
 * @param fx the X coordinate in user space to which the first color
 *           is mapped
 * @param fy the Y coordinate in user space to which the first color
 *           is mapped
 * @param fractions the fractions specifying the gradient distribution
 * @param colors the gradient colors
 * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
 * @param colorSpace which colorspace to use for interpolation,
 *                   either SRGB or LINEAR_RGB
 */
RadialGradientPaintContext(RadialGradientPaint paint,
                           ColorModel cm,
                           Rectangle deviceBounds,
                           Rectangle2D userBounds,
                           AffineTransform t,
                           RenderingHints hints,
                           float cx, float cy,
                           float r,
                           float fx, float fy,
                           float[] fractions,
                           Color[] colors,
                           CycleMethod cycleMethod,
                           ColorSpaceType colorSpace)
{
    super(paint, cm, deviceBounds, userBounds, t, hints,
          fractions, colors, cycleMethod, colorSpace);

    // copy some parameters
    centerX = cx;
    centerY = cy;
    focusX = fx;
    focusY = fy;
    radius = r;

    this.isSimpleFocus = (focusX == centerX) && (focusY == centerY);
    this.isNonCyclic = (cycleMethod == CycleMethod.NO_CYCLE);

    // for use in the quadractic equation
    radiusSq = radius * radius;

    float dX = focusX - centerX;
    float dY = focusY - centerY;

    double distSq = (dX * dX) + (dY * dY);

    // test if distance from focus to center is greater than the radius
    if (distSq > radiusSq * SCALEBACK) {
        // clamp focus to radius
        float scalefactor = (float)Math.sqrt(radiusSq * SCALEBACK / distSq);
        dX = dX * scalefactor;
        dY = dY * scalefactor;
        focusX = centerX + dX;
        focusY = centerY + dY;
    }

    // calculate the solution to be used in the case where X == focusX
    // in cyclicCircularGradientFillRaster()
    trivial = (float)Math.sqrt(radiusSq - (dX * dX));

    // constant parts of X, Y user space coordinates
    constA = a02 - centerX;
    constB = a12 - centerY;

    // constant second order delta for simple loop
    gDeltaDelta = 2 * ( a00 *  a00 +  a10 *  a10) / radiusSq;
}
 

private Paint makePaint(PaintType paintType,
                        CycleMethod cycleMethod,
                        ColorSpaceType colorSpace,
                        XformType xformType, int numStops)
{
    int startX   = TESTW/6;
    int startY   = TESTH/6;
    int endX     = TESTW/2;
    int endY     = TESTH/2;
    int ctrX     = TESTW/2;
    int ctrY     = TESTH/2;
    int focusX   = ctrX + 20;
    int focusY   = ctrY + 20;
    float radius = 100.0f;
    Paint paint;
    AffineTransform transform;

    Color[] colors = Arrays.copyOf(COLORS, numStops);
    float[] fractions = new float[colors.length];
    for (int i = 0; i < fractions.length; i++) {
        fractions[i] = ((float)i) / (fractions.length-1);
    }

    switch (xformType) {
    default:
    case IDENTITY:
        transform = new AffineTransform();
        break;
    case TRANSLATE:
        transform = AffineTransform.getTranslateInstance(2, 2);
        break;
    case SCALE:
        transform = AffineTransform.getScaleInstance(1.2, 1.4);
        break;
    case SHEAR:
        transform = AffineTransform.getShearInstance(0.1, 0.1);
        break;
    case ROTATE:
        transform = AffineTransform.getRotateInstance(Math.PI / 4,
                                                      getWidth()/2,
                                                      getHeight()/2);
        break;
    }

    switch (paintType) {
    case BASIC:
        boolean cyclic = (cycleMethod != CycleMethod.NO_CYCLE);
        paint =
            new GradientPaint(startX, startY, Color.RED,
                              endX, endY, Color.BLUE, cyclic);
        break;

    default:
    case LINEAR:
        paint =
            new LinearGradientPaint(new Point2D.Float(startX, startY),
                                    new Point2D.Float(endX, endY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;

    case RADIAL:
        paint =
            new RadialGradientPaint(new Point2D.Float(ctrX, ctrY),
                                    radius,
                                    new Point2D.Float(focusX, focusY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;
    }

    return paint;
}
 

/**
 * This method uses techniques that are nearly identical to those
 * employed in setGradientPaint() above.  The primary difference
 * is that at the native level we use a fragment shader to manually
 * apply the plane equation constants to the current fragment position
 * to calculate the gradient position in the range [0,1] (the native
 * code for GradientPaint does the same, except that it uses OpenGL's
 * automatic texture coordinate generation facilities).
 *
 * One other minor difference worth mentioning is that
 * setGradientPaint() calculates the plane equation constants
 * such that the gradient end points are positioned at 0.25 and 0.75
 * (for reasons discussed in the comments for that method).  In
 * contrast, for LinearGradientPaint we setup the equation constants
 * such that the gradient end points fall at 0.0 and 1.0.  The
 * reason for this difference is that in the fragment shader we
 * have more control over how the gradient values are interpreted
 * (depending on the paint's CycleMethod).
 */
private static void setLinearGradientPaint(RenderQueue rq,
                                           SunGraphics2D sg2d,
                                           LinearGradientPaint paint,
                                           boolean useMask)
{
    boolean linear =
        (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
    Color[] colors = paint.getColors();
    int numStops = colors.length;
    Point2D pt1 = paint.getStartPoint();
    Point2D pt2 = paint.getEndPoint();
    AffineTransform at = paint.getTransform();
    at.preConcatenate(sg2d.transform);

    if (!linear && numStops == 2 &&
        paint.getCycleMethod() != CycleMethod.REPEAT)
    {
        // delegate to the optimized two-color gradient codepath
        boolean isCyclic =
            (paint.getCycleMethod() != CycleMethod.NO_CYCLE);
        setGradientPaint(rq, at,
                         colors[0], colors[1],
                         pt1, pt2,
                         isCyclic, useMask);
        return;
    }

    int cycleMethod = paint.getCycleMethod().ordinal();
    float[] fractions = paint.getFractions();
    int[] pixels = convertToIntArgbPrePixels(colors, linear);

    // calculate plane equation constants
    double x = pt1.getX();
    double y = pt1.getY();
    at.translate(x, y);
    // now gradient point 1 is at the origin
    x = pt2.getX() - x;
    y = pt2.getY() - y;
    double len = Math.sqrt(x * x + y * y);
    at.rotate(x, y);
    // now gradient point 2 is on the positive x-axis
    at.scale(len, 1);
    // now gradient point 1 is at (0.0, 0), point 2 is at (1.0, 0)

    float p0, p1, p3;
    try {
        at.invert();
        p0 = (float)at.getScaleX();
        p1 = (float)at.getShearX();
        p3 = (float)at.getTranslateX();
    } catch (java.awt.geom.NoninvertibleTransformException e) {
        p0 = p1 = p3 = 0.0f;
    }

    // assert rq.lock.isHeldByCurrentThread();
    rq.ensureCapacity(20 + 12 + (numStops*4*2));
    RenderBuffer buf = rq.getBuffer();
    buf.putInt(SET_LINEAR_GRADIENT_PAINT);
    buf.putInt(useMask ? 1 : 0);
    buf.putInt(linear  ? 1 : 0);
    buf.putInt(cycleMethod);
    buf.putInt(numStops);
    buf.putFloat(p0);
    buf.putFloat(p1);
    buf.putFloat(p3);
    buf.put(fractions);
    buf.put(pixels);
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @returns integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

/**
 * Constructor for RadialGradientPaintContext.
 *
 * @param paint the {@code RadialGradientPaint} from which this context
 *              is created
 * @param cm the {@code ColorModel} that receives
 *           the {@code Paint} data (this is used only as a hint)
 * @param deviceBounds the device space bounding box of the
 *                     graphics primitive being rendered
 * @param userBounds the user space bounding box of the
 *                   graphics primitive being rendered
 * @param t the {@code AffineTransform} from user
 *          space into device space (gradientTransform should be
 *          concatenated with this)
 * @param hints the hints that the context object uses to choose
 *              between rendering alternatives
 * @param cx the center X coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param cy the center Y coordinate in user space of the circle defining
 *           the gradient.  The last color of the gradient is mapped to
 *           the perimeter of this circle.
 * @param r the radius of the circle defining the extents of the
 *          color gradient
 * @param fx the X coordinate in user space to which the first color
 *           is mapped
 * @param fy the Y coordinate in user space to which the first color
 *           is mapped
 * @param fractions the fractions specifying the gradient distribution
 * @param colors the gradient colors
 * @param cycleMethod either NO_CYCLE, REFLECT, or REPEAT
 * @param colorSpace which colorspace to use for interpolation,
 *                   either SRGB or LINEAR_RGB
 */
RadialGradientPaintContext(RadialGradientPaint paint,
                           ColorModel cm,
                           Rectangle deviceBounds,
                           Rectangle2D userBounds,
                           AffineTransform t,
                           RenderingHints hints,
                           float cx, float cy,
                           float r,
                           float fx, float fy,
                           float[] fractions,
                           Color[] colors,
                           CycleMethod cycleMethod,
                           ColorSpaceType colorSpace)
{
    super(paint, cm, deviceBounds, userBounds, t, hints,
          fractions, colors, cycleMethod, colorSpace);

    // copy some parameters
    centerX = cx;
    centerY = cy;
    focusX = fx;
    focusY = fy;
    radius = r;

    this.isSimpleFocus = (focusX == centerX) && (focusY == centerY);
    this.isNonCyclic = (cycleMethod == CycleMethod.NO_CYCLE);

    // for use in the quadractic equation
    radiusSq = radius * radius;

    float dX = focusX - centerX;
    float dY = focusY - centerY;

    double distSq = (dX * dX) + (dY * dY);

    // test if distance from focus to center is greater than the radius
    if (distSq > radiusSq * SCALEBACK) {
        // clamp focus to radius
        float scalefactor = (float)Math.sqrt(radiusSq * SCALEBACK / distSq);
        dX = dX * scalefactor;
        dY = dY * scalefactor;
        focusX = centerX + dX;
        focusY = centerY + dY;
    }

    // calculate the solution to be used in the case where X == focusX
    // in cyclicCircularGradientFillRaster()
    trivial = (float)Math.sqrt(radiusSq - (dX * dX));

    // constant parts of X, Y user space coordinates
    constA = a02 - centerX;
    constB = a12 - centerY;

    // constant second order delta for simple loop
    gDeltaDelta = 2 * ( a00 *  a00 +  a10 *  a10) / radiusSq;
}
 

/**
 * This method uses techniques that are nearly identical to those
 * employed in setGradientPaint() above.  The primary difference
 * is that at the native level we use a fragment shader to manually
 * apply the plane equation constants to the current fragment position
 * to calculate the gradient position in the range [0,1] (the native
 * code for GradientPaint does the same, except that it uses OpenGL's
 * automatic texture coordinate generation facilities).
 *
 * One other minor difference worth mentioning is that
 * setGradientPaint() calculates the plane equation constants
 * such that the gradient end points are positioned at 0.25 and 0.75
 * (for reasons discussed in the comments for that method).  In
 * contrast, for LinearGradientPaint we setup the equation constants
 * such that the gradient end points fall at 0.0 and 1.0.  The
 * reason for this difference is that in the fragment shader we
 * have more control over how the gradient values are interpreted
 * (depending on the paint's CycleMethod).
 */
private static void setLinearGradientPaint(RenderQueue rq,
                                           SunGraphics2D sg2d,
                                           LinearGradientPaint paint,
                                           boolean useMask)
{
    boolean linear =
        (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
    Color[] colors = paint.getColors();
    int numStops = colors.length;
    Point2D pt1 = paint.getStartPoint();
    Point2D pt2 = paint.getEndPoint();
    AffineTransform at = paint.getTransform();
    at.preConcatenate(sg2d.transform);

    if (!linear && numStops == 2 &&
        paint.getCycleMethod() != CycleMethod.REPEAT)
    {
        // delegate to the optimized two-color gradient codepath
        boolean isCyclic =
            (paint.getCycleMethod() != CycleMethod.NO_CYCLE);
        setGradientPaint(rq, at,
                         colors[0], colors[1],
                         pt1, pt2,
                         isCyclic, useMask);
        return;
    }

    int cycleMethod = paint.getCycleMethod().ordinal();
    float[] fractions = paint.getFractions();
    int[] pixels = convertToIntArgbPrePixels(colors, linear);

    // calculate plane equation constants
    double x = pt1.getX();
    double y = pt1.getY();
    at.translate(x, y);
    // now gradient point 1 is at the origin
    x = pt2.getX() - x;
    y = pt2.getY() - y;
    double len = Math.sqrt(x * x + y * y);
    at.rotate(x, y);
    // now gradient point 2 is on the positive x-axis
    at.scale(len, 1);
    // now gradient point 1 is at (0.0, 0), point 2 is at (1.0, 0)

    float p0, p1, p3;
    try {
        at.invert();
        p0 = (float)at.getScaleX();
        p1 = (float)at.getShearX();
        p3 = (float)at.getTranslateX();
    } catch (java.awt.geom.NoninvertibleTransformException e) {
        p0 = p1 = p3 = 0.0f;
    }

    // assert rq.lock.isHeldByCurrentThread();
    rq.ensureCapacity(20 + 12 + (numStops*4*2));
    RenderBuffer buf = rq.getBuffer();
    buf.putInt(SET_LINEAR_GRADIENT_PAINT);
    buf.putInt(useMask ? 1 : 0);
    buf.putInt(linear  ? 1 : 0);
    buf.putInt(cycleMethod);
    buf.putInt(numStops);
    buf.putFloat(p0);
    buf.putFloat(p1);
    buf.putFloat(p3);
    buf.put(fractions);
    buf.put(pixels);
}
 

/**
 * Helper function to index into the gradients array.  This is necessary
 * because each interval has an array of colors with uniform size 255.
 * However, the color intervals are not necessarily of uniform length, so
 * a conversion is required.
 *
 * @param position the unmanipulated position, which will be mapped
 *                 into the range 0 to 1
 * @returns integer color to display
 */
protected final int indexIntoGradientsArrays(float position) {
    // first, manipulate position value depending on the cycle method
    if (cycleMethod == CycleMethod.NO_CYCLE) {
        if (position > 1) {
            // upper bound is 1
            position = 1;
        } else if (position < 0) {
            // lower bound is 0
            position = 0;
        }
    } else if (cycleMethod == CycleMethod.REPEAT) {
        // get the fractional part
        // (modulo behavior discards integer component)
        position = position - (int)position;

        //position should now be between -1 and 1
        if (position < 0) {
            // force it to be in the range 0-1
            position = position + 1;
        }
    } else { // cycleMethod == CycleMethod.REFLECT
        if (position < 0) {
            // take absolute value
            position = -position;
        }

        // get the integer part
        int part = (int)position;

        // get the fractional part
        position = position - part;

        if ((part & 1) == 1) {
            // integer part is odd, get reflected color instead
            position = 1 - position;
        }
    }

    // now, get the color based on this 0-1 position...

    if (isSimpleLookup) {
        // easy to compute: just scale index by array size
        return gradient[(int)(position * fastGradientArraySize)];
    } else {
        // more complicated computation, to save space

        // for all the gradient interval arrays
        for (int i = 0; i < gradients.length; i++) {
            if (position < fractions[i+1]) {
                // this is the array we want
                float delta = position - fractions[i];

                // this is the interval we want
                int index = (int)((delta / normalizedIntervals[i])
                                  * (GRADIENT_SIZE_INDEX));

                return gradients[i][index];
            }
        }
    }

    return gradients[gradients.length - 1][GRADIENT_SIZE_INDEX];
}
 

private Paint makePaint(PaintType paintType,
                        CycleMethod cycleMethod,
                        ColorSpaceType colorSpace,
                        XformType xformType, int numStops)
{
    int startX   = TESTW/6;
    int startY   = TESTH/6;
    int endX     = TESTW/2;
    int endY     = TESTH/2;
    int ctrX     = TESTW/2;
    int ctrY     = TESTH/2;
    int focusX   = ctrX + 20;
    int focusY   = ctrY + 20;
    float radius = 100.0f;
    Paint paint;
    AffineTransform transform;

    Color[] colors = Arrays.copyOf(COLORS, numStops);
    float[] fractions = new float[colors.length];
    for (int i = 0; i < fractions.length; i++) {
        fractions[i] = ((float)i) / (fractions.length-1);
    }

    switch (xformType) {
    default:
    case IDENTITY:
        transform = new AffineTransform();
        break;
    case TRANSLATE:
        transform = AffineTransform.getTranslateInstance(2, 2);
        break;
    case SCALE:
        transform = AffineTransform.getScaleInstance(1.2, 1.4);
        break;
    case SHEAR:
        transform = AffineTransform.getShearInstance(0.1, 0.1);
        break;
    case ROTATE:
        transform = AffineTransform.getRotateInstance(Math.PI / 4,
                                                      getWidth()/2,
                                                      getHeight()/2);
        break;
    }

    switch (paintType) {
    case BASIC:
        boolean cyclic = (cycleMethod != CycleMethod.NO_CYCLE);
        paint =
            new GradientPaint(startX, startY, Color.RED,
                              endX, endY, Color.BLUE, cyclic);
        break;

    default:
    case LINEAR:
        paint =
            new LinearGradientPaint(new Point2D.Float(startX, startY),
                                    new Point2D.Float(endX, endY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;

    case RADIAL:
        paint =
            new RadialGradientPaint(new Point2D.Float(ctrX, ctrY),
                                    radius,
                                    new Point2D.Float(focusX, focusY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;
    }

    return paint;
}
 

private Paint makePaint(PaintType paintType,
                        CycleMethod cycleMethod,
                        ColorSpaceType colorSpace,
                        XformType xformType, int numStops)
{
    int startX   = TESTW/6;
    int startY   = TESTH/6;
    int endX     = TESTW/2;
    int endY     = TESTH/2;
    int ctrX     = TESTW/2;
    int ctrY     = TESTH/2;
    int focusX   = ctrX + 20;
    int focusY   = ctrY + 20;
    float radius = 100.0f;
    Paint paint;
    AffineTransform transform;

    Color[] colors = Arrays.copyOf(COLORS, numStops);
    float[] fractions = new float[colors.length];
    for (int i = 0; i < fractions.length; i++) {
        fractions[i] = ((float)i) / (fractions.length-1);
    }

    switch (xformType) {
    default:
    case IDENTITY:
        transform = new AffineTransform();
        break;
    case TRANSLATE:
        transform = AffineTransform.getTranslateInstance(2, 2);
        break;
    case SCALE:
        transform = AffineTransform.getScaleInstance(1.2, 1.4);
        break;
    case SHEAR:
        transform = AffineTransform.getShearInstance(0.1, 0.1);
        break;
    case ROTATE:
        transform = AffineTransform.getRotateInstance(Math.PI / 4,
                                                      getWidth()/2,
                                                      getHeight()/2);
        break;
    }

    switch (paintType) {
    case BASIC:
        boolean cyclic = (cycleMethod != CycleMethod.NO_CYCLE);
        paint =
            new GradientPaint(startX, startY, Color.RED,
                              endX, endY, Color.BLUE, cyclic);
        break;

    default:
    case LINEAR:
        paint =
            new LinearGradientPaint(new Point2D.Float(startX, startY),
                                    new Point2D.Float(endX, endY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;

    case RADIAL:
        paint =
            new RadialGradientPaint(new Point2D.Float(ctrX, ctrY),
                                    radius,
                                    new Point2D.Float(focusX, focusY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;
    }

    return paint;
}
 

private Paint makePaint(PaintType paintType,
                        CycleMethod cycleMethod,
                        ColorSpaceType colorSpace,
                        XformType xformType, int numStops)
{
    int startX   = TESTW/6;
    int startY   = TESTH/6;
    int endX     = TESTW/2;
    int endY     = TESTH/2;
    int ctrX     = TESTW/2;
    int ctrY     = TESTH/2;
    int focusX   = ctrX + 20;
    int focusY   = ctrY + 20;
    float radius = 100.0f;
    Paint paint;
    AffineTransform transform;

    Color[] colors = Arrays.copyOf(COLORS, numStops);
    float[] fractions = new float[colors.length];
    for (int i = 0; i < fractions.length; i++) {
        fractions[i] = ((float)i) / (fractions.length-1);
    }

    switch (xformType) {
    default:
    case IDENTITY:
        transform = new AffineTransform();
        break;
    case TRANSLATE:
        transform = AffineTransform.getTranslateInstance(2, 2);
        break;
    case SCALE:
        transform = AffineTransform.getScaleInstance(1.2, 1.4);
        break;
    case SHEAR:
        transform = AffineTransform.getShearInstance(0.1, 0.1);
        break;
    case ROTATE:
        transform = AffineTransform.getRotateInstance(Math.PI / 4,
                                                      getWidth()/2,
                                                      getHeight()/2);
        break;
    }

    switch (paintType) {
    case BASIC:
        boolean cyclic = (cycleMethod != CycleMethod.NO_CYCLE);
        paint =
            new GradientPaint(startX, startY, Color.RED,
                              endX, endY, Color.BLUE, cyclic);
        break;

    default:
    case LINEAR:
        paint =
            new LinearGradientPaint(new Point2D.Float(startX, startY),
                                    new Point2D.Float(endX, endY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;

    case RADIAL:
        paint =
            new RadialGradientPaint(new Point2D.Float(ctrX, ctrY),
                                    radius,
                                    new Point2D.Float(focusX, focusY),
                                    fractions, colors,
                                    cycleMethod, colorSpace,
                                    transform);
        break;
    }

    return paint;
}