| /* |
| * Copyright (c) 1997, 2007, 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 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; |
| } |
| } |
| } |
