137 double yDiff = Math.max(pt1.getY(), pt2.getY()) - Math.min(pt1.getY(), pt2.getY());
138 return (int) Math.ceil(Math.sqrt(xDiff*xDiff + yDiff*yDiff));
139 }
140
141 private static class XRLinearGradient extends XRPaints {
142
143 @Override
144 boolean isPaintValid(SunGraphics2D sg2d) {
145 return true;
146 }
147
148 @Override
149 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
150 LinearGradientPaint paint = (LinearGradientPaint) pt;
151 boolean linear = (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
152
153 Color[] colors = paint.getColors();
154 Point2D pt1 = paint.getStartPoint();
155 Point2D pt2 = paint.getEndPoint();
156
157
158 AffineTransform at = paint.getTransform();
159 at.preConcatenate(sg2d.transform);
160
161 int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
162 float[] fractions = paint.getFractions();
163 int[] pixels = convertToIntArgbPixels(colors, linear);
164
165 try {
166 at.invert();
167 } catch (NoninvertibleTransformException ex) {
168 ex.printStackTrace();
169 }
170
171 XRBackend con = xrCompMan.getBackend();
172 int gradient = con.createLinearGradient(pt1, pt2, fractions, pixels, repeat, at);
173 xrCompMan.setGradientPaint(new XRSurfaceData.XRInternalSurfaceData(con, gradient, at));
174 }
175 }
176
177 private static class XRRadialGradient extends XRPaints {
178
179 @Override
180 boolean isPaintValid(SunGraphics2D sg2d) {
181 RadialGradientPaint grad = (RadialGradientPaint) sg2d.paint;
182 return grad.getFocusPoint().equals(grad.getCenterPoint());
183 }
184
185 @Override
186 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
187 RadialGradientPaint paint = (RadialGradientPaint) pt;
188 boolean linear = (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
189 Color[] colors = paint.getColors();
190 Point2D center = paint.getCenterPoint();
191 Point2D focus = paint.getFocusPoint();
192
193 int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
194 float[] fractions = paint.getFractions();
195 int[] pixels = convertToIntArgbPixels(colors, linear);
196 float radius = paint.getRadius();
197
198 // save original (untransformed) center and focus points
199 double cx = center.getX();
200 double cy = center.getY();
201 double fx = focus.getX();
202 double fy = focus.getY();
203
204 AffineTransform at = paint.getTransform();
205 at.preConcatenate(sg2d.transform);
206 focus = at.transform(focus, focus);
207
208 // transform unit circle to gradient coords; we start with the
209 // unit circle (center=(0,0), focus on positive x-axis, radius=1)
210 // and then transform into gradient space
211 at.translate(cx, cy);
212 at.rotate(fx - cx, fy - cy);
213 // at.scale(radius, radius);
214
215 // invert to get mapping from device coords to unit circle
216 try {
217 at.invert();
218 } catch (Exception e) {
219 at.setToScale(0.0, 0.0);
220 }
221 focus = at.transform(focus, focus);
222
223 // clamp the focus point so that it does not rest on, or outside
224 // of, the circumference of the gradient circle
225 fx = Math.min(focus.getX(), 0.99);
226
227 XRBackend con = xrCompMan.getBackend();
228 int gradient = con.createRadialGradient(new Point2D.Float(0, 0), new Point2D.Float(0, 0), 0, radius, fractions, pixels, repeat, at);
229 xrCompMan.setGradientPaint(new XRSurfaceData.XRInternalSurfaceData(con, gradient, at));
230 }
231 }
232
233 private static class XRTexture extends XRPaints {
234
235 @Override
236 boolean isPaintValid(SunGraphics2D sg2d) {
237 TexturePaint paint = (TexturePaint) sg2d.paint;
238 BufferedImage bi = paint.getImage();
239 XRSurfaceData dstData = (XRSurfaceData) sg2d.getDestSurface();
240
241 SurfaceData srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
242 if (!(srcData instanceof XRSurfaceData)) {
243 // REMIND: this is a hack that attempts to cache the system
244 // memory image from the TexturePaint instance into an
245 // OpenGL texture...
246 srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
247 if (!(srcData instanceof XRSurfaceData)) {
248 return false;
249 }
250 }
251
252 return true;
253 }
254
255 @Override
256 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
257 TexturePaint paint = (TexturePaint) pt;
258
259 BufferedImage bi = paint.getImage();
260 SurfaceData dstData = sg2d.surfaceData;
261 SurfaceData srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
262
263 // REMIND: this hack tries to ensure that we have a cached texture
264 if (!(srcData instanceof XRSurfaceData)) {
265 srcData = dstData.getSourceSurfaceData(paint.getImage(), SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
266 if (!(srcData instanceof XRSurfaceData)) {
267 throw new InternalError("Surface not cachable");
268 }
269 }
270
271 XRSurfaceData x11SrcData = (XRSurfaceData) srcData;
272
273 AffineTransform at = (AffineTransform) sg2d.transform.clone();
274 Rectangle2D anchor = paint.getAnchorRect();
275 at.translate(anchor.getX(), anchor.getY());
276 at.scale(anchor.getWidth() / ((double) bi.getWidth()), anchor.getHeight() / ((double) bi.getHeight()));
277
278 try {
279 at.invert();
280 } catch (NoninvertibleTransformException ex) {
281 at.setToIdentity(); /* TODO: Right thing to do in this case? */
282 }
283
284 x11SrcData.validateAsSource(at, XRUtils.RepeatNormal, XRUtils.ATransOpToXRQuality(sg2d.interpolationType));
285 xrCompMan.setTexturePaint(((XRSurfaceData) srcData));
286 }
287 }
288
289 public int[] convertToIntArgbPixels(Color[] colors, boolean linear) {
290 int[] pixels = new int[colors.length];
291 for (int i = 0; i < colors.length; i++) {
292 pixels[i] = colorToIntArgbPixel(colors[i], linear);
293 }
294 return pixels;
295 }
296
297 public int colorToIntArgbPixel(Color c, boolean linear) {
298 int rgb = c.getRGB();
299
300 int a = rgb >>> 24;
301 int r = (rgb >> 16) & 0xff;
302 int g = (rgb >> 8) & 0xff;
303 int b = (rgb) & 0xff;
304 if (linear) {
305 r = BufferedPaints.convertSRGBtoLinearRGB(r);
|
137 double yDiff = Math.max(pt1.getY(), pt2.getY()) - Math.min(pt1.getY(), pt2.getY());
138 return (int) Math.ceil(Math.sqrt(xDiff*xDiff + yDiff*yDiff));
139 }
140
141 private static class XRLinearGradient extends XRPaints {
142
143 @Override
144 boolean isPaintValid(SunGraphics2D sg2d) {
145 return true;
146 }
147
148 @Override
149 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
150 LinearGradientPaint paint = (LinearGradientPaint) pt;
151 boolean linear = (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
152
153 Color[] colors = paint.getColors();
154 Point2D pt1 = paint.getStartPoint();
155 Point2D pt2 = paint.getEndPoint();
156
157 AffineTransform at = paint.getTransform();
158 at.preConcatenate(sg2d.transform);
159
160 int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
161 float[] fractions = paint.getFractions();
162 int[] pixels = convertToIntArgbPixels(colors, linear);
163
164 try {
165 at.invert();
166 } catch (NoninvertibleTransformException ex) {
167 ex.printStackTrace();
168 }
169
170 XRBackend con = xrCompMan.getBackend();
171 int gradient = con.createLinearGradient(pt1, pt2, fractions, pixels, repeat, at);
172 xrCompMan.setGradientPaint(new XRSurfaceData.XRInternalSurfaceData(con, gradient, at));
173 }
174 }
175
176 private static class XRRadialGradient extends XRPaints {
177
178 @Override
179 boolean isPaintValid(SunGraphics2D sg2d) {
180 RadialGradientPaint grad = (RadialGradientPaint) sg2d.paint;
181 return grad.getFocusPoint().equals(grad.getCenterPoint());
182 }
183
184 @Override
185 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
186 RadialGradientPaint paint = (RadialGradientPaint) pt;
187 boolean linear = (paint.getColorSpace() == ColorSpaceType.LINEAR_RGB);
188 Color[] colors = paint.getColors();
189 Point2D center = paint.getCenterPoint();
190
191 int repeat = XRUtils.getRepeatForCycleMethod(paint.getCycleMethod());
192 float[] fractions = paint.getFractions();
193 int[] pixels = convertToIntArgbPixels(colors, linear);
194 float radius = paint.getRadius();
195
196 float cx = (float) center.getX();
197 float cy = (float) center.getY();
198
199 AffineTransform at = paint.getTransform();
200 at.preConcatenate(sg2d.transform);
201 try {
202 at.invert();
203 } catch (NoninvertibleTransformException ex) {
204 ex.printStackTrace();
205 }
206
207 XRBackend con = xrCompMan.getBackend();
208 int gradient = con.createRadialGradient(cx, cy, 0, radius, fractions, pixels, repeat, at);
209 xrCompMan.setGradientPaint(new XRSurfaceData.XRInternalSurfaceData(con, gradient, at));
210 }
211 }
212
213 private static class XRTexture extends XRPaints {
214
215 private XRSurfaceData getAccSrcSurface(XRSurfaceData dstData, BufferedImage bi) {
216 // REMIND: this is a hack that attempts to cache the system
217 // memory image from the TexturePaint instance into an
218 // XRender pixmap...
219 SurfaceData srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
220 if (!(srcData instanceof XRSurfaceData)) {
221 srcData = dstData.getSourceSurfaceData(bi, SunGraphics2D.TRANSFORM_ISIDENT, CompositeType.SrcOver, null);
222 if (!(srcData instanceof XRSurfaceData)) {
223 throw new InternalError("Surface not cachable");
224 }
225 }
226
227 return (XRSurfaceData) srcData;
228 }
229
230 @Override
231 boolean isPaintValid(SunGraphics2D sg2d) {
232 TexturePaint paint = (TexturePaint) sg2d.paint;
233 BufferedImage bi = paint.getImage();
234 XRSurfaceData dstData = (XRSurfaceData) sg2d.getDestSurface();
235
236 return getAccSrcSurface(dstData, bi) != null;
237 }
238
239 @Override
240 void setXRPaint(SunGraphics2D sg2d, Paint pt) {
241 TexturePaint paint = (TexturePaint) pt;
242 BufferedImage bi = paint.getImage();
243 Rectangle2D anchor = paint.getAnchorRect();
244
245 XRSurfaceData dstData = (XRSurfaceData) sg2d.surfaceData;
246 XRSurfaceData srcData = (XRSurfaceData) getAccSrcSurface(dstData, bi);
247
248 AffineTransform at = new AffineTransform();
249 at.translate(anchor.getX(), anchor.getY());
250 at.scale(anchor.getWidth() / ((double) bi.getWidth()), anchor.getHeight() / ((double) bi.getHeight()));
251
252 try {
253 at.invert();
254 } catch (NoninvertibleTransformException ex) {
255 at.setToIdentity();
256 }
257 srcData.setStaticSrcTx(at);
258
259 srcData.validateAsSource(at, XRUtils.RepeatNormal, XRUtils.ATransOpToXRQuality(sg2d.interpolationType));
260 xrCompMan.setTexturePaint(srcData);
261 }
262 }
263
264 public int[] convertToIntArgbPixels(Color[] colors, boolean linear) {
265 int[] pixels = new int[colors.length];
266 for (int i = 0; i < colors.length; i++) {
267 pixels[i] = colorToIntArgbPixel(colors[i], linear);
268 }
269 return pixels;
270 }
271
272 public int colorToIntArgbPixel(Color c, boolean linear) {
273 int rgb = c.getRGB();
274
275 int a = rgb >>> 24;
276 int r = (rgb >> 16) & 0xff;
277 int g = (rgb >> 8) & 0xff;
278 int b = (rgb) & 0xff;
279 if (linear) {
280 r = BufferedPaints.convertSRGBtoLinearRGB(r);
|