1 /*
2  * Copyright (c) 2010, 2018, Oracle and/or its affiliates. All rights reserved.
3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4  *
5  * This code is free software; you can redistribute it and/or modify it
6  * under the terms of the GNU General Public License version 2 only, as
7  * published by the Free Software Foundation.  Oracle designates this
8  * particular file as subject to the "Classpath" exception as provided
9  * by Oracle in the LICENSE file that accompanied this code.
10  *
11  * This code is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14  * version 2 for more details (a copy is included in the LICENSE file that
15  * accompanied this code).
16  *
17  * You should have received a copy of the GNU General Public License version
18  * 2 along with this work; if not, write to the Free Software Foundation,
19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20  *
21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22  * or visit www.oracle.com if you need additional information or have any
23  * questions.
24  */
25 
26 package sun.java2d.xr;
27 
28 import java.awt.*;
29 import java.awt.MultipleGradientPaint.*;
30 import java.awt.geom.*;
31 import java.awt.image.*;
32 import sun.java2d.*;
33 import sun.java2d.loops.*;
34 import sun.java2d.xr.XRSurfaceData.XRInternalSurfaceData;
35 
36 abstract class XRPaints {
37     static XRCompositeManager xrCompMan;
38 
39     static final XRGradient xrGradient = new XRGradient();
40     static final XRLinearGradient xrLinearGradient = new XRLinearGradient();
41     static final XRRadialGradient xrRadialGradient = new XRRadialGradient();
42     static final XRTexture xrTexture = new XRTexture();
43 
register(XRCompositeManager xrComp)44     public static void register(XRCompositeManager xrComp) {
45         xrCompMan = xrComp;
46     }
47 
getXRPaint(SunGraphics2D sg2d)48     private static XRPaints getXRPaint(SunGraphics2D sg2d) {
49         switch (sg2d.paintState) {
50         case SunGraphics2D.PAINT_GRADIENT:
51             return xrGradient;
52 
53         case SunGraphics2D.PAINT_LIN_GRADIENT:
54             return xrLinearGradient;
55 
56         case SunGraphics2D.PAINT_RAD_GRADIENT:
57             return xrRadialGradient;
58 
59         case SunGraphics2D.PAINT_TEXTURE:
60             return xrTexture;
61 
62         default:
63             return null;
64         }
65     }
66 
67     /**
68      * Attempts to locate an implementation corresponding to the paint state of
69      * the provided SunGraphics2D object. If no implementation can be found, or
70      * if the paint cannot be accelerated under the conditions of the
71      * SunGraphics2D, this method returns false; otherwise, returns true.
72      */
isValid(SunGraphics2D sg2d)73     static boolean isValid(SunGraphics2D sg2d) {
74         XRPaints impl = getXRPaint(sg2d);
75         return (impl != null && impl.isPaintValid(sg2d));
76     }
77 
setPaint(SunGraphics2D sg2d, Paint paint)78     static void setPaint(SunGraphics2D sg2d, Paint paint) {
79         XRPaints impl = getXRPaint(sg2d);
80         if (impl != null) {
81             impl.setXRPaint(sg2d, paint);
82         }
83     }
84 
85     /**
86      * Returns true if this implementation is able to accelerate the Paint
87      * object associated with, and under the conditions of, the provided
88      * SunGraphics2D instance; otherwise returns false.
89      */
isPaintValid(SunGraphics2D sg2d)90     abstract boolean isPaintValid(SunGraphics2D sg2d);
91 
setXRPaint(SunGraphics2D sg2d, Paint paint)92     abstract void setXRPaint(SunGraphics2D sg2d, Paint paint);
93 
94     private static class XRGradient extends XRPaints {
XRGradient()95         private XRGradient() {
96         }
97 
98         @Override
isPaintValid(SunGraphics2D sg2d)99         boolean isPaintValid(SunGraphics2D sg2d) {
100             GradientPaint paint = (GradientPaint) sg2d.paint;
101 
102             return XRUtils.isPointCoordInShortRange(paint.getPoint1())
103                     && XRUtils.isPointCoordInShortRange(paint.getPoint2());
104         }
105 
106         @Override
setXRPaint(SunGraphics2D sg2d, Paint pt)107         void setXRPaint(SunGraphics2D sg2d, Paint pt) {
108             GradientPaint paint = (GradientPaint) pt;
109 
110             int repeat = paint.isCyclic() ? XRUtils.RepeatReflect : XRUtils.RepeatPad;
111             float[] fractions = {0, 1};
112             int[] pixels = convertToIntArgbPixels(new Color[] { paint.getColor1(), paint.getColor2() });
113 
114             Point2D pt1 = paint.getPoint1();
115             Point2D pt2 = paint.getPoint2();
116 
117             XRBackend con = xrCompMan.getBackend();
118             int gradient = con.createLinearGradient(pt1, pt2, fractions, pixels, repeat);
119             xrCompMan.setGradientPaint(new XRSurfaceData.XRInternalSurfaceData(con, gradient));
120         }
121     }
122 
getGradientLength(Point2D pt1, Point2D pt2)123     public int getGradientLength(Point2D pt1, Point2D pt2) {
124            double xDiff = Math.max(pt1.getX(), pt2.getX()) - Math.min(pt1.getX(), pt2.getX());
125            double yDiff = Math.max(pt1.getY(), pt2.getY()) - Math.min(pt1.getY(), pt2.getY());
126            return (int) Math.ceil(Math.sqrt(xDiff*xDiff + yDiff*yDiff));
127     }
128 
129     private static class XRLinearGradient extends XRPaints {
130 
131         @Override
isPaintValid(SunGraphics2D sg2d)132         boolean isPaintValid(SunGraphics2D sg2d) {
133             LinearGradientPaint paint = (LinearGradientPaint) sg2d.getPaint();
134 
135             return paint.getColorSpace() == ColorSpaceType.SRGB
136                     && XRUtils.isPointCoordInShortRange(paint.getStartPoint())
137                     && XRUtils.isPointCoordInShortRange(paint.getEndPoint())
138                     && paint.getTransform().getDeterminant() != 0.0;
139         }
140 
141         @Override
setXRPaint(SunGraphics2D sg2d, Paint pt)142         void setXRPaint(SunGraphics2D sg2d, Paint pt) {
143             LinearGradientPaint paint = (LinearGradientPaint) pt;
144             Color[] colors = paint.getColors();
145             Point2D pt1 = paint.getStartPoint();
146             Point2D pt2 = paint.getEndPoint();
147             int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
148             float[] fractions = paint.getFractions();
149             int[] pixels = convertToIntArgbPixels(colors);
150             AffineTransform at = paint.getTransform();
151 
152             try {
153                at.invert();
154             } catch (NoninvertibleTransformException ex) {
155                 ex.printStackTrace();
156             }
157 
158             XRBackend con = xrCompMan.getBackend();
159             int gradient = con.createLinearGradient(pt1, pt2, fractions, pixels, repeat);
160             XRInternalSurfaceData x11sd = new XRSurfaceData.XRInternalSurfaceData(con, gradient);
161             x11sd.setStaticSrcTx(at);
162             xrCompMan.setGradientPaint(x11sd);
163         }
164     }
165 
166     private static class XRRadialGradient extends XRPaints {
167 
168         @Override
isPaintValid(SunGraphics2D sg2d)169         boolean isPaintValid(SunGraphics2D sg2d) {
170             RadialGradientPaint grad = (RadialGradientPaint) sg2d.paint;
171 
172             return grad.getColorSpace() == ColorSpaceType.SRGB
173                    && grad.getFocusPoint().equals(grad.getCenterPoint())
174                    && XRUtils.isPointCoordInShortRange(grad.getCenterPoint())
175                    && grad.getRadius() <= Short.MAX_VALUE
176                    && grad.getTransform().getDeterminant() != 0.0;
177         }
178 
179         @Override
setXRPaint(SunGraphics2D sg2d, Paint pt)180         void setXRPaint(SunGraphics2D sg2d, Paint pt) {
181             RadialGradientPaint paint = (RadialGradientPaint) pt;
182             Color[] colors = paint.getColors();
183             Point2D center = paint.getCenterPoint();
184             float cx = (float) center.getX();
185             float cy = (float) center.getY();
186 
187             AffineTransform at = paint.getTransform();
188             int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
189             float[] fractions = paint.getFractions();
190             int[] pixels = convertToIntArgbPixels(colors);
191             float radius = paint.getRadius();
192 
193             try {
194                at.invert();
195             } catch (NoninvertibleTransformException ex) {
196                 ex.printStackTrace();
197             }
198 
199             XRBackend con = xrCompMan.getBackend();
200             int gradient = con.createRadialGradient(cx, cy, 0, radius, fractions, pixels, repeat);
201             XRInternalSurfaceData x11sd = new XRSurfaceData.XRInternalSurfaceData(con, gradient);
202             x11sd.setStaticSrcTx(at);
203             xrCompMan.setGradientPaint(x11sd);
204         }
205     }
206 
207     private static class XRTexture extends XRPaints {
208 
getAccSrcSurface(XRSurfaceData dstData, BufferedImage bi)209         private XRSurfaceData getAccSrcSurface(XRSurfaceData dstData, BufferedImage bi) {
210             // REMIND: this is a hack that attempts to cache the system
211             // memory image from the TexturePaint instance into an
212             // XRender pixmap...
213             SurfaceData srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
214             if (!(srcData instanceof XRSurfaceData)) {
215                 srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
216                 if (!(srcData instanceof XRSurfaceData)) {
217                     throw new InternalError("Surface not cachable");
218                 }
219             }
220 
221             return (XRSurfaceData) srcData;
222         }
223 
224         @Override
isPaintValid(SunGraphics2D sg2d)225         boolean isPaintValid(SunGraphics2D sg2d) {
226             TexturePaint paint = (TexturePaint) sg2d.paint;
227             BufferedImage bi = paint.getImage();
228             XRSurfaceData dstData = (XRSurfaceData) sg2d.getDestSurface();
229 
230             return getAccSrcSurface(dstData, bi) != null;
231         }
232 
233         @Override
setXRPaint(SunGraphics2D sg2d, Paint pt)234         void setXRPaint(SunGraphics2D sg2d, Paint pt) {
235             TexturePaint paint = (TexturePaint) pt;
236             BufferedImage bi = paint.getImage();
237             Rectangle2D anchor = paint.getAnchorRect();
238 
239             XRSurfaceData dstData = (XRSurfaceData) sg2d.surfaceData;
240             XRSurfaceData srcData = getAccSrcSurface(dstData, bi);
241 
242             AffineTransform at = new AffineTransform();
243             at.translate(anchor.getX(), anchor.getY());
244             at.scale(anchor.getWidth() / ((double) bi.getWidth()), anchor.getHeight() / ((double) bi.getHeight()));
245 
246             try {
247                 at.invert();
248             } catch (NoninvertibleTransformException ex) {
249                 at.setToIdentity();
250             }
251             srcData.setStaticSrcTx(at);
252 
253             srcData.validateAsSource(at, XRUtils.RepeatNormal, XRUtils.ATransOpToXRQuality(sg2d.interpolationType));
254             xrCompMan.setTexturePaint(srcData);
255         }
256     }
257 
convertToIntArgbPixels(Color[] colors)258     public int[] convertToIntArgbPixels(Color[] colors) {
259         int[] pixels = new int[colors.length];
260         for (int i = 0; i < colors.length; i++) {
261             pixels[i] = colorToIntArgbPixel(colors[i]);
262         }
263         return pixels;
264     }
265 
colorToIntArgbPixel(Color c)266     public int colorToIntArgbPixel(Color c) {
267         int rgb = c.getRGB();
268         int a = Math.round(xrCompMan.getExtraAlpha() * (rgb >>> 24));
269         return ((a << 24) | (rgb & 0x00FFFFFF));
270     }
271 }
272