1 /*
2 * Copyright (c) 2011, 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;
27
28 import java.awt.*;
29 import java.awt.geom.*;
30 import java.awt.image.*;
31 import java.nio.*;
32
33 import sun.awt.image.*;
34 import sun.java2d.loops.*;
35 import sun.java2d.pipe.*;
36 import sun.lwawt.macosx.*;
37
38 public class CRenderer implements PixelDrawPipe, PixelFillPipe, ShapeDrawPipe, DrawImagePipe {
39 native static void init();
40
41 // cache of the runtime options
42 static {
43 init(); // initialize coordinate tables for shapes
44 }
45
46 native void doLine(SurfaceData sData, float x1, float y1, float x2, float y2);
47
48 public void drawLine(SunGraphics2D sg2d, int x1, int y1, int x2, int y2) {
49 drawLine(sg2d, (float) x1, (float) y1, (float) x2, (float) y2);
50 }
51
52 Line2D lineToShape;
53
54 public void drawLine(SunGraphics2D sg2d, float x1, float y1, float x2, float y2) {
55 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
56 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
57 surfaceData.doLine(this, sg2d, x1, y1, x2, y2);
58 } else {
59 if (lineToShape == null) {
60 synchronized (this) {
61 if (lineToShape == null) {
62 lineToShape = new Line2D.Float();
63 }
64 }
65 }
66 synchronized (lineToShape) {
67 lineToShape.setLine(x1, y1, x2, y2);
68 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(lineToShape), true, true);
69 }
70 }
71 }
72
73 native void doRect(SurfaceData sData, float x, float y, float width, float height, boolean isfill);
74
75 public void drawRect(SunGraphics2D sg2d, int x, int y, int width, int height) {
76 drawRect(sg2d, (float) x, (float) y, (float) width, (float) height);
77 }
78
79 Rectangle2D rectToShape;
80
81 public void drawRect(SunGraphics2D sg2d, float x, float y, float width, float height) {
82 if ((width < 0) || (height < 0)) return;
83
84 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
85 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
86 surfaceData.doRect(this, sg2d, x, y, width, height, false);
87 } else {
88 if (rectToShape == null) {
89 synchronized (this) {
90 if (rectToShape == null) {
91 rectToShape = new Rectangle2D.Float();
92 }
93 }
94 }
95 synchronized (rectToShape) {
96 rectToShape.setRect(x, y, width, height);
97 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(rectToShape), true, true);
98 }
99 }
100 }
101
102 public void fillRect(SunGraphics2D sg2d, int x, int y, int width, int height) {
103 fillRect(sg2d, (float) x, (float) y, (float) width, (float) height);
104 }
105
106 public void fillRect(SunGraphics2D sg2d, float x, float y, float width, float height) {
107 if ((width >= 0) && (height >= 0)) {
108 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
109 surfaceData.doRect(this, sg2d, x, y, width, height, true);
110 }
111 }
112
113 native void doRoundRect(SurfaceData sData, float x, float y, float width, float height, float arcW, float arcH, boolean isfill);
114
115 public void drawRoundRect(SunGraphics2D sg2d, int x, int y, int width, int height, int arcWidth, int arcHeight) {
116 drawRoundRect(sg2d, (float) x, (float) y, (float) width, (float) height, (float) arcWidth, (float) arcHeight);
117 }
118
119 RoundRectangle2D roundrectToShape;
120
121 public void drawRoundRect(SunGraphics2D sg2d, float x, float y, float width, float height, float arcWidth, float arcHeight) {
122 if ((width < 0) || (height < 0)) return;
123
124 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
125 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
126 surfaceData.doRoundRect(this, sg2d, x, y, width, height, arcWidth, arcHeight, false);
127 } else {
128 if (roundrectToShape == null) {
129 synchronized (this) {
130 if (roundrectToShape == null) {
131 roundrectToShape = new RoundRectangle2D.Float();
132 }
133 }
134 }
135 synchronized (roundrectToShape) {
136 roundrectToShape.setRoundRect(x, y, width, height, arcWidth, arcHeight);
137 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(roundrectToShape), true, true);
138 }
139 }
140 }
141
142 public void fillRoundRect(SunGraphics2D sg2d, int x, int y, int width, int height, int arcWidth, int arcHeight) {
143 fillRoundRect(sg2d, (float) x, (float) y, (float) width, (float) height, (float) arcWidth, (float) arcHeight);
144 }
145
146 public void fillRoundRect(SunGraphics2D sg2d, float x, float y, float width, float height, float arcWidth, float arcHeight) {
147 if ((width < 0) || (height < 0)) return;
148 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
149 surfaceData.doRoundRect(this, sg2d, x, y, width, height, arcWidth, arcHeight, true);
150 }
151
152 native void doOval(SurfaceData sData, float x, float y, float width, float height, boolean isfill);
153
154 public void drawOval(SunGraphics2D sg2d, int x, int y, int width, int height) {
155 drawOval(sg2d, (float) x, (float) y, (float) width, (float) height);
156 }
157
158 Ellipse2D ovalToShape;
159
160 public void drawOval(SunGraphics2D sg2d, float x, float y, float width, float height) {
161 if ((width < 0) || (height < 0)) return;
162
163 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
164 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
165 surfaceData.doOval(this, sg2d, x, y, width, height, false);
166 } else {
167 if (ovalToShape == null) {
168 synchronized (this) {
169 if (ovalToShape == null) {
170 ovalToShape = new Ellipse2D.Float();
171 }
172 }
173 }
174 synchronized (ovalToShape) {
175 ovalToShape.setFrame(x, y, width, height);
176 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(ovalToShape), true, true);
177 }
178 }
179 }
180
181 public void fillOval(SunGraphics2D sg2d, int x, int y, int width, int height) {
182 fillOval(sg2d, (float) x, (float) y, (float) width, (float) height);
183 }
184
185 public void fillOval(SunGraphics2D sg2d, float x, float y, float width, float height) {
186 if ((width < 0) || (height < 0)) return;
187 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
188 surfaceData.doOval(this, sg2d, x, y, width, height, true);
189 }
190
191 native void doArc(SurfaceData sData, float x, float y, float width, float height, float angleStart, float angleExtent, int type, boolean isfill);
192
193 public void drawArc(SunGraphics2D sg2d, int x, int y, int width, int height, int startAngle, int arcAngle) {
194 drawArc(sg2d, x, y, width, height, startAngle, arcAngle, Arc2D.OPEN);
195 }
196
197 Arc2D arcToShape;
198
199 public void drawArc(SunGraphics2D sg2d, float x, float y, float width, float height, float startAngle, float arcAngle, int type) {
200 if ((width < 0) || (height < 0)) return;
201
202 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
203 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
204 surfaceData.doArc(this, sg2d, x, y, width, height, startAngle, arcAngle, type, false);
205 } else {
206 if (arcToShape == null) {
207 synchronized (this) {
208 if (arcToShape == null) {
209 arcToShape = new Arc2D.Float();
210 }
211 }
212 }
213 synchronized (arcToShape) {
214 arcToShape.setArc(x, y, width, height, startAngle, arcAngle, type);
215 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(arcToShape), true, true);
216 }
217 }
218 }
219
220 public void fillArc(SunGraphics2D sg2d, int x, int y, int width, int height, int startAngle, int arcAngle) {
221 fillArc(sg2d, x, y, width, height, startAngle, arcAngle, Arc2D.PIE);
222 }
223
224 public void fillArc(SunGraphics2D sg2d, float x, float y, float width, float height, float startAngle, float arcAngle, int type) {
225 if ((width < 0) || (height < 0)) return;
226
227 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
228 surfaceData.doArc(this, sg2d, x, y, width, height, startAngle, arcAngle, type, true);
229 }
230
231 native void doPoly(SurfaceData sData, int[] xpoints, int[] ypoints, int npoints, boolean ispolygon, boolean isfill);
232
233 public void drawPolyline(SunGraphics2D sg2d, int xpoints[], int ypoints[], int npoints) {
234 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
235 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
236 surfaceData.doPolygon(this, sg2d, xpoints, ypoints, npoints, false, false);
237 } else {
238 GeneralPath polyToShape = new GeneralPath();
239 polyToShape.moveTo(xpoints[0], ypoints[0]);
240 for (int i = 1; i < npoints; i++) {
241 polyToShape.lineTo(xpoints[i], ypoints[i]);
242 }
243 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(polyToShape), true, true);
244 }
245 }
246
247 public void drawPolygon(SunGraphics2D sg2d, int xpoints[], int ypoints[], int npoints) {
248 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
249 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
250 surfaceData.doPolygon(this, sg2d, xpoints, ypoints, npoints, true, false);
251 } else {
252 GeneralPath polyToShape = new GeneralPath();
253 polyToShape.moveTo(xpoints[0], ypoints[0]);
254 for (int i = 1; i < npoints; i++) {
255 polyToShape.lineTo(xpoints[i], ypoints[i]);
256 }
257 polyToShape.lineTo(xpoints[0], ypoints[0]);
258 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(polyToShape), true, true);
259 }
260 }
261
262 public void fillPolygon(SunGraphics2D sg2d, int xpoints[], int ypoints[], int npoints) {
263 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
264 surfaceData.doPolygon(this, sg2d, xpoints, ypoints, npoints, true, true);
265 }
266
267 native void doShape(SurfaceData sData, int length, FloatBuffer coordinates, IntBuffer types, int windingRule, boolean isfill, boolean shouldApplyOffset);
268
269 void drawfillShape(SunGraphics2D sg2d, Shape s, boolean isfill, boolean shouldApplyOffset) {
270 if (s == null) { throw new NullPointerException(); }
271
272 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
273 // TODO:
274 boolean sOptimizeShapes = true;
275 if (sOptimizeShapes && OSXSurfaceData.IsSimpleColor(sg2d.paint)) {
276 if (s instanceof Rectangle2D) {
277 Rectangle2D rectangle = (Rectangle2D) s;
278
279 float x = (float) rectangle.getX();
280 float y = (float) rectangle.getY();
281 float w = (float) rectangle.getWidth();
282 float h = (float) rectangle.getHeight();
283 if (isfill) {
284 fillRect(sg2d, x, y, w, h);
285 } else {
286 drawRect(sg2d, x, y, w, h);
287 }
288 } else if (s instanceof Ellipse2D) {
289 Ellipse2D ellipse = (Ellipse2D) s;
290
291 float x = (float) ellipse.getX();
292 float y = (float) ellipse.getY();
293 float w = (float) ellipse.getWidth();
294 float h = (float) ellipse.getHeight();
295
296 if (isfill) {
297 fillOval(sg2d, x, y, w, h);
298 } else {
299 drawOval(sg2d, x, y, w, h);
300 }
301 } else if (s instanceof Arc2D) {
302 Arc2D arc = (Arc2D) s;
303
304 float x = (float) arc.getX();
305 float y = (float) arc.getY();
306 float w = (float) arc.getWidth();
307 float h = (float) arc.getHeight();
308 float as = (float) arc.getAngleStart();
309 float ae = (float) arc.getAngleExtent();
310
311 if (isfill) {
312 fillArc(sg2d, x, y, w, h, as, ae, arc.getArcType());
313 } else {
314 drawArc(sg2d, x, y, w, h, as, ae, arc.getArcType());
315 }
316 } else if (s instanceof RoundRectangle2D) {
317 RoundRectangle2D roundrect = (RoundRectangle2D) s;
318
319 float x = (float) roundrect.getX();
320 float y = (float) roundrect.getY();
321 float w = (float) roundrect.getWidth();
322 float h = (float) roundrect.getHeight();
323 float aw = (float) roundrect.getArcWidth();
324 float ah = (float) roundrect.getArcHeight();
325
326 if (isfill) {
327 fillRoundRect(sg2d, x, y, w, h, aw, ah);
328 } else {
329 drawRoundRect(sg2d, x, y, w, h, aw, ah);
330 }
331 } else if (s instanceof Line2D) {
332 Line2D line = (Line2D) s;
333
334 float x1 = (float) line.getX1();
335 float y1 = (float) line.getY1();
336 float x2 = (float) line.getX2();
337 float y2 = (float) line.getY2();
338
339 drawLine(sg2d, x1, y1, x2, y2);
340 } else if (s instanceof Point2D) {
341 Point2D point = (Point2D) s;
342
343 float x = (float) point.getX();
344 float y = (float) point.getY();
345
346 drawLine(sg2d, x, y, x, y);
347 } else {
348 GeneralPath gp;
349
350 if (s instanceof GeneralPath) {
351 gp = (GeneralPath) s;
352 } else {
353 gp = new GeneralPath(s);
354 }
355
356 PathIterator pi = gp.getPathIterator(null);
357 if (pi.isDone() == false) {
358 surfaceData.drawfillShape(this, sg2d, gp, isfill, shouldApplyOffset);
359 }
360 }
361 } else {
362 GeneralPath gp;
363
364 if (s instanceof GeneralPath) {
365 gp = (GeneralPath) s;
366 } else {
367 gp = new GeneralPath(s);
368 }
369
370 PathIterator pi = gp.getPathIterator(null);
371 if (pi.isDone() == false) {
372 surfaceData.drawfillShape(this, sg2d, gp, isfill, shouldApplyOffset);
373 }
374 }
375 }
376
377 public void draw(SunGraphics2D sg2d, Shape s) {
378 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
379 if ((sg2d.strokeState != SunGraphics2D.STROKE_CUSTOM) && (OSXSurfaceData.IsSimpleColor(sg2d.paint))) {
380 drawfillShape(sg2d, s, false, true);
381 } else {
382 drawfillShape(sg2d, sg2d.stroke.createStrokedShape(s), true, true);
383 }
384 }
385
386 public void fill(SunGraphics2D sg2d, Shape s) {
387 drawfillShape(sg2d, s, true, false);
388 }
389
390 native void doImage(SurfaceData sData, SurfaceData img, boolean fliph, boolean flipv, int w, int h, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh);
391
392 // Copy img to scaled sg2d @ x,y with width height
393 public boolean scaleImage(SunGraphics2D sg2d, Image img, int x, int y, int width, int height, Color bgColor) {
394 OSXSurfaceData surfaceData = (OSXSurfaceData) sg2d.getSurfaceData();
395
396 int sx = 0;
397 int sy = 0;
398 int iw = img.getWidth(null);
399 int ih = img.getHeight(null);
400
401 return scaleImage(sg2d, img, x, y, x + width, y + height, sx, sy, sx + iw, sy + ih, bgColor);
402 }
403
404 // Copy img, clipped to sx1, sy1 by sx2, sy2 to dx1, dy2 by dx2, dy2
405 public boolean scaleImage(SunGraphics2D sg2d, Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgColor) {
406
407 // System.err.println("scaleImage");
408 // System.err.println(" sx1="+sx1+", sy1="+sy1+", sx2="+sx2+", sy2="+sy2);
409 // System.err.println(" dx1="+dx1+", dy1="+dy1+", dx2="+dx2+", dy2="+dy2);
410
411 int srcW, srcH, dstW, dstH;
412 int srcX, srcY, dstX, dstY;
413 boolean srcWidthFlip = false;
414 boolean srcHeightFlip = false;
415 boolean dstWidthFlip = false;
416 boolean dstHeightFlip = false;
417
418 if (sx2 > sx1) {
419 srcW = sx2 - sx1;
420 srcX = sx1;
421 } else {
422 srcWidthFlip = true;
423 srcW = sx1 - sx2;
424 srcX = sx2;
425 }
426 if (sy2 > sy1) {
427 srcH = sy2 - sy1;
428 srcY = sy1;
429 } else {
430 srcHeightFlip = true;
431 srcH = sy1 - sy2;
432 srcY = sy2;
433 }
434 if (dx2 > dx1) {
435 dstW = dx2 - dx1;
436 dstX = dx1;
437 } else {
438 dstW = dx1 - dx2;
439 dstWidthFlip = true;
440 dstX = dx2;
441 }
442 if (dy2 > dy1) {
443 dstH = dy2 - dy1;
444 dstY = dy1;
445 } else {
446 dstH = dy1 - dy2;
447 dstHeightFlip = true;
448 dstY = dy2;
449 }
450 if (srcW <= 0 || srcH <= 0) { return true; }
451
452 boolean flipv = (srcHeightFlip != dstHeightFlip);
453 boolean fliph = (srcWidthFlip != dstWidthFlip);
454
455 return blitImage(sg2d, img, fliph, flipv, srcX, srcY, srcW, srcH, dstX, dstY, dstW, dstH, bgColor);
456 }
457
458 protected boolean blitImage(SunGraphics2D sg2d, Image img, boolean fliph, boolean flipv, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh, Color bgColor) {
459 CPrinterSurfaceData surfaceData = (CPrinterSurfaceData)sg2d.getSurfaceData();
460 OSXOffScreenSurfaceData imgSurfaceData = (OSXOffScreenSurfaceData) OSXOffScreenSurfaceData.createNewSurface((BufferedImage)img);
461 surfaceData.blitImage(this, sg2d, imgSurfaceData, fliph, flipv, sx, sy, sw, sh, dx, dy, dw, dh, bgColor);
462 return true;
463 }
464
465 // Copy img to sg2d @ x, y
466 protected boolean copyImage(SunGraphics2D sg2d, Image img, int dx, int dy, Color bgColor) {
467 if (img == null) { return true; }
468
469 int sx = 0;
470 int sy = 0;
471 int width = img.getWidth(null);
472 int height = img.getHeight(null);
473
474 return blitImage(sg2d, img, false, false, sx, sy, width, height, dx, dy, width, height, bgColor);
475 }
476
477 // Copy img, clipped to sx, sy with width, height to sg2d @ dx, dy
478 protected boolean copyImage(SunGraphics2D sg2d, Image img, int dx, int dy, int sx, int sy, int width, int height, Color bgColor) {
479 return blitImage(sg2d, img, false, false, sx, sy, width, height, dx, dy, width, height, bgColor);
480 }
481
482 protected void transformImage(SunGraphics2D sg2d, Image img, int x, int y, BufferedImageOp op, AffineTransform xf, Color bgColor) {
483 if (img != null) {
484 int iw = img.getWidth(null);
485 int ih = img.getHeight(null);
486
487 if ((op != null) && (img instanceof BufferedImage)) {
488 if (((BufferedImage) img).getType() == BufferedImage.TYPE_CUSTOM) {
489 // BufferedImageOp can not handle custom images
490 BufferedImage dest = null;
491 dest = new BufferedImage(iw, ih, BufferedImage.TYPE_INT_ARGB_PRE);
492 Graphics g = dest.createGraphics();
493 g.drawImage(img, 0, 0, null);
494 g.dispose();
495 img = op.filter(dest, null);
496 } else {
497 // sun.awt.image.BufImgSurfaceData.createData((BufferedImage)img).finishLazyDrawing();
498 img = op.filter((BufferedImage) img, null);
499 }
500
501 iw = img.getWidth(null);
502 ih = img.getHeight(null);
503 }
504
505 if (xf != null) {
506 AffineTransform reset = sg2d.getTransform();
507 sg2d.transform(xf);
508 scaleImage(sg2d, img, x, y, x + iw, y + ih, 0, 0, iw, ih, bgColor);
509 sg2d.setTransform(reset);
510 } else {
511 scaleImage(sg2d, img, x, y, x + iw, y + ih, 0, 0, iw, ih, bgColor);
512 }
513 } else {
514 throw new NullPointerException();
515 }
516 }
517
518 // copied from DrawImage.java
519 protected boolean imageReady(sun.awt.image.ToolkitImage sunimg, ImageObserver observer) {
520 if (sunimg.hasError()) {
521 if (observer != null) {
522 observer.imageUpdate(sunimg, ImageObserver.ERROR | ImageObserver.ABORT, -1, -1, -1, -1);
523 }
524 return false;
525 }
526 return true;
527 }
528
529 // copied from DrawImage.java
530 public boolean copyImage(SunGraphics2D sg2d, Image img, int x, int y, Color bgColor, ImageObserver observer) {
531 if (img == null) { throw new NullPointerException(); }
532
533 if (!(img instanceof sun.awt.image.ToolkitImage)) { return copyImage(sg2d, img, x, y, bgColor); }
534
535 sun.awt.image.ToolkitImage sunimg = (sun.awt.image.ToolkitImage) img;
536 if (!imageReady(sunimg, observer)) { return false; }
537 ImageRepresentation ir = sunimg.getImageRep();
538 return ir.drawToBufImage(sg2d, sunimg, x, y, bgColor, observer);
539 }
540
541 // copied from DrawImage.java
542 public boolean copyImage(SunGraphics2D sg2d, Image img, int dx, int dy, int sx, int sy, int width, int height, Color bgColor, ImageObserver observer) {
543 if (img == null) { throw new NullPointerException(); }
544
545 if (!(img instanceof sun.awt.image.ToolkitImage)) { return copyImage(sg2d, img, dx, dy, sx, sy, width, height, bgColor); }
546
547 sun.awt.image.ToolkitImage sunimg = (sun.awt.image.ToolkitImage) img;
548 if (!imageReady(sunimg, observer)) { return false; }
549 ImageRepresentation ir = sunimg.getImageRep();
550 return ir.drawToBufImage(sg2d, sunimg, dx, dy, (dx + width), (dy + height), sx, sy, (sx + width), (sy + height), null, observer);
551 }
552
553 // copied from DrawImage.java
554 public boolean scaleImage(SunGraphics2D sg2d, Image img, int x, int y, int width, int height, Color bgColor, ImageObserver observer) {
555 if (img == null) { throw new NullPointerException(); }
556
557 if (!(img instanceof sun.awt.image.ToolkitImage)) { return scaleImage(sg2d, img, x, y, width, height, bgColor); }
558
559 sun.awt.image.ToolkitImage sunimg = (sun.awt.image.ToolkitImage) img;
560 if (!imageReady(sunimg, observer)) { return false; }
561 ImageRepresentation ir = sunimg.getImageRep();
562 return ir.drawToBufImage(sg2d, sunimg, x, y, width, height, bgColor, observer);
563 }
564
565 // copied from DrawImage.java
566 public boolean scaleImage(SunGraphics2D sg2d, Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgColor, ImageObserver observer) {
567 if (img == null) { throw new NullPointerException(); }
568
569 if (!(img instanceof sun.awt.image.ToolkitImage)) { return scaleImage(sg2d, img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgColor); }
570
571 sun.awt.image.ToolkitImage sunimg = (sun.awt.image.ToolkitImage) img;
572 if (!imageReady(sunimg, observer)) { return false; }
573 ImageRepresentation ir = sunimg.getImageRep();
574 return ir.drawToBufImage(sg2d, sunimg, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, bgColor, observer);
575 }
576
577 // copied from DrawImage.java
578 public boolean transformImage(SunGraphics2D sg2d, Image img, AffineTransform atfm, ImageObserver observer) {
579 if (img == null) { throw new NullPointerException(); }
580
581 if (!(img instanceof sun.awt.image.ToolkitImage)) {
582 transformImage(sg2d, img, 0, 0, null, atfm, null);
583 return true;
584 }
585
586 sun.awt.image.ToolkitImage sunimg = (sun.awt.image.ToolkitImage) img;
587 if (!imageReady(sunimg, observer)) { return false; }
588 ImageRepresentation ir = sunimg.getImageRep();
589 return ir.drawToBufImage(sg2d, sunimg, atfm, observer);
590 }
591
592 // copied from DrawImage.java
593 public void transformImage(SunGraphics2D sg2d, BufferedImage img, BufferedImageOp op, int x, int y) {
594 if (img != null) {
595 transformImage(sg2d, img, x, y, op, null, null);
596 } else {
597 throw new NullPointerException();
598 }
599 }
600
601 public CRenderer traceWrap() {
602 return new Tracer();
603 }
604
605 public static class Tracer extends CRenderer {
606 void doLine(SurfaceData sData, float x1, float y1, float x2, float y2) {
607 GraphicsPrimitive.tracePrimitive("QuartzLine");
608 super.doLine(sData, x1, y1, x2, y2);
609 }
610
611 void doRect(SurfaceData sData, float x, float y, float width, float height, boolean isfill) {
612 GraphicsPrimitive.tracePrimitive("QuartzRect");
613 super.doRect(sData, x, y, width, height, isfill);
614 }
615
616 void doRoundRect(SurfaceData sData, float x, float y, float width, float height, float arcW, float arcH, boolean isfill) {
617 GraphicsPrimitive.tracePrimitive("QuartzRoundRect");
618 super.doRoundRect(sData, x, y, width, height, arcW, arcH, isfill);
619 }
620
621 void doOval(SurfaceData sData, float x, float y, float width, float height, boolean isfill) {
622 GraphicsPrimitive.tracePrimitive("QuartzOval");
623 super.doOval(sData, x, y, width, height, isfill);
624 }
625
626 void doArc(SurfaceData sData, float x, float y, float width, float height, float angleStart, float angleExtent, int type, boolean isfill) {
627 GraphicsPrimitive.tracePrimitive("QuartzArc");
628 super.doArc(sData, x, y, width, height, angleStart, angleExtent, type, isfill);
629 }
630
631 void doPoly(SurfaceData sData, int[] xpoints, int[] ypoints, int npoints, boolean ispolygon, boolean isfill) {
632 GraphicsPrimitive.tracePrimitive("QuartzDoPoly");
633 super.doPoly(sData, xpoints, ypoints, npoints, ispolygon, isfill);
634 }
635
636 void doShape(SurfaceData sData, int length, FloatBuffer coordinates, IntBuffer types, int windingRule, boolean isfill, boolean shouldApplyOffset) {
637 GraphicsPrimitive.tracePrimitive("QuartzFillOrDrawShape");
638 super.doShape(sData, length, coordinates, types, windingRule, isfill, shouldApplyOffset);
639 }
640
641 void doImage(SurfaceData sData, SurfaceData img, boolean fliph, boolean flipv, int w, int h, int sx, int sy, int sw, int sh, int dx, int dy, int dw, int dh) {
642 GraphicsPrimitive.tracePrimitive("QuartzDrawImage");
643 super.doImage(sData, img, fliph, flipv, w, h, sx, sy, sw, sh, dx, dy, dw, dh);
644 }
645 }
646 }