Back to index...

	/*
	* Copyright (c) 1997, 2013, 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.image.Raster;
	import sun.awt.image.IntegerComponentRaster;
	import java.awt.image.ColorModel;
	import java.awt.image.DirectColorModel;
	import java.awt.geom.Point2D;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.NoninvertibleTransformException;
	import java.lang.ref.WeakReference;

	class GradientPaintContext implements PaintContext {
	static ColorModel xrgbmodel =
	new DirectColorModel(24, 0x00ff0000, 0x0000ff00, 0x000000ff);
	static ColorModel xbgrmodel =
	new DirectColorModel(24, 0x000000ff, 0x0000ff00, 0x00ff0000);

	static ColorModel cachedModel;
	static WeakReference<Raster> cached;

	static synchronized Raster getCachedRaster(ColorModel cm, int w, int h) {
	if (cm == cachedModel) {
	if (cached != null) {
	Raster ras = (Raster) cached.get();
	if (ras != null &&
	ras.getWidth() >= w &&
	ras.getHeight() >= h)
	{
	cached = null;
	return ras;
	}
	}
	}
	return cm.createCompatibleWritableRaster(w, h);
	}

	static synchronized void putCachedRaster(ColorModel cm, Raster ras) {
	if (cached != null) {
	Raster cras = (Raster) cached.get();
	if (cras != null) {
	int cw = cras.getWidth();
	int ch = cras.getHeight();
	int iw = ras.getWidth();
	int ih = ras.getHeight();
	if (cw >= iw && ch >= ih) {
	return;
	}
	if (cw * ch >= iw * ih) {
	return;
	}
	}
	}
	cachedModel = cm;
	cached = new WeakReference<>(ras);
	}

	double x1;
	double y1;
	double dx;
	double dy;
	boolean cyclic;
	int interp[];
	Raster saved;
	ColorModel model;

	public GradientPaintContext(ColorModel cm,
	Point2D p1, Point2D p2, AffineTransform xform,
	Color c1, Color c2, boolean cyclic) {
	// First calculate the distance moved in user space when
	// we move a single unit along the X & Y axes in device space.
	Point2D xvec = new Point2D.Double(1, 0);
	Point2D yvec = new Point2D.Double(0, 1);
	try {
	AffineTransform inverse = xform.createInverse();
	inverse.deltaTransform(xvec, xvec);
	inverse.deltaTransform(yvec, yvec);
	} catch (NoninvertibleTransformException e) {
	xvec.setLocation(0, 0);
	yvec.setLocation(0, 0);
	}

	// Now calculate the (square of the) user space distance
	// between the anchor points. This value equals:
	// (UserVec . UserVec)
	double udx = p2.getX() - p1.getX();
	double udy = p2.getY() - p1.getY();
	double ulenSq = udx * udx + udy * udy;

	if (ulenSq <= Double.MIN_VALUE) {
	dx = 0;
	dy = 0;
	} else {
	// Now calculate the proportional distance moved along the
	// vector from p1 to p2 when we move a unit along X & Y in
	// device space.
	//
	// The length of the projection of the Device Axis Vector is
	// its dot product with the Unit User Vector:
	// (DevAxisVec . (UserVec / Len(UserVec))
	//
	// The "proportional" length is that length divided again
	// by the length of the User Vector:
	// (DevAxisVec . (UserVec / Len(UserVec))) / Len(UserVec)
	// which simplifies to:
	// ((DevAxisVec . UserVec) / Len(UserVec)) / Len(UserVec)
	// which simplifies to:
	// (DevAxisVec . UserVec) / LenSquared(UserVec)
	dx = (xvec.getX() * udx + xvec.getY() * udy) / ulenSq;
	dy = (yvec.getX() * udx + yvec.getY() * udy) / ulenSq;

	if (cyclic) {
	dx = dx % 1.0;
	dy = dy % 1.0;
	} else {
	// We are acyclic
	if (dx < 0) {
	// If we are using the acyclic form below, we need
	// dx to be non-negative for simplicity of scanning
	// across the scan lines for the transition points.
	// To ensure that constraint, we negate the dx/dy
	// values and swap the points and colors.
	Point2D p = p1; p1 = p2; p2 = p;
	Color c = c1; c1 = c2; c2 = c;
	dx = -dx;
	dy = -dy;
	}
	}
	}

	Point2D dp1 = xform.transform(p1, null);
	this.x1 = dp1.getX();
	this.y1 = dp1.getY();

	this.cyclic = cyclic;
	int rgb1 = c1.getRGB();
	int rgb2 = c2.getRGB();
	int a1 = (rgb1 >> 24) & 0xff;
	int r1 = (rgb1 >> 16) & 0xff;
	int g1 = (rgb1 >> 8) & 0xff;
	int b1 = (rgb1 ) & 0xff;
	int da = ((rgb2 >> 24) & 0xff) - a1;
	int dr = ((rgb2 >> 16) & 0xff) - r1;
	int dg = ((rgb2 >> 8) & 0xff) - g1;
	int db = ((rgb2 ) & 0xff) - b1;
	if (a1 == 0xff && da == 0) {
	model = xrgbmodel;
	if (cm instanceof DirectColorModel) {
	DirectColorModel dcm = (DirectColorModel) cm;
	int tmp = dcm.getAlphaMask();
	if ((tmp == 0 \|\| tmp == 0xff) &&
	dcm.getRedMask() == 0xff &&
	dcm.getGreenMask() == 0xff00 &&
	dcm.getBlueMask() == 0xff0000)
	{
	model = xbgrmodel;
	tmp = r1; r1 = b1; b1 = tmp;
	tmp = dr; dr = db; db = tmp;
	}
	}
	} else {
	model = ColorModel.getRGBdefault();
	}
	interp = new int[cyclic ? 513 : 257];
	for (int i = 0; i <= 256; i++) {
	float rel = i / 256.0f;
	int rgb =
	(((int) (a1 + da * rel)) << 24) \|
	(((int) (r1 + dr * rel)) << 16) \|
	(((int) (g1 + dg * rel)) << 8) \|
	(((int) (b1 + db * rel)) );
	interp[i] = rgb;
	if (cyclic) {
	interp[512 - i] = rgb;
	}
	}
	}

	/**
	* Release the resources allocated for the operation.
	*/
	public void dispose() {
	if (saved != null) {
	putCachedRaster(model, saved);
	saved = null;
	}
	}

	/**
	* Return the ColorModel of the output.
	*/
	public ColorModel getColorModel() {
	return model;
	}

	/**
	* Return a Raster containing the colors generated for the graphics
	* operation.
	* @param x,y,w,h The area in device space for which colors are
	* generated.
	*/
	public Raster getRaster(int x, int y, int w, int h) {
	double rowrel = (x - x1) * dx + (y - y1) * dy;

	Raster rast = saved;
	if (rast == null \|\| rast.getWidth() < w \|\| rast.getHeight() < h) {
	rast = getCachedRaster(model, w, h);
	saved = rast;
	}
	IntegerComponentRaster irast = (IntegerComponentRaster) rast;
	int off = irast.getDataOffset(0);
	int adjust = irast.getScanlineStride() - w;
	int[] pixels = irast.getDataStorage();

	if (cyclic) {
	cycleFillRaster(pixels, off, adjust, w, h, rowrel, dx, dy);
	} else {
	clipFillRaster(pixels, off, adjust, w, h, rowrel, dx, dy);
	}

	irast.markDirty();

	return rast;
	}

	void cycleFillRaster(int[] pixels, int off, int adjust, int w, int h,
	double rowrel, double dx, double dy) {
	rowrel = rowrel % 2.0;
	int irowrel = ((int) (rowrel * (1 << 30))) << 1;
	int idx = (int) (-dx * (1 << 31));
	int idy = (int) (-dy * (1 << 31));
	while (--h >= 0) {
	int icolrel = irowrel;
	for (int j = w; j > 0; j--) {
	pixels[off++] = interp[icolrel >>> 23];
	icolrel += idx;
	}

	off += adjust;
	irowrel += idy;
	}
	}

	void clipFillRaster(int[] pixels, int off, int adjust, int w, int h,
	double rowrel, double dx, double dy) {
	while (--h >= 0) {
	double colrel = rowrel;
	int j = w;
	if (colrel <= 0.0) {
	int rgb = interp[0];
	do {
	pixels[off++] = rgb;
	colrel += dx;
	} while (--j > 0 && colrel <= 0.0);
	}
	while (colrel < 1.0 && --j >= 0) {
	pixels[off++] = interp[(int) (colrel * 256)];
	colrel += dx;
	}
	if (j > 0) {
	int rgb = interp[256];
	do {
	pixels[off++] = rgb;
	} while (--j > 0);
	}

	off += adjust;
	rowrel += dy;
	}
	}
	}

Back to index...