You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
296 lines
9.2 KiB
296 lines
9.2 KiB
/*
|
|
* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|