1 /*
2 * Copyright (c) 1996, 2020, 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.Graphics;
29 import java.awt.Graphics2D;
30 import java.awt.RenderingHints;
31 import java.awt.RenderingHints.Key;
32 import java.awt.geom.Area;
33 import java.awt.geom.AffineTransform;
34 import java.awt.geom.NoninvertibleTransformException;
35 import java.awt.AlphaComposite;
36 import java.awt.BasicStroke;
37 import java.awt.image.BufferedImage;
38 import java.awt.image.BufferedImageOp;
39 import java.awt.image.RenderedImage;
40 import java.awt.image.renderable.RenderableImage;
41 import java.awt.image.renderable.RenderContext;
42 import java.awt.image.AffineTransformOp;
43 import java.awt.image.Raster;
44 import java.awt.image.WritableRaster;
45 import java.awt.Image;
46 import java.awt.Composite;
47 import java.awt.Color;
48 import java.awt.image.ColorModel;
49 import java.awt.GraphicsConfiguration;
50 import java.awt.Paint;
51 import java.awt.GradientPaint;
52 import java.awt.LinearGradientPaint;
53 import java.awt.RadialGradientPaint;
54 import java.awt.TexturePaint;
55 import java.awt.geom.Rectangle2D;
56 import java.awt.geom.PathIterator;
57 import java.awt.geom.GeneralPath;
58 import java.awt.Shape;
59 import java.awt.Stroke;
60 import java.awt.FontMetrics;
61 import java.awt.Rectangle;
62 import java.text.AttributedCharacterIterator;
63 import java.awt.Font;
64 import java.awt.image.ImageObserver;
65 import java.awt.Transparency;
66 import java.awt.font.GlyphVector;
67 import java.awt.font.TextLayout;
68
69 import sun.awt.image.SurfaceManager;
70 import sun.font.FontDesignMetrics;
71 import sun.font.FontUtilities;
72 import sun.java2d.pipe.PixelDrawPipe;
73 import sun.java2d.pipe.PixelFillPipe;
74 import sun.java2d.pipe.ShapeDrawPipe;
75 import sun.java2d.pipe.ValidatePipe;
76 import sun.java2d.pipe.ShapeSpanIterator;
77 import sun.java2d.pipe.Region;
78 import sun.java2d.pipe.TextPipe;
79 import sun.java2d.pipe.DrawImagePipe;
80 import sun.java2d.pipe.LoopPipe;
81 import sun.java2d.loops.FontInfo;
82 import sun.java2d.loops.RenderLoops;
83 import sun.java2d.loops.CompositeType;
84 import sun.java2d.loops.SurfaceType;
85 import sun.java2d.loops.Blit;
86 import sun.java2d.loops.MaskFill;
87 import java.awt.font.FontRenderContext;
88 import sun.java2d.loops.XORComposite;
89 import sun.awt.ConstrainableGraphics;
90 import sun.awt.SunHints;
91 import sun.awt.util.PerformanceLogger;
92 import java.util.Map;
93 import java.util.Iterator;
94
95 import java.lang.annotation.Native;
96 import java.awt.image.MultiResolutionImage;
97
98 import static java.awt.geom.AffineTransform.TYPE_FLIP;
99 import static java.awt.geom.AffineTransform.TYPE_MASK_SCALE;
100 import static java.awt.geom.AffineTransform.TYPE_TRANSLATION;
101 import java.awt.image.VolatileImage;
102 import sun.awt.image.MultiResolutionToolkitImage;
103 import sun.awt.image.ToolkitImage;
104
105 /**
106 * This is a the master Graphics2D superclass for all of the Sun
107 * Graphics implementations. This class relies on subclasses to
108 * manage the various device information, but provides an overall
109 * general framework for performing all of the requests in the
110 * Graphics and Graphics2D APIs.
111 *
112 * @author Jim Graham
113 */
114 public final class SunGraphics2D
115 extends Graphics2D
116 implements ConstrainableGraphics, Cloneable, DestSurfaceProvider
117 {
118 /*
119 * Attribute States
120 */
121 /* Paint */
122 @Native
123 public static final int PAINT_CUSTOM = 6; /* Any other Paint object */
124 @Native
125 public static final int PAINT_TEXTURE = 5; /* Tiled Image */
126 @Native
127 public static final int PAINT_RAD_GRADIENT = 4; /* Color RadialGradient */
128 @Native
129 public static final int PAINT_LIN_GRADIENT = 3; /* Color LinearGradient */
130 @Native
131 public static final int PAINT_GRADIENT = 2; /* Color Gradient */
132 @Native
133 public static final int PAINT_ALPHACOLOR = 1; /* Non-opaque Color */
134 @Native
135 public static final int PAINT_OPAQUECOLOR = 0; /* Opaque Color */
136
137 /* Composite*/
138 @Native
139 public static final int COMP_CUSTOM = 3;/* Custom Composite */
140 @Native
141 public static final int COMP_XOR = 2;/* XOR Mode Composite */
142 @Native
143 public static final int COMP_ALPHA = 1;/* AlphaComposite */
144 @Native
145 public static final int COMP_ISCOPY = 0;/* simple stores into destination,
146 * i.e. Src, SrcOverNoEa, and other
147 * alpha modes which replace
148 * the destination.
149 */
150
151 /* Stroke */
152 @Native
153 public static final int STROKE_CUSTOM = 3; /* custom Stroke */
154 @Native
155 public static final int STROKE_WIDE = 2; /* BasicStroke */
156 @Native
157 public static final int STROKE_THINDASHED = 1; /* BasicStroke */
158 @Native
159 public static final int STROKE_THIN = 0; /* BasicStroke */
160
161 /* Transform */
162 @Native
163 public static final int TRANSFORM_GENERIC = 4; /* any 3x2 */
164 @Native
165 public static final int TRANSFORM_TRANSLATESCALE = 3; /* scale XY */
166 @Native
167 public static final int TRANSFORM_ANY_TRANSLATE = 2; /* non-int translate */
168 @Native
169 public static final int TRANSFORM_INT_TRANSLATE = 1; /* int translate */
170 @Native
171 public static final int TRANSFORM_ISIDENT = 0; /* Identity */
172
173 /* Clipping */
174 @Native
175 public static final int CLIP_SHAPE = 2; /* arbitrary clip */
176 @Native
177 public static final int CLIP_RECTANGULAR = 1; /* rectangular clip */
178 @Native
179 public static final int CLIP_DEVICE = 0; /* no clipping set */
180
181 /* The following fields are used when the current Paint is a Color. */
182 public int eargb; // ARGB value with ExtraAlpha baked in
183 public int pixel; // pixel value for eargb
184
185 public SurfaceData surfaceData;
186
187 public PixelDrawPipe drawpipe;
188 public PixelFillPipe fillpipe;
189 public DrawImagePipe imagepipe;
190 public ShapeDrawPipe shapepipe;
191 public TextPipe textpipe;
192 public MaskFill alphafill;
193
194 public RenderLoops loops;
195
196 public CompositeType imageComp; /* Image Transparency checked on fly */
197
198 public int paintState;
199 public int compositeState;
200 public int strokeState;
201 public int transformState;
202 public int clipState;
203
204 public Color foregroundColor;
205 public Color backgroundColor;
206
207 public AffineTransform transform;
208 public int transX;
209 public int transY;
210
211 protected static final Stroke defaultStroke = new BasicStroke();
212 protected static final Composite defaultComposite = AlphaComposite.SrcOver;
213 private static final Font defaultFont =
214 new Font(Font.DIALOG, Font.PLAIN, 12);
215
216 public Paint paint;
217 public Stroke stroke;
218 public Composite composite;
219 protected Font font;
220 protected FontMetrics fontMetrics;
221
222 public int renderHint;
223 public int antialiasHint;
224 public int textAntialiasHint;
225 protected int fractionalMetricsHint;
226
227 /* A gamma adjustment to the colour used in lcd text blitting */
228 public int lcdTextContrast;
229 private static int lcdTextContrastDefaultValue = 140;
230
231 private int interpolationHint; // raw value of rendering Hint
232 public int strokeHint;
233
234 public int interpolationType; // algorithm choice based on
235 // interpolation and render Hints
236
237 public RenderingHints hints;
238
239 public Region constrainClip; // lightweight bounds in pixels
240 public int constrainX;
241 public int constrainY;
242
243 public Region clipRegion;
244 public Shape usrClip;
245 protected Region devClip; // Actual physical drawable in pixels
246
247 private int resolutionVariantHint;
248
249 // cached state for text rendering
250 private boolean validFontInfo;
251 private FontInfo fontInfo;
252 private FontInfo glyphVectorFontInfo;
253 private FontRenderContext glyphVectorFRC;
254
255 private static final int slowTextTransformMask =
256 AffineTransform.TYPE_GENERAL_TRANSFORM
257 | AffineTransform.TYPE_MASK_ROTATION
258 | AffineTransform.TYPE_FLIP;
259
260 static {
261 if (PerformanceLogger.loggingEnabled()) {
262 PerformanceLogger.setTime("SunGraphics2D static initialization");
263 }
264 }
265
266 public SunGraphics2D(SurfaceData sd, Color fg, Color bg, Font f) {
267 surfaceData = sd;
268 foregroundColor = fg;
269 backgroundColor = bg;
270 stroke = defaultStroke;
271 composite = defaultComposite;
272 paint = foregroundColor;
273
274 imageComp = CompositeType.SrcOverNoEa;
275
276 renderHint = SunHints.INTVAL_RENDER_DEFAULT;
277 antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
278 textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;
279 fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
280 lcdTextContrast = lcdTextContrastDefaultValue;
281 interpolationHint = -1;
282 strokeHint = SunHints.INTVAL_STROKE_DEFAULT;
283 resolutionVariantHint = SunHints.INTVAL_RESOLUTION_VARIANT_DEFAULT;
284
285 interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
286
287 transform = getDefaultTransform();
288 if (!transform.isIdentity()) {
289 invalidateTransform();
290 }
291
292 validateColor();
293
294 font = f;
295 if (font == null) {
296 font = defaultFont;
297 }
298
299 setDevClip(sd.getBounds());
300 invalidatePipe();
301 }
302
303 private AffineTransform getDefaultTransform() {
304 GraphicsConfiguration gc = getDeviceConfiguration();
305 return (gc == null) ? new AffineTransform() : gc.getDefaultTransform();
306 }
307
308 protected Object clone() {
309 try {
310 SunGraphics2D g = (SunGraphics2D) super.clone();
311 g.transform = new AffineTransform(this.transform);
312 if (hints != null) {
313 g.hints = (RenderingHints) this.hints.clone();
314 }
315 /* FontInfos are re-used, so must be cloned too, if they
316 * are valid, and be nulled out if invalid.
317 * The implied trade-off is that there is more to be gained
318 * from re-using these objects than is lost by having to
319 * clone them when the SG2D is cloned.
320 */
321 if (this.fontInfo != null) {
322 if (this.validFontInfo) {
323 g.fontInfo = (FontInfo)this.fontInfo.clone();
324 } else {
325 g.fontInfo = null;
326 }
327 }
328 if (this.glyphVectorFontInfo != null) {
329 g.glyphVectorFontInfo =
330 (FontInfo)this.glyphVectorFontInfo.clone();
331 g.glyphVectorFRC = this.glyphVectorFRC;
332 }
333 //g.invalidatePipe();
334 return g;
335 } catch (CloneNotSupportedException e) {
336 }
337 return null;
338 }
339
340 /**
341 * Create a new SunGraphics2D based on this one.
342 */
343 public Graphics create() {
344 return (Graphics) clone();
345 }
346
347 public void setDevClip(int x, int y, int w, int h) {
348 Region c = constrainClip;
349 if (c == null) {
350 devClip = Region.getInstanceXYWH(x, y, w, h);
351 } else {
352 devClip = c.getIntersectionXYWH(x, y, w, h);
353 }
354 validateCompClip();
355 }
356
357 public void setDevClip(Rectangle r) {
358 setDevClip(r.x, r.y, r.width, r.height);
359 }
360
361 /**
362 * Constrain rendering for lightweight objects.
363 */
364 public void constrain(int x, int y, int w, int h, Region region) {
365 if ((x | y) != 0) {
366 translate(x, y);
367 }
368 if (transformState > TRANSFORM_TRANSLATESCALE) {
369 clipRect(0, 0, w, h);
370 return;
371 }
372 // changes parameters according to the current scale and translate.
373 final double scaleX = transform.getScaleX();
374 final double scaleY = transform.getScaleY();
375 x = constrainX = (int) transform.getTranslateX();
376 y = constrainY = (int) transform.getTranslateY();
377 w = Region.dimAdd(x, Region.clipScale(w, scaleX));
378 h = Region.dimAdd(y, Region.clipScale(h, scaleY));
379
380 Region c = constrainClip;
381 if (c == null) {
382 c = Region.getInstanceXYXY(x, y, w, h);
383 } else {
384 c = c.getIntersectionXYXY(x, y, w, h);
385 }
386 if (region != null) {
387 region = region.getScaledRegion(scaleX, scaleY);
388 region = region.getTranslatedRegion(x, y);
389 c = c.getIntersection(region);
390 }
391
392 if (c == constrainClip) {
393 // Common case to ignore
394 return;
395 }
396
397 constrainClip = c;
398 if (!devClip.isInsideQuickCheck(c)) {
399 devClip = devClip.getIntersection(c);
400 validateCompClip();
401 }
402 }
403
404 /**
405 * Constrain rendering for lightweight objects.
406 *
407 * REMIND: This method will back off to the "workaround"
408 * of using translate and clipRect if the Graphics
409 * to be constrained has a complex transform. The
410 * drawback of the workaround is that the resulting
411 * clip and device origin cannot be "enforced".
412 *
413 * @exception IllegalStateException If the Graphics
414 * to be constrained has a complex transform.
415 */
416 @Override
417 public void constrain(int x, int y, int w, int h) {
418 constrain(x, y, w, h, null);
419 }
420
421 protected static ValidatePipe invalidpipe = new ValidatePipe();
422
423 /*
424 * Invalidate the pipeline
425 */
426 protected void invalidatePipe() {
427 drawpipe = invalidpipe;
428 fillpipe = invalidpipe;
429 shapepipe = invalidpipe;
430 textpipe = invalidpipe;
431 imagepipe = invalidpipe;
432 loops = null;
433 }
434
435 public void validatePipe() {
436 /* This workaround is for the situation when we update the Pipelines
437 * for invalid SurfaceData and run further code when the current
438 * pipeline doesn't support the type of new SurfaceData created during
439 * the current pipeline's work (in place of the invalid SurfaceData).
440 * Usually SurfaceData and Pipelines are repaired (through revalidateAll)
441 * and called again in the exception handlers */
442
443 if (!surfaceData.isValid()) {
444 throw new InvalidPipeException("attempt to validate Pipe with invalid SurfaceData");
445 }
446
447 surfaceData.validatePipe(this);
448 }
449
450 /*
451 * Intersect two Shapes by the simplest method, attempting to produce
452 * a simplified result.
453 * The boolean arguments keep1 and keep2 specify whether or not
454 * the first or second shapes can be modified during the operation
455 * or whether that shape must be "kept" unmodified.
456 */
457 Shape intersectShapes(Shape s1, Shape s2, boolean keep1, boolean keep2) {
458 if (s1 instanceof Rectangle && s2 instanceof Rectangle) {
459 return ((Rectangle) s1).intersection((Rectangle) s2);
460 }
461 if (s1 instanceof Rectangle2D) {
462 return intersectRectShape((Rectangle2D) s1, s2, keep1, keep2);
463 } else if (s2 instanceof Rectangle2D) {
464 return intersectRectShape((Rectangle2D) s2, s1, keep2, keep1);
465 }
466 return intersectByArea(s1, s2, keep1, keep2);
467 }
468
469 /*
470 * Intersect a Rectangle with a Shape by the simplest method,
471 * attempting to produce a simplified result.
472 * The boolean arguments keep1 and keep2 specify whether or not
473 * the first or second shapes can be modified during the operation
474 * or whether that shape must be "kept" unmodified.
475 */
476 Shape intersectRectShape(Rectangle2D r, Shape s,
477 boolean keep1, boolean keep2) {
478 if (s instanceof Rectangle2D) {
479 Rectangle2D r2 = (Rectangle2D) s;
480 Rectangle2D outrect;
481 if (!keep1) {
482 outrect = r;
483 } else if (!keep2) {
484 outrect = r2;
485 } else {
486 outrect = new Rectangle2D.Float();
487 }
488 double x1 = Math.max(r.getX(), r2.getX());
489 double x2 = Math.min(r.getX() + r.getWidth(),
490 r2.getX() + r2.getWidth());
491 double y1 = Math.max(r.getY(), r2.getY());
492 double y2 = Math.min(r.getY() + r.getHeight(),
493 r2.getY() + r2.getHeight());
494
495 if (((x2 - x1) < 0) || ((y2 - y1) < 0))
496 // Width or height is negative. No intersection.
497 outrect.setFrameFromDiagonal(0, 0, 0, 0);
498 else
499 outrect.setFrameFromDiagonal(x1, y1, x2, y2);
500 return outrect;
501 }
502 if (r.contains(s.getBounds2D())) {
503 if (keep2) {
504 s = cloneShape(s);
505 }
506 return s;
507 }
508 return intersectByArea(r, s, keep1, keep2);
509 }
510
511 protected static Shape cloneShape(Shape s) {
512 return new GeneralPath(s);
513 }
514
515 /*
516 * Intersect two Shapes using the Area class. Presumably other
517 * attempts at simpler intersection methods proved fruitless.
518 * The boolean arguments keep1 and keep2 specify whether or not
519 * the first or second shapes can be modified during the operation
520 * or whether that shape must be "kept" unmodified.
521 * @see #intersectShapes
522 * @see #intersectRectShape
523 */
524 Shape intersectByArea(Shape s1, Shape s2, boolean keep1, boolean keep2) {
525 Area a1, a2;
526
527 // First see if we can find an overwriteable source shape
528 // to use as our destination area to avoid duplication.
529 if (!keep1 && (s1 instanceof Area)) {
530 a1 = (Area) s1;
531 } else if (!keep2 && (s2 instanceof Area)) {
532 a1 = (Area) s2;
533 s2 = s1;
534 } else {
535 a1 = new Area(s1);
536 }
537
538 if (s2 instanceof Area) {
539 a2 = (Area) s2;
540 } else {
541 a2 = new Area(s2);
542 }
543
544 a1.intersect(a2);
545 if (a1.isRectangular()) {
546 return a1.getBounds();
547 }
548
549 return a1;
550 }
551
552 /*
553 * Intersect usrClip bounds and device bounds to determine the composite
554 * rendering boundaries.
555 */
556 public Region getCompClip() {
557 if (!surfaceData.isValid()) {
558 // revalidateAll() implicitly recalculcates the composite clip
559 revalidateAll();
560 }
561
562 return clipRegion;
563 }
564
565 public Font getFont() {
566 if (font == null) {
567 font = defaultFont;
568 }
569 return font;
570 }
571
572 private static final double[] IDENT_MATRIX = {1, 0, 0, 1};
573 private static final AffineTransform IDENT_ATX =
574 new AffineTransform();
575
576 private static final int MINALLOCATED = 8;
577 private static final int TEXTARRSIZE = 17;
578 private static double[][] textTxArr = new double[TEXTARRSIZE][];
579 private static AffineTransform[] textAtArr =
580 new AffineTransform[TEXTARRSIZE];
581
582 static {
583 for (int i=MINALLOCATED;i<TEXTARRSIZE;i++) {
584 textTxArr[i] = new double [] {i, 0, 0, i};
585 textAtArr[i] = new AffineTransform( textTxArr[i]);
586 }
587 }
588
589 // cached state for various draw[String,Char,Byte] optimizations
590 public FontInfo checkFontInfo(FontInfo info, Font font,
591 FontRenderContext frc) {
592 /* Do not create a FontInfo object as part of construction of an
593 * SG2D as its possible it may never be needed - ie if no text
594 * is drawn using this SG2D.
595 */
596 if (info == null) {
597 info = new FontInfo();
598 }
599
600 float ptSize = font.getSize2D();
601 int txFontType;
602 AffineTransform devAt, textAt=null;
603 if (font.isTransformed()) {
604 textAt = font.getTransform();
605 textAt.scale(ptSize, ptSize);
606 txFontType = textAt.getType();
607 info.originX = (float)textAt.getTranslateX();
608 info.originY = (float)textAt.getTranslateY();
609 textAt.translate(-info.originX, -info.originY);
610 if (transformState >= TRANSFORM_TRANSLATESCALE) {
611 transform.getMatrix(info.devTx = new double[4]);
612 devAt = new AffineTransform(info.devTx);
613 textAt.preConcatenate(devAt);
614 } else {
615 info.devTx = IDENT_MATRIX;
616 devAt = IDENT_ATX;
617 }
618 textAt.getMatrix(info.glyphTx = new double[4]);
619 double shearx = textAt.getShearX();
620 double scaley = textAt.getScaleY();
621 if (shearx != 0) {
622 scaley = Math.sqrt(shearx * shearx + scaley * scaley);
623 }
624 info.pixelHeight = (int)(Math.abs(scaley)+0.5);
625 } else {
626 txFontType = AffineTransform.TYPE_IDENTITY;
627 info.originX = info.originY = 0;
628 if (transformState >= TRANSFORM_TRANSLATESCALE) {
629 transform.getMatrix(info.devTx = new double[4]);
630 devAt = new AffineTransform(info.devTx);
631 info.glyphTx = new double[4];
632 for (int i = 0; i < 4; i++) {
633 info.glyphTx[i] = info.devTx[i] * ptSize;
634 }
635 textAt = new AffineTransform(info.glyphTx);
636 double shearx = transform.getShearX();
637 double scaley = transform.getScaleY();
638 if (shearx != 0) {
639 scaley = Math.sqrt(shearx * shearx + scaley * scaley);
640 }
641 info.pixelHeight = (int)(Math.abs(scaley * ptSize)+0.5);
642 } else {
643 /* If the double represents a common integral, we
644 * may have pre-allocated objects.
645 * A "sparse" array be seems to be as fast as a switch
646 * even for 3 or 4 pt sizes, and is more flexible.
647 * This should perform comparably in single-threaded
648 * rendering to the old code which synchronized on the
649 * class and scale better on MP systems.
650 */
651 int pszInt = (int)ptSize;
652 if (ptSize == pszInt &&
653 pszInt >= MINALLOCATED && pszInt < TEXTARRSIZE) {
654 info.glyphTx = textTxArr[pszInt];
655 textAt = textAtArr[pszInt];
656 info.pixelHeight = pszInt;
657 } else {
658 info.pixelHeight = (int)(ptSize+0.5);
659 }
660 if (textAt == null) {
661 info.glyphTx = new double[] {ptSize, 0, 0, ptSize};
662 textAt = new AffineTransform(info.glyphTx);
663 }
664
665 info.devTx = IDENT_MATRIX;
666 devAt = IDENT_ATX;
667 }
668 }
669
670 info.nonInvertibleTx =
671 (Math.abs(textAt.getDeterminant()) <= Double.MIN_VALUE);
672
673 info.font2D = FontUtilities.getFont2D(font);
674
675 int fmhint = fractionalMetricsHint;
676 if (fmhint == SunHints.INTVAL_FRACTIONALMETRICS_DEFAULT) {
677 fmhint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
678 }
679 info.lcdSubPixPos = false; // conditionally set true in LCD mode.
680
681 /* The text anti-aliasing hints that are set by the client need
682 * to be interpreted for the current state and stored in the
683 * FontInfo.aahint which is what will actually be used and
684 * will be one of OFF, ON, LCD_HRGB or LCD_VRGB.
685 * This is what pipe selection code should typically refer to, not
686 * textAntialiasHint. This means we are now evaluating the meaning
687 * of "default" here. Any pipe that really cares about that will
688 * also need to consult that variable.
689 * Otherwise these are being used only as args to getStrike,
690 * and are encapsulated in that object which is part of the
691 * FontInfo, so we do not need to store them directly as fields
692 * in the FontInfo object.
693 * That could change if FontInfo's were more selectively
694 * revalidated when graphics state changed. Presently this
695 * method re-evaluates all fields in the fontInfo.
696 * The strike doesn't need to know the RGB subpixel order. Just
697 * if its H or V orientation, so if an LCD option is specified we
698 * always pass in the RGB hint to the strike.
699 * frc is non-null only if this is a GlyphVector. For reasons
700 * which are probably a historical mistake the AA hint in a GV
701 * is honoured when we render, overriding the Graphics setting.
702 */
703 int aahint;
704 if (frc == null) {
705 aahint = textAntialiasHint;
706 } else {
707 aahint = ((SunHints.Value)frc.getAntiAliasingHint()).getIndex();
708 }
709 if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT) {
710 if (antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
711 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
712 } else {
713 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_OFF;
714 }
715 } else {
716 /* If we are in checkFontInfo because a rendering hint has been
717 * set then all pipes are revalidated. But we can also
718 * be here because setFont() has been called when the 'gasp'
719 * hint is set, as then the font size determines the text pipe.
720 * See comments in SunGraphics2d.setFont(Font).
721 */
722 if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_GASP) {
723 if (info.font2D.useAAForPtSize(info.pixelHeight)) {
724 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
725 } else {
726 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_OFF;
727 }
728 } else if (aahint >= SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB) {
729 /* loops for default rendering modes are installed in the SG2D
730 * constructor. If there are none this will be null.
731 * Not all compositing modes update the render loops, so
732 * we also test that this is a mode we know should support
733 * this. One minor issue is that the loops aren't necessarily
734 * installed for a new rendering mode until after this
735 * method is called during pipeline validation. So it is
736 * theoretically possible that it was set to null for a
737 * compositing mode, the composite is then set back to Src,
738 * but the loop is still null when this is called and AA=ON
739 * is installed instead of an LCD mode.
740 * However this is done in the right order in SurfaceData.java
741 * so this is not likely to be a problem - but not
742 * guaranteed.
743 */
744 if (
745 !surfaceData.canRenderLCDText(this)
746 // loops.drawGlyphListLCDLoop == null ||
747 // compositeState > COMP_ISCOPY ||
748 // paintState > PAINT_ALPHACOLOR
749 ) {
750 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
751 } else {
752 info.lcdRGBOrder = true;
753 /* Collapse these into just HRGB or VRGB.
754 * Pipe selection code needs only to test for these two.
755 * Since these both select the same pipe anyway its
756 * tempting to collapse into one value. But they are
757 * different strikes (glyph caches) so the distinction
758 * needs to be made for that purpose.
759 */
760 if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HBGR) {
761 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB;
762 info.lcdRGBOrder = false;
763 } else if
764 (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VBGR) {
765 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_LCD_VRGB;
766 info.lcdRGBOrder = false;
767 }
768 /* Support subpixel positioning only for the case in
769 * which the horizontal resolution is increased
770 */
771 info.lcdSubPixPos =
772 fmhint == SunHints.INTVAL_FRACTIONALMETRICS_ON &&
773 aahint == SunHints.INTVAL_TEXT_ANTIALIAS_LCD_HRGB;
774 }
775 }
776 }
777 if (FontUtilities.isMacOSX14 &&
778 (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_OFF))
779 {
780 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
781 }
782 info.aaHint = aahint;
783 info.fontStrike = info.font2D.getStrike(font, devAt, textAt,
784 aahint, fmhint);
785 return info;
786 }
787
788 public static boolean isRotated(double [] mtx) {
789 if ((mtx[0] == mtx[3]) &&
790 (mtx[1] == 0.0) &&
791 (mtx[2] == 0.0) &&
792 (mtx[0] > 0.0))
793 {
794 return false;
795 }
796
797 return true;
798 }
799
800 public void setFont(Font font) {
801 /* replacing the reference equality test font != this.font with
802 * !font.equals(this.font) did not yield any measurable difference
803 * in testing, but there may be yet to be identified cases where it
804 * is beneficial.
805 */
806 if (font != null && font!=this.font/*!font.equals(this.font)*/) {
807 /* In the GASP AA case the textpipe depends on the glyph size
808 * as determined by graphics and font transforms as well as the
809 * font size, and information in the font. But we may invalidate
810 * the pipe only to find that it made no difference.
811 * Deferring pipe invalidation to checkFontInfo won't work because
812 * when called we may already be rendering to the wrong pipe.
813 * So, if the font is transformed, or the graphics has more than
814 * a simple scale, we'll take that as enough of a hint to
815 * revalidate everything. But if they aren't we will
816 * use the font's point size to query the gasp table and see if
817 * what it says matches what's currently being used, in which
818 * case there's no need to invalidate the textpipe.
819 * This should be sufficient for all typical uses cases.
820 */
821 if (textAntialiasHint == SunHints.INTVAL_TEXT_ANTIALIAS_GASP &&
822 textpipe != invalidpipe &&
823 (transformState > TRANSFORM_ANY_TRANSLATE ||
824 font.isTransformed() ||
825 fontInfo == null || // Precaution, if true shouldn't get here
826 (fontInfo.aaHint == SunHints.INTVAL_TEXT_ANTIALIAS_ON) !=
827 FontUtilities.getFont2D(font).
828 useAAForPtSize(font.getSize()))) {
829 textpipe = invalidpipe;
830 }
831 this.font = font;
832 this.fontMetrics = null;
833 this.validFontInfo = false;
834 }
835 }
836
837 public FontInfo getFontInfo() {
838 if (!validFontInfo) {
839 this.fontInfo = checkFontInfo(this.fontInfo, font, null);
840 validFontInfo = true;
841 }
842 return this.fontInfo;
843 }
844
845 /* Used by drawGlyphVector which specifies its own font. */
846 public FontInfo getGVFontInfo(Font font, FontRenderContext frc) {
847 if (glyphVectorFontInfo != null &&
848 glyphVectorFontInfo.font == font &&
849 glyphVectorFRC == frc) {
850 return glyphVectorFontInfo;
851 } else {
852 glyphVectorFRC = frc;
853 return glyphVectorFontInfo =
854 checkFontInfo(glyphVectorFontInfo, font, frc);
855 }
856 }
857
858 public FontMetrics getFontMetrics() {
859 if (this.fontMetrics != null) {
860 return this.fontMetrics;
861 }
862 /* NB the constructor and the setter disallow "font" being null */
863 return this.fontMetrics =
864 FontDesignMetrics.getMetrics(font, getFontRenderContext());
865 }
866
867 public FontMetrics getFontMetrics(Font font) {
868 if ((this.fontMetrics != null) && (font == this.font)) {
869 return this.fontMetrics;
870 }
871 FontMetrics fm =
872 FontDesignMetrics.getMetrics(font, getFontRenderContext());
873
874 if (this.font == font) {
875 this.fontMetrics = fm;
876 }
877 return fm;
878 }
879
880 /**
881 * Checks to see if a Path intersects the specified Rectangle in device
882 * space. The rendering attributes taken into account include the
883 * clip, transform, and stroke attributes.
884 * @param rect The area in device space to check for a hit.
885 * @param s The path to check for a hit.
886 * @param onStroke Flag to choose between testing the stroked or
887 * the filled path.
888 * @return True if there is a hit, false otherwise.
889 * @see #setStroke
890 * @see #fill(Shape)
891 * @see #draw(Shape)
892 * @see #transform
893 * @see #setTransform
894 * @see #clip
895 * @see #setClip
896 */
897 public boolean hit(Rectangle rect, Shape s, boolean onStroke) {
898 if (onStroke) {
899 s = stroke.createStrokedShape(s);
900 }
901
902 s = transformShape(s);
903 if ((constrainX|constrainY) != 0) {
904 rect = new Rectangle(rect);
905 rect.translate(constrainX, constrainY);
906 }
907
908 return s.intersects(rect);
909 }
910
911 /**
912 * Return the ColorModel associated with this Graphics2D.
913 */
914 public ColorModel getDeviceColorModel() {
915 return surfaceData.getColorModel();
916 }
917
918 /**
919 * Return the device configuration associated with this Graphics2D.
920 */
921 public GraphicsConfiguration getDeviceConfiguration() {
922 return surfaceData.getDeviceConfiguration();
923 }
924
925 /**
926 * Return the SurfaceData object assigned to manage the destination
927 * drawable surface of this Graphics2D.
928 */
929 public SurfaceData getSurfaceData() {
930 return surfaceData;
931 }
932
933 /**
934 * Sets the Composite in the current graphics state. Composite is used
935 * in all drawing methods such as drawImage, drawString, drawPath,
936 * and fillPath. It specifies how new pixels are to be combined with
937 * the existing pixels on the graphics device in the rendering process.
938 * @param comp The Composite object to be used for drawing.
939 * @see java.awt.Graphics#setXORMode
940 * @see java.awt.Graphics#setPaintMode
941 * @see AlphaComposite
942 */
943 public void setComposite(Composite comp) {
944 if (composite == comp) {
945 return;
946 }
947 int newCompState;
948 CompositeType newCompType;
949 if (comp instanceof AlphaComposite) {
950 AlphaComposite alphacomp = (AlphaComposite) comp;
951 newCompType = CompositeType.forAlphaComposite(alphacomp);
952 if (newCompType == CompositeType.SrcOverNoEa) {
953 if (paintState == PAINT_OPAQUECOLOR ||
954 (paintState > PAINT_ALPHACOLOR &&
955 paint.getTransparency() == Transparency.OPAQUE))
956 {
957 newCompState = COMP_ISCOPY;
958 } else {
959 newCompState = COMP_ALPHA;
960 }
961 } else if (newCompType == CompositeType.SrcNoEa ||
962 newCompType == CompositeType.Src ||
963 newCompType == CompositeType.Clear)
964 {
965 newCompState = COMP_ISCOPY;
966 } else if (surfaceData.getTransparency() == Transparency.OPAQUE &&
967 newCompType == CompositeType.SrcIn)
968 {
969 newCompState = COMP_ISCOPY;
970 } else {
971 newCompState = COMP_ALPHA;
972 }
973 } else if (comp instanceof XORComposite) {
974 newCompState = COMP_XOR;
975 newCompType = CompositeType.Xor;
976 } else if (comp == null) {
977 throw new IllegalArgumentException("null Composite");
978 } else {
979 surfaceData.checkCustomComposite();
980 newCompState = COMP_CUSTOM;
981 newCompType = CompositeType.General;
982 }
983 if (compositeState != newCompState ||
984 imageComp != newCompType)
985 {
986 compositeState = newCompState;
987 imageComp = newCompType;
988 invalidatePipe();
989 validFontInfo = false;
990 }
991 composite = comp;
992 if (paintState <= PAINT_ALPHACOLOR) {
993 validateColor();
994 }
995 }
996
997 /**
998 * Sets the Paint in the current graphics state.
999 * @param paint The Paint object to be used to generate color in
1000 * the rendering process.
1001 * @see java.awt.Graphics#setColor
1002 * @see GradientPaint
1003 * @see TexturePaint
1004 */
1005 public void setPaint(Paint paint) {
1006 if (paint instanceof Color) {
1007 setColor((Color) paint);
1008 return;
1009 }
1010 if (paint == null || this.paint == paint) {
1011 return;
1012 }
1013 this.paint = paint;
1014 if (imageComp == CompositeType.SrcOverNoEa) {
1015 // special case where compState depends on opacity of paint
1016 if (paint.getTransparency() == Transparency.OPAQUE) {
1017 if (compositeState != COMP_ISCOPY) {
1018 compositeState = COMP_ISCOPY;
1019 }
1020 } else {
1021 if (compositeState == COMP_ISCOPY) {
1022 compositeState = COMP_ALPHA;
1023 }
1024 }
1025 }
1026 Class<? extends Paint> paintClass = paint.getClass();
1027 if (paintClass == GradientPaint.class) {
1028 paintState = PAINT_GRADIENT;
1029 } else if (paintClass == LinearGradientPaint.class) {
1030 paintState = PAINT_LIN_GRADIENT;
1031 } else if (paintClass == RadialGradientPaint.class) {
1032 paintState = PAINT_RAD_GRADIENT;
1033 } else if (paintClass == TexturePaint.class) {
1034 paintState = PAINT_TEXTURE;
1035 } else {
1036 paintState = PAINT_CUSTOM;
1037 }
1038 validFontInfo = false;
1039 invalidatePipe();
1040 }
1041
1042 static final int NON_UNIFORM_SCALE_MASK =
1043 (AffineTransform.TYPE_GENERAL_TRANSFORM |
1044 AffineTransform.TYPE_GENERAL_SCALE);
1045 public static final double MinPenSizeAA =
1046 sun.java2d.pipe.RenderingEngine.getInstance().getMinimumAAPenSize();
1047 public static final double MinPenSizeAASquared =
1048 (MinPenSizeAA * MinPenSizeAA);
1049 // Since inaccuracies in the trig package can cause us to
1050 // calculated a rotated pen width of just slightly greater
1051 // than 1.0, we add a fudge factor to our comparison value
1052 // here so that we do not misclassify single width lines as
1053 // wide lines under certain rotations.
1054 public static final double MinPenSizeSquared = 1.000000001;
1055
1056 private void validateBasicStroke(BasicStroke bs) {
1057 boolean aa = (antialiasHint == SunHints.INTVAL_ANTIALIAS_ON);
1058 if (transformState < TRANSFORM_TRANSLATESCALE) {
1059 if (aa) {
1060 if (bs.getLineWidth() <= MinPenSizeAA) {
1061 if (bs.getDashArray() == null) {
1062 strokeState = STROKE_THIN;
1063 } else {
1064 strokeState = STROKE_THINDASHED;
1065 }
1066 } else {
1067 strokeState = STROKE_WIDE;
1068 }
1069 } else {
1070 if (bs == defaultStroke) {
1071 strokeState = STROKE_THIN;
1072 } else if (bs.getLineWidth() <= 1.0f) {
1073 if (bs.getDashArray() == null) {
1074 strokeState = STROKE_THIN;
1075 } else {
1076 strokeState = STROKE_THINDASHED;
1077 }
1078 } else {
1079 strokeState = STROKE_WIDE;
1080 }
1081 }
1082 } else {
1083 double widthsquared;
1084 if ((transform.getType() & NON_UNIFORM_SCALE_MASK) == 0) {
1085 /* sqrt omitted, compare to squared limits below. */
1086 widthsquared = Math.abs(transform.getDeterminant());
1087 } else {
1088 /* First calculate the "maximum scale" of this transform. */
1089 double A = transform.getScaleX(); // m00
1090 double C = transform.getShearX(); // m01
1091 double B = transform.getShearY(); // m10
1092 double D = transform.getScaleY(); // m11
1093
1094 /*
1095 * Given a 2 x 2 affine matrix [ A B ] such that
1096 * [ C D ]
1097 * v' = [x' y'] = [Ax + Cy, Bx + Dy], we want to
1098 * find the maximum magnitude (norm) of the vector v'
1099 * with the constraint (x^2 + y^2 = 1).
1100 * The equation to maximize is
1101 * |v'| = sqrt((Ax+Cy)^2+(Bx+Dy)^2)
1102 * or |v'| = sqrt((AA+BB)x^2 + 2(AC+BD)xy + (CC+DD)y^2).
1103 * Since sqrt is monotonic we can maximize |v'|^2
1104 * instead and plug in the substitution y = sqrt(1 - x^2).
1105 * Trigonometric equalities can then be used to get
1106 * rid of most of the sqrt terms.
1107 */
1108 double EA = A*A + B*B; // x^2 coefficient
1109 double EB = 2*(A*C + B*D); // xy coefficient
1110 double EC = C*C + D*D; // y^2 coefficient
1111
1112 /*
1113 * There is a lot of calculus omitted here.
1114 *
1115 * Conceptually, in the interests of understanding the
1116 * terms that the calculus produced we can consider
1117 * that EA and EC end up providing the lengths along
1118 * the major axes and the hypot term ends up being an
1119 * adjustment for the additional length along the off-axis
1120 * angle of rotated or sheared ellipses as well as an
1121 * adjustment for the fact that the equation below
1122 * averages the two major axis lengths. (Notice that
1123 * the hypot term contains a part which resolves to the
1124 * difference of these two axis lengths in the absence
1125 * of rotation.)
1126 *
1127 * In the calculus, the ratio of the EB and (EA-EC) terms
1128 * ends up being the tangent of 2*theta where theta is
1129 * the angle that the long axis of the ellipse makes
1130 * with the horizontal axis. Thus, this equation is
1131 * calculating the length of the hypotenuse of a triangle
1132 * along that axis.
1133 */
1134 double hypot = Math.sqrt(EB*EB + (EA-EC)*(EA-EC));
1135
1136 /* sqrt omitted, compare to squared limits below. */
1137 widthsquared = ((EA + EC + hypot)/2.0);
1138 }
1139 if (bs != defaultStroke) {
1140 widthsquared *= bs.getLineWidth() * bs.getLineWidth();
1141 }
1142 if (widthsquared <=
1143 (aa ? MinPenSizeAASquared : MinPenSizeSquared))
1144 {
1145 if (bs.getDashArray() == null) {
1146 strokeState = STROKE_THIN;
1147 } else {
1148 strokeState = STROKE_THINDASHED;
1149 }
1150 } else {
1151 strokeState = STROKE_WIDE;
1152 }
1153 }
1154 }
1155
1156 /*
1157 * Sets the Stroke in the current graphics state.
1158 * @param s The Stroke object to be used to stroke a Path in
1159 * the rendering process.
1160 * @see BasicStroke
1161 */
1162 public void setStroke(Stroke s) {
1163 if (s == null) {
1164 throw new IllegalArgumentException("null Stroke");
1165 }
1166 int saveStrokeState = strokeState;
1167 stroke = s;
1168 if (s instanceof BasicStroke) {
1169 validateBasicStroke((BasicStroke) s);
1170 } else {
1171 strokeState = STROKE_CUSTOM;
1172 }
1173 if (strokeState != saveStrokeState) {
1174 invalidatePipe();
1175 }
1176 }
1177
1178 /**
1179 * Sets the preferences for the rendering algorithms.
1180 * Hint categories include controls for rendering quality and
1181 * overall time/quality trade-off in the rendering process.
1182 * @param hintKey The key of hint to be set. The strings are
1183 * defined in the RenderingHints class.
1184 * @param hintValue The value indicating preferences for the specified
1185 * hint category. These strings are defined in the RenderingHints
1186 * class.
1187 * @see RenderingHints
1188 */
1189 public void setRenderingHint(Key hintKey, Object hintValue) {
1190 // If we recognize the key, we must recognize the value
1191 // otherwise throw an IllegalArgumentException
1192 // and do not change the Hints object
1193 // If we do not recognize the key, just pass it through
1194 // to the Hints object untouched
1195 if (!hintKey.isCompatibleValue(hintValue)) {
1196 throw new IllegalArgumentException
1197 (hintValue+" is not compatible with "+hintKey);
1198 }
1199 if (hintKey instanceof SunHints.Key) {
1200 boolean stateChanged;
1201 boolean textStateChanged = false;
1202 boolean recognized = true;
1203 SunHints.Key sunKey = (SunHints.Key) hintKey;
1204 int newHint;
1205 if (sunKey == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST) {
1206 newHint = ((Integer)hintValue).intValue();
1207 } else {
1208 newHint = ((SunHints.Value) hintValue).getIndex();
1209 }
1210 switch (sunKey.getIndex()) {
1211 case SunHints.INTKEY_RENDERING:
1212 stateChanged = (renderHint != newHint);
1213 if (stateChanged) {
1214 renderHint = newHint;
1215 if (interpolationHint == -1) {
1216 interpolationType =
1217 (newHint == SunHints.INTVAL_RENDER_QUALITY
1218 ? AffineTransformOp.TYPE_BILINEAR
1219 : AffineTransformOp.TYPE_NEAREST_NEIGHBOR);
1220 }
1221 }
1222 break;
1223 case SunHints.INTKEY_ANTIALIASING:
1224 stateChanged = (antialiasHint != newHint);
1225 antialiasHint = newHint;
1226 if (stateChanged) {
1227 textStateChanged =
1228 (textAntialiasHint ==
1229 SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT);
1230 if (strokeState != STROKE_CUSTOM) {
1231 validateBasicStroke((BasicStroke) stroke);
1232 }
1233 }
1234 break;
1235 case SunHints.INTKEY_TEXT_ANTIALIASING:
1236 stateChanged = (textAntialiasHint != newHint);
1237 textStateChanged = stateChanged;
1238 textAntialiasHint = newHint;
1239 break;
1240 case SunHints.INTKEY_FRACTIONALMETRICS:
1241 stateChanged = (fractionalMetricsHint != newHint);
1242 textStateChanged = stateChanged;
1243 fractionalMetricsHint = newHint;
1244 break;
1245 case SunHints.INTKEY_AATEXT_LCD_CONTRAST:
1246 stateChanged = false;
1247 /* Already have validated it is an int 100 <= newHint <= 250 */
1248 lcdTextContrast = newHint;
1249 break;
1250 case SunHints.INTKEY_INTERPOLATION:
1251 interpolationHint = newHint;
1252 switch (newHint) {
1253 case SunHints.INTVAL_INTERPOLATION_BICUBIC:
1254 newHint = AffineTransformOp.TYPE_BICUBIC;
1255 break;
1256 case SunHints.INTVAL_INTERPOLATION_BILINEAR:
1257 newHint = AffineTransformOp.TYPE_BILINEAR;
1258 break;
1259 default:
1260 case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
1261 newHint = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
1262 break;
1263 }
1264 stateChanged = (interpolationType != newHint);
1265 interpolationType = newHint;
1266 break;
1267 case SunHints.INTKEY_STROKE_CONTROL:
1268 stateChanged = (strokeHint != newHint);
1269 strokeHint = newHint;
1270 break;
1271 case SunHints.INTKEY_RESOLUTION_VARIANT:
1272 stateChanged = (resolutionVariantHint != newHint);
1273 resolutionVariantHint = newHint;
1274 break;
1275 default:
1276 recognized = false;
1277 stateChanged = false;
1278 break;
1279 }
1280 if (recognized) {
1281 if (stateChanged) {
1282 invalidatePipe();
1283 if (textStateChanged) {
1284 fontMetrics = null;
1285 this.cachedFRC = null;
1286 validFontInfo = false;
1287 this.glyphVectorFontInfo = null;
1288 }
1289 }
1290 if (hints != null) {
1291 hints.put(hintKey, hintValue);
1292 }
1293 return;
1294 }
1295 }
1296 // Nothing we recognize so none of "our state" has changed
1297 if (hints == null) {
1298 hints = makeHints(null);
1299 }
1300 hints.put(hintKey, hintValue);
1301 }
1302
1303
1304 /**
1305 * Returns the preferences for the rendering algorithms.
1306 * @param hintKey The category of hint to be set. The strings
1307 * are defined in the RenderingHints class.
1308 * @return The preferences for rendering algorithms. The strings
1309 * are defined in the RenderingHints class.
1310 * @see RenderingHints
1311 */
1312 public Object getRenderingHint(Key hintKey) {
1313 if (hints != null) {
1314 return hints.get(hintKey);
1315 }
1316 if (!(hintKey instanceof SunHints.Key)) {
1317 return null;
1318 }
1319 int keyindex = ((SunHints.Key)hintKey).getIndex();
1320 switch (keyindex) {
1321 case SunHints.INTKEY_RENDERING:
1322 return SunHints.Value.get(SunHints.INTKEY_RENDERING,
1323 renderHint);
1324 case SunHints.INTKEY_ANTIALIASING:
1325 return SunHints.Value.get(SunHints.INTKEY_ANTIALIASING,
1326 antialiasHint);
1327 case SunHints.INTKEY_TEXT_ANTIALIASING:
1328 return SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
1329 textAntialiasHint);
1330 case SunHints.INTKEY_FRACTIONALMETRICS:
1331 return SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
1332 fractionalMetricsHint);
1333 case SunHints.INTKEY_AATEXT_LCD_CONTRAST:
1334 return lcdTextContrast;
1335 case SunHints.INTKEY_INTERPOLATION:
1336 switch (interpolationHint) {
1337 case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
1338 return SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
1339 case SunHints.INTVAL_INTERPOLATION_BILINEAR:
1340 return SunHints.VALUE_INTERPOLATION_BILINEAR;
1341 case SunHints.INTVAL_INTERPOLATION_BICUBIC:
1342 return SunHints.VALUE_INTERPOLATION_BICUBIC;
1343 }
1344 return null;
1345 case SunHints.INTKEY_STROKE_CONTROL:
1346 return SunHints.Value.get(SunHints.INTKEY_STROKE_CONTROL,
1347 strokeHint);
1348 case SunHints.INTKEY_RESOLUTION_VARIANT:
1349 return SunHints.Value.get(SunHints.INTKEY_RESOLUTION_VARIANT,
1350 resolutionVariantHint);
1351 }
1352 return null;
1353 }
1354
1355 /**
1356 * Sets the preferences for the rendering algorithms.
1357 * Hint categories include controls for rendering quality and
1358 * overall time/quality trade-off in the rendering process.
1359 * @param hints The rendering hints to be set
1360 * @see RenderingHints
1361 */
1362 public void setRenderingHints(Map<?,?> hints) {
1363 this.hints = null;
1364 renderHint = SunHints.INTVAL_RENDER_DEFAULT;
1365 antialiasHint = SunHints.INTVAL_ANTIALIAS_OFF;
1366 textAntialiasHint = SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT;
1367 fractionalMetricsHint = SunHints.INTVAL_FRACTIONALMETRICS_OFF;
1368 lcdTextContrast = lcdTextContrastDefaultValue;
1369 interpolationHint = -1;
1370 interpolationType = AffineTransformOp.TYPE_NEAREST_NEIGHBOR;
1371 boolean customHintPresent = false;
1372 Iterator<?> iter = hints.keySet().iterator();
1373 while (iter.hasNext()) {
1374 Object key = iter.next();
1375 if (key == SunHints.KEY_RENDERING ||
1376 key == SunHints.KEY_ANTIALIASING ||
1377 key == SunHints.KEY_TEXT_ANTIALIASING ||
1378 key == SunHints.KEY_FRACTIONALMETRICS ||
1379 key == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST ||
1380 key == SunHints.KEY_STROKE_CONTROL ||
1381 key == SunHints.KEY_INTERPOLATION)
1382 {
1383 setRenderingHint((Key) key, hints.get(key));
1384 } else {
1385 customHintPresent = true;
1386 }
1387 }
1388 if (customHintPresent) {
1389 this.hints = makeHints(hints);
1390 }
1391 invalidatePipe();
1392 }
1393
1394 /**
1395 * Adds a number of preferences for the rendering algorithms.
1396 * Hint categories include controls for rendering quality and
1397 * overall time/quality trade-off in the rendering process.
1398 * @param hints The rendering hints to be set
1399 * @see RenderingHints
1400 */
1401 public void addRenderingHints(Map<?,?> hints) {
1402 boolean customHintPresent = false;
1403 Iterator<?> iter = hints.keySet().iterator();
1404 while (iter.hasNext()) {
1405 Object key = iter.next();
1406 if (key == SunHints.KEY_RENDERING ||
1407 key == SunHints.KEY_ANTIALIASING ||
1408 key == SunHints.KEY_TEXT_ANTIALIASING ||
1409 key == SunHints.KEY_FRACTIONALMETRICS ||
1410 key == SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST ||
1411 key == SunHints.KEY_STROKE_CONTROL ||
1412 key == SunHints.KEY_INTERPOLATION)
1413 {
1414 setRenderingHint((Key) key, hints.get(key));
1415 } else {
1416 customHintPresent = true;
1417 }
1418 }
1419 if (customHintPresent) {
1420 if (this.hints == null) {
1421 this.hints = makeHints(hints);
1422 } else {
1423 this.hints.putAll(hints);
1424 }
1425 }
1426 }
1427
1428 /**
1429 * Gets the preferences for the rendering algorithms.
1430 * Hint categories include controls for rendering quality and
1431 * overall time/quality trade-off in the rendering process.
1432 * @see RenderingHints
1433 */
1434 public RenderingHints getRenderingHints() {
1435 if (hints == null) {
1436 return makeHints(null);
1437 } else {
1438 return (RenderingHints) hints.clone();
1439 }
1440 }
1441
1442 RenderingHints makeHints(Map<?,?> hints) {
1443 RenderingHints model = new RenderingHints(null);
1444 if (hints != null) {
1445 model.putAll(hints);
1446 }
1447 model.put(SunHints.KEY_RENDERING,
1448 SunHints.Value.get(SunHints.INTKEY_RENDERING,
1449 renderHint));
1450 model.put(SunHints.KEY_ANTIALIASING,
1451 SunHints.Value.get(SunHints.INTKEY_ANTIALIASING,
1452 antialiasHint));
1453 model.put(SunHints.KEY_TEXT_ANTIALIASING,
1454 SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING,
1455 textAntialiasHint));
1456 model.put(SunHints.KEY_FRACTIONALMETRICS,
1457 SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
1458 fractionalMetricsHint));
1459 model.put(SunHints.KEY_TEXT_ANTIALIAS_LCD_CONTRAST,
1460 Integer.valueOf(lcdTextContrast));
1461 Object value;
1462 switch (interpolationHint) {
1463 case SunHints.INTVAL_INTERPOLATION_NEAREST_NEIGHBOR:
1464 value = SunHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR;
1465 break;
1466 case SunHints.INTVAL_INTERPOLATION_BILINEAR:
1467 value = SunHints.VALUE_INTERPOLATION_BILINEAR;
1468 break;
1469 case SunHints.INTVAL_INTERPOLATION_BICUBIC:
1470 value = SunHints.VALUE_INTERPOLATION_BICUBIC;
1471 break;
1472 default:
1473 value = null;
1474 break;
1475 }
1476 if (value != null) {
1477 model.put(SunHints.KEY_INTERPOLATION, value);
1478 }
1479 model.put(SunHints.KEY_STROKE_CONTROL,
1480 SunHints.Value.get(SunHints.INTKEY_STROKE_CONTROL,
1481 strokeHint));
1482 return model;
1483 }
1484
1485 /**
1486 * Concatenates the current transform of this Graphics2D with a
1487 * translation transformation.
1488 * This is equivalent to calling transform(T), where T is an
1489 * AffineTransform represented by the following matrix:
1490 * <pre>
1491 * [ 1 0 tx ]
1492 * [ 0 1 ty ]
1493 * [ 0 0 1 ]
1494 * </pre>
1495 */
1496 public void translate(double tx, double ty) {
1497 transform.translate(tx, ty);
1498 invalidateTransform();
1499 }
1500
1501 /**
1502 * Concatenates the current transform of this Graphics2D with a
1503 * rotation transformation.
1504 * This is equivalent to calling transform(R), where R is an
1505 * AffineTransform represented by the following matrix:
1506 * <pre>
1507 * [ cos(theta) -sin(theta) 0 ]
1508 * [ sin(theta) cos(theta) 0 ]
1509 * [ 0 0 1 ]
1510 * </pre>
1511 * Rotating with a positive angle theta rotates points on the positive
1512 * x axis toward the positive y axis.
1513 * @param theta The angle of rotation in radians.
1514 */
1515 public void rotate(double theta) {
1516 transform.rotate(theta);
1517 invalidateTransform();
1518 }
1519
1520 /**
1521 * Concatenates the current transform of this Graphics2D with a
1522 * translated rotation transformation.
1523 * This is equivalent to the following sequence of calls:
1524 * <pre>
1525 * translate(x, y);
1526 * rotate(theta);
1527 * translate(-x, -y);
1528 * </pre>
1529 * Rotating with a positive angle theta rotates points on the positive
1530 * x axis toward the positive y axis.
1531 * @param theta The angle of rotation in radians.
1532 * @param x The x coordinate of the origin of the rotation
1533 * @param y The x coordinate of the origin of the rotation
1534 */
1535 public void rotate(double theta, double x, double y) {
1536 transform.rotate(theta, x, y);
1537 invalidateTransform();
1538 }
1539
1540 /**
1541 * Concatenates the current transform of this Graphics2D with a
1542 * scaling transformation.
1543 * This is equivalent to calling transform(S), where S is an
1544 * AffineTransform represented by the following matrix:
1545 * <pre>
1546 * [ sx 0 0 ]
1547 * [ 0 sy 0 ]
1548 * [ 0 0 1 ]
1549 * </pre>
1550 */
1551 public void scale(double sx, double sy) {
1552 transform.scale(sx, sy);
1553 invalidateTransform();
1554 }
1555
1556 /**
1557 * Concatenates the current transform of this Graphics2D with a
1558 * shearing transformation.
1559 * This is equivalent to calling transform(SH), where SH is an
1560 * AffineTransform represented by the following matrix:
1561 * <pre>
1562 * [ 1 shx 0 ]
1563 * [ shy 1 0 ]
1564 * [ 0 0 1 ]
1565 * </pre>
1566 * @param shx The factor by which coordinates are shifted towards the
1567 * positive X axis direction according to their Y coordinate
1568 * @param shy The factor by which coordinates are shifted towards the
1569 * positive Y axis direction according to their X coordinate
1570 */
1571 public void shear(double shx, double shy) {
1572 transform.shear(shx, shy);
1573 invalidateTransform();
1574 }
1575
1576 /**
1577 * Composes a Transform object with the transform in this
1578 * Graphics2D according to the rule last-specified-first-applied.
1579 * If the currrent transform is Cx, the result of composition
1580 * with Tx is a new transform Cx'. Cx' becomes the current
1581 * transform for this Graphics2D.
1582 * Transforming a point p by the updated transform Cx' is
1583 * equivalent to first transforming p by Tx and then transforming
1584 * the result by the original transform Cx. In other words,
1585 * Cx'(p) = Cx(Tx(p)).
1586 * A copy of the Tx is made, if necessary, so further
1587 * modifications to Tx do not affect rendering.
1588 * @param xform The Transform object to be composed with the current
1589 * transform.
1590 * @see #setTransform
1591 * @see AffineTransform
1592 */
1593 public void transform(AffineTransform xform) {
1594 this.transform.concatenate(xform);
1595 invalidateTransform();
1596 }
1597
1598 /**
1599 * Translate
1600 */
1601 public void translate(int x, int y) {
1602 transform.translate(x, y);
1603 if (transformState <= TRANSFORM_INT_TRANSLATE) {
1604 transX += x;
1605 transY += y;
1606 transformState = (((transX | transY) == 0) ?
1607 TRANSFORM_ISIDENT : TRANSFORM_INT_TRANSLATE);
1608 } else {
1609 invalidateTransform();
1610 }
1611 }
1612
1613 /**
1614 * Sets the Transform in the current graphics state.
1615 * @param Tx The Transform object to be used in the rendering process.
1616 * @see #transform
1617 * @see AffineTransform
1618 */
1619 @Override
1620 public void setTransform(AffineTransform Tx) {
1621 if ((constrainX | constrainY) == 0) {
1622 transform.setTransform(Tx);
1623 } else {
1624 transform.setToTranslation(constrainX, constrainY);
1625 transform.concatenate(Tx);
1626 }
1627 invalidateTransform();
1628 }
1629
1630 protected void invalidateTransform() {
1631 int type = transform.getType();
1632 int origTransformState = transformState;
1633 if (type == AffineTransform.TYPE_IDENTITY) {
1634 transformState = TRANSFORM_ISIDENT;
1635 transX = transY = 0;
1636 } else if (type == AffineTransform.TYPE_TRANSLATION) {
1637 double dtx = transform.getTranslateX();
1638 double dty = transform.getTranslateY();
1639 transX = (int) Math.floor(dtx + 0.5);
1640 transY = (int) Math.floor(dty + 0.5);
1641 if (dtx == transX && dty == transY) {
1642 transformState = TRANSFORM_INT_TRANSLATE;
1643 } else {
1644 transformState = TRANSFORM_ANY_TRANSLATE;
1645 }
1646 } else if ((type & (AffineTransform.TYPE_FLIP |
1647 AffineTransform.TYPE_MASK_ROTATION |
1648 AffineTransform.TYPE_GENERAL_TRANSFORM)) == 0)
1649 {
1650 transformState = TRANSFORM_TRANSLATESCALE;
1651 transX = transY = 0;
1652 } else {
1653 transformState = TRANSFORM_GENERIC;
1654 transX = transY = 0;
1655 }
1656
1657 if (transformState >= TRANSFORM_TRANSLATESCALE ||
1658 origTransformState >= TRANSFORM_TRANSLATESCALE)
1659 {
1660 /* Its only in this case that the previous or current transform
1661 * was more than a translate that font info is invalidated
1662 */
1663 cachedFRC = null;
1664 this.validFontInfo = false;
1665 this.fontMetrics = null;
1666 this.glyphVectorFontInfo = null;
1667
1668 if (transformState != origTransformState) {
1669 invalidatePipe();
1670 }
1671 }
1672 if (strokeState != STROKE_CUSTOM) {
1673 validateBasicStroke((BasicStroke) stroke);
1674 }
1675 }
1676
1677 /**
1678 * Returns the current Transform in the Graphics2D state.
1679 * @see #transform
1680 * @see #setTransform
1681 */
1682 @Override
1683 public AffineTransform getTransform() {
1684 if ((constrainX | constrainY) == 0) {
1685 return new AffineTransform(transform);
1686 }
1687 AffineTransform tx
1688 = AffineTransform.getTranslateInstance(-constrainX, -constrainY);
1689 tx.concatenate(transform);
1690 return tx;
1691 }
1692
1693 /**
1694 * Returns the current Transform ignoring the "constrain"
1695 * rectangle.
1696 */
1697 public AffineTransform cloneTransform() {
1698 return new AffineTransform(transform);
1699 }
1700
1701 /**
1702 * Returns the current Paint in the Graphics2D state.
1703 * @see #setPaint
1704 * @see java.awt.Graphics#setColor
1705 */
1706 public Paint getPaint() {
1707 return paint;
1708 }
1709
1710 /**
1711 * Returns the current Composite in the Graphics2D state.
1712 * @see #setComposite
1713 */
1714 public Composite getComposite() {
1715 return composite;
1716 }
1717
1718 public Color getColor() {
1719 return foregroundColor;
1720 }
1721
1722 /*
1723 * Validate the eargb and pixel fields against the current color.
1724 *
1725 * The eargb field must take into account the extraAlpha
1726 * value of an AlphaComposite. It may also take into account
1727 * the Fsrc Porter-Duff blending function if such a function is
1728 * a constant (see handling of Clear mode below). For instance,
1729 * by factoring in the (Fsrc == 0) state of the Clear mode we can
1730 * use a SrcNoEa loop just as easily as a general Alpha loop
1731 * since the math will be the same in both cases.
1732 *
1733 * The pixel field will always be the best pixel data choice for
1734 * the final result of all calculations applied to the eargb field.
1735 *
1736 * Note that this method is only necessary under the following
1737 * conditions:
1738 * (paintState <= PAINT_ALPHA_COLOR &&
1739 * compositeState <= COMP_CUSTOM)
1740 * though nothing bad will happen if it is run in other states.
1741 */
1742 void validateColor() {
1743 int eargb;
1744 if (imageComp == CompositeType.Clear) {
1745 eargb = 0;
1746 } else {
1747 eargb = foregroundColor.getRGB();
1748 if (compositeState <= COMP_ALPHA &&
1749 imageComp != CompositeType.SrcNoEa &&
1750 imageComp != CompositeType.SrcOverNoEa)
1751 {
1752 AlphaComposite alphacomp = (AlphaComposite) composite;
1753 int a = Math.round(alphacomp.getAlpha() * (eargb >>> 24));
1754 eargb = (eargb & 0x00ffffff) | (a << 24);
1755 }
1756 }
1757 this.eargb = eargb;
1758 this.pixel = surfaceData.pixelFor(eargb);
1759 }
1760
1761 public void setColor(Color color) {
1762 if (color == null || color == paint) {
1763 return;
1764 }
1765 this.paint = foregroundColor = color;
1766 validateColor();
1767 if ((eargb >> 24) == -1) {
1768 if (paintState == PAINT_OPAQUECOLOR) {
1769 return;
1770 }
1771 paintState = PAINT_OPAQUECOLOR;
1772 if (imageComp == CompositeType.SrcOverNoEa) {
1773 // special case where compState depends on opacity of paint
1774 compositeState = COMP_ISCOPY;
1775 }
1776 } else {
1777 if (paintState == PAINT_ALPHACOLOR) {
1778 return;
1779 }
1780 paintState = PAINT_ALPHACOLOR;
1781 if (imageComp == CompositeType.SrcOverNoEa) {
1782 // special case where compState depends on opacity of paint
1783 compositeState = COMP_ALPHA;
1784 }
1785 }
1786 validFontInfo = false;
1787 invalidatePipe();
1788 }
1789
1790 /**
1791 * Sets the background color in this context used for clearing a region.
1792 * When Graphics2D is constructed for a component, the backgroung color is
1793 * inherited from the component. Setting the background color in the
1794 * Graphics2D context only affects the subsequent clearRect() calls and
1795 * not the background color of the component. To change the background
1796 * of the component, use appropriate methods of the component.
1797 * @param color The background color that should be used in
1798 * subsequent calls to clearRect().
1799 * @see #getBackground
1800 * @see Graphics#clearRect
1801 */
1802 public void setBackground(Color color) {
1803 backgroundColor = color;
1804 }
1805
1806 /**
1807 * Returns the background color used for clearing a region.
1808 * @see #setBackground
1809 */
1810 public Color getBackground() {
1811 return backgroundColor;
1812 }
1813
1814 /**
1815 * Returns the current Stroke in the Graphics2D state.
1816 * @see #setStroke
1817 */
1818 public Stroke getStroke() {
1819 return stroke;
1820 }
1821
1822 public Rectangle getClipBounds() {
1823 if (clipState == CLIP_DEVICE) {
1824 return null;
1825 }
1826 return getClipBounds(new Rectangle());
1827 }
1828
1829 public Rectangle getClipBounds(Rectangle r) {
1830 if (clipState != CLIP_DEVICE) {
1831 if (transformState <= TRANSFORM_INT_TRANSLATE) {
1832 if (usrClip instanceof Rectangle) {
1833 r.setBounds((Rectangle) usrClip);
1834 } else {
1835 r.setFrame(usrClip.getBounds2D());
1836 }
1837 r.translate(-transX, -transY);
1838 } else {
1839 r.setFrame(getClip().getBounds2D());
1840 }
1841 } else if (r == null) {
1842 throw new NullPointerException("null rectangle parameter");
1843 }
1844 return r;
1845 }
1846
1847 public boolean hitClip(int x, int y, int width, int height) {
1848 if (width <= 0 || height <= 0) {
1849 return false;
1850 }
1851 if (transformState > TRANSFORM_INT_TRANSLATE) {
1852 // Note: Technically the most accurate test would be to
1853 // raster scan the parallelogram of the transformed rectangle
1854 // and do a span for span hit test against the clip, but for
1855 // speed we approximate the test with a bounding box of the
1856 // transformed rectangle. The cost of rasterizing the
1857 // transformed rectangle is probably high enough that it is
1858 // not worth doing so to save the caller from having to call
1859 // a rendering method where we will end up discovering the
1860 // same answer in about the same amount of time anyway.
1861 // This logic breaks down if this hit test is being performed
1862 // on the bounds of a group of shapes in which case it might
1863 // be beneficial to be a little more accurate to avoid lots
1864 // of subsequent rendering calls. In either case, this relaxed
1865 // test should not be significantly less accurate than the
1866 // optimal test for most transforms and so the conservative
1867 // answer should not cause too much extra work.
1868
1869 double[] d = {
1870 x, y,
1871 x+width, y,
1872 x, y+height,
1873 x+width, y+height
1874 };
1875 transform.transform(d, 0, d, 0, 4);
1876 x = (int) Math.floor(Math.min(Math.min(d[0], d[2]),
1877 Math.min(d[4], d[6])));
1878 y = (int) Math.floor(Math.min(Math.min(d[1], d[3]),
1879 Math.min(d[5], d[7])));
1880 width = (int) Math.ceil(Math.max(Math.max(d[0], d[2]),
1881 Math.max(d[4], d[6])));
1882 height = (int) Math.ceil(Math.max(Math.max(d[1], d[3]),
1883 Math.max(d[5], d[7])));
1884 } else {
1885 x += transX;
1886 y += transY;
1887 width += x;
1888 height += y;
1889 }
1890
1891 try {
1892 if (!getCompClip().intersectsQuickCheckXYXY(x, y, width, height)) {
1893 return false;
1894 }
1895 } catch (InvalidPipeException e) {
1896 return false;
1897 }
1898 // REMIND: We could go one step further here and examine the
1899 // non-rectangular clip shape more closely if there is one.
1900 // Since the clip has already been rasterized, the performance
1901 // penalty of doing the scan is probably still within the bounds
1902 // of a good tradeoff between speed and quality of the answer.
1903 return true;
1904 }
1905
1906 protected void validateCompClip() {
1907 int origClipState = clipState;
1908 if (usrClip == null) {
1909 clipState = CLIP_DEVICE;
1910 clipRegion = devClip;
1911 } else if (usrClip instanceof Rectangle2D) {
1912 clipState = CLIP_RECTANGULAR;
1913 clipRegion = devClip.getIntersection((Rectangle2D) usrClip);
1914 } else {
1915 PathIterator cpi = usrClip.getPathIterator(null);
1916 int[] box = new int[4];
1917 ShapeSpanIterator sr = LoopPipe.getFillSSI(this);
1918 try {
1919 sr.setOutputArea(devClip);
1920 sr.appendPath(cpi);
1921 sr.getPathBox(box);
1922 Region r = Region.getInstance(box, sr);
1923 clipRegion = r;
1924 clipState =
1925 r.isRectangular() ? CLIP_RECTANGULAR : CLIP_SHAPE;
1926 } finally {
1927 sr.dispose();
1928 }
1929 }
1930 if (origClipState != clipState &&
1931 (clipState == CLIP_SHAPE || origClipState == CLIP_SHAPE))
1932 {
1933 validFontInfo = false;
1934 invalidatePipe();
1935 }
1936 }
1937
1938 static final int NON_RECTILINEAR_TRANSFORM_MASK =
1939 (AffineTransform.TYPE_GENERAL_TRANSFORM |
1940 AffineTransform.TYPE_GENERAL_ROTATION);
1941
1942 protected Shape transformShape(Shape s) {
1943 if (s == null) {
1944 return null;
1945 }
1946 if (transformState > TRANSFORM_INT_TRANSLATE) {
1947 return transformShape(transform, s);
1948 } else {
1949 return transformShape(transX, transY, s);
1950 }
1951 }
1952
1953 public Shape untransformShape(Shape s) {
1954 if (s == null) {
1955 return null;
1956 }
1957 if (transformState > TRANSFORM_INT_TRANSLATE) {
1958 try {
1959 return transformShape(transform.createInverse(), s);
1960 } catch (NoninvertibleTransformException e) {
1961 return null;
1962 }
1963 } else {
1964 return transformShape(-transX, -transY, s);
1965 }
1966 }
1967
1968 protected static Shape transformShape(int tx, int ty, Shape s) {
1969 if (s == null) {
1970 return null;
1971 }
1972
1973 if (s instanceof Rectangle) {
1974 Rectangle r = s.getBounds();
1975 r.translate(tx, ty);
1976 return r;
1977 }
1978 if (s instanceof Rectangle2D) {
1979 Rectangle2D rect = (Rectangle2D) s;
1980 return new Rectangle2D.Double(rect.getX() + tx,
1981 rect.getY() + ty,
1982 rect.getWidth(),
1983 rect.getHeight());
1984 }
1985
1986 if (tx == 0 && ty == 0) {
1987 return cloneShape(s);
1988 }
1989
1990 AffineTransform mat = AffineTransform.getTranslateInstance(tx, ty);
1991 return mat.createTransformedShape(s);
1992 }
1993
1994 protected static Shape transformShape(AffineTransform tx, Shape clip) {
1995 if (clip == null) {
1996 return null;
1997 }
1998
1999 if (clip instanceof Rectangle2D &&
2000 (tx.getType() & NON_RECTILINEAR_TRANSFORM_MASK) == 0)
2001 {
2002 Rectangle2D rect = (Rectangle2D) clip;
2003 double[] matrix = new double[4];
2004 matrix[0] = rect.getX();
2005 matrix[1] = rect.getY();
2006 matrix[2] = matrix[0] + rect.getWidth();
2007 matrix[3] = matrix[1] + rect.getHeight();
2008 tx.transform(matrix, 0, matrix, 0, 2);
2009 fixRectangleOrientation(matrix, rect);
2010 return new Rectangle2D.Double(matrix[0], matrix[1],
2011 matrix[2] - matrix[0],
2012 matrix[3] - matrix[1]);
2013 }
2014
2015 if (tx.isIdentity()) {
2016 return cloneShape(clip);
2017 }
2018
2019 return tx.createTransformedShape(clip);
2020 }
2021
2022 /**
2023 * Sets orientation of the rectangle according to the clip.
2024 */
2025 private static void fixRectangleOrientation(double[] m, Rectangle2D clip) {
2026 if (clip.getWidth() > 0 != (m[2] - m[0] > 0)) {
2027 double t = m[0];
2028 m[0] = m[2];
2029 m[2] = t;
2030 }
2031 if (clip.getHeight() > 0 != (m[3] - m[1] > 0)) {
2032 double t = m[1];
2033 m[1] = m[3];
2034 m[3] = t;
2035 }
2036 }
2037
2038 public void clipRect(int x, int y, int w, int h) {
2039 clip(new Rectangle(x, y, w, h));
2040 }
2041
2042 public void setClip(int x, int y, int w, int h) {
2043 setClip(new Rectangle(x, y, w, h));
2044 }
2045
2046 public Shape getClip() {
2047 return untransformShape(usrClip);
2048 }
2049
2050 public void setClip(Shape sh) {
2051 usrClip = transformShape(sh);
2052 validateCompClip();
2053 }
2054
2055 /**
2056 * Intersects the current clip with the specified Path and sets the
2057 * current clip to the resulting intersection. The clip is transformed
2058 * with the current transform in the Graphics2D state before being
2059 * intersected with the current clip. This method is used to make the
2060 * current clip smaller. To make the clip larger, use any setClip method.
2061 * @param s The Path to be intersected with the current clip.
2062 */
2063 public void clip(Shape s) {
2064 s = transformShape(s);
2065 if (usrClip != null) {
2066 s = intersectShapes(usrClip, s, true, true);
2067 }
2068 usrClip = s;
2069 validateCompClip();
2070 }
2071
2072 public void setPaintMode() {
2073 setComposite(AlphaComposite.SrcOver);
2074 }
2075
2076 public void setXORMode(Color c) {
2077 if (c == null) {
2078 throw new IllegalArgumentException("null XORColor");
2079 }
2080 setComposite(new XORComposite(c, surfaceData));
2081 }
2082
2083 Blit lastCAblit;
2084 Composite lastCAcomp;
2085
2086 public void copyArea(int x, int y, int w, int h, int dx, int dy) {
2087 try {
2088 doCopyArea(x, y, w, h, dx, dy);
2089 } catch (InvalidPipeException e) {
2090 try {
2091 revalidateAll();
2092 doCopyArea(x, y, w, h, dx, dy);
2093 } catch (InvalidPipeException e2) {
2094 // Still catching the exception; we are not yet ready to
2095 // validate the surfaceData correctly. Fail for now and
2096 // try again next time around.
2097 }
2098 } finally {
2099 surfaceData.markDirty();
2100 }
2101 }
2102
2103 private void doCopyArea(int x, int y, int w, int h, int dx, int dy) {
2104 if (w <= 0 || h <= 0) {
2105 return;
2106 }
2107
2108 if (transformState == SunGraphics2D.TRANSFORM_ISIDENT) {
2109 // do nothing
2110 } else if (transformState <= SunGraphics2D.TRANSFORM_ANY_TRANSLATE) {
2111 x += transX;
2112 y += transY;
2113 } else if (transformState == SunGraphics2D.TRANSFORM_TRANSLATESCALE) {
2114 final double[] coords = {x, y, x + w, y + h, x + dx, y + dy};
2115 transform.transform(coords, 0, coords, 0, 3);
2116 x = (int) Math.ceil(coords[0] - 0.5);
2117 y = (int) Math.ceil(coords[1] - 0.5);
2118 w = ((int) Math.ceil(coords[2] - 0.5)) - x;
2119 h = ((int) Math.ceil(coords[3] - 0.5)) - y;
2120 dx = ((int) Math.ceil(coords[4] - 0.5)) - x;
2121 dy = ((int) Math.ceil(coords[5] - 0.5)) - y;
2122 // In case of negative scale transform, reflect the rect coords.
2123 if (w < 0) {
2124 w = -w;
2125 x -= w;
2126 }
2127 if (h < 0) {
2128 h = -h;
2129 y -= h;
2130 }
2131 } else {
2132 throw new InternalError("transformed copyArea not implemented yet");
2133 }
2134
2135 SurfaceData theData = surfaceData;
2136 if (theData.copyArea(this, x, y, w, h, dx, dy)) {
2137 return;
2138 }
2139
2140 // REMIND: This method does not deal with missing data from the
2141 // source object (i.e. it does not send exposure events...)
2142
2143 Region clip = getCompClip();
2144
2145 Composite comp = composite;
2146 if (lastCAcomp != comp) {
2147 SurfaceType dsttype = theData.getSurfaceType();
2148 CompositeType comptype = imageComp;
2149 if (CompositeType.SrcOverNoEa.equals(comptype) &&
2150 theData.getTransparency() == Transparency.OPAQUE)
2151 {
2152 comptype = CompositeType.SrcNoEa;
2153 }
2154 lastCAblit = Blit.locate(dsttype, comptype, dsttype);
2155 lastCAcomp = comp;
2156 }
2157
2158 Blit ob = lastCAblit;
2159 if (dy == 0 && dx > 0 && dx < w) {
2160 while (w > 0) {
2161 int partW = Math.min(w, dx);
2162 w -= partW;
2163 int sx = x + w;
2164 ob.Blit(theData, theData, comp, clip,
2165 sx, y, sx+dx, y+dy, partW, h);
2166 }
2167 return;
2168 }
2169 if (dy > 0 && dy < h && dx > -w && dx < w) {
2170 while (h > 0) {
2171 int partH = Math.min(h, dy);
2172 h -= partH;
2173 int sy = y + h;
2174 ob.Blit(theData, theData, comp, clip,
2175 x, sy, x+dx, sy+dy, w, partH);
2176 }
2177 return;
2178 }
2179 ob.Blit(theData, theData, comp, clip, x, y, x+dx, y+dy, w, h);
2180 }
2181
2182 /*
2183 public void XcopyArea(int x, int y, int w, int h, int dx, int dy) {
2184 Rectangle rect = new Rectangle(x, y, w, h);
2185 rect = transformBounds(rect, transform);
2186 Point2D point = new Point2D.Float(dx, dy);
2187 Point2D root = new Point2D.Float(0, 0);
2188 point = transform.transform(point, point);
2189 root = transform.transform(root, root);
2190 int fdx = (int)(point.getX()-root.getX());
2191 int fdy = (int)(point.getY()-root.getY());
2192
2193 Rectangle r = getCompBounds().intersection(rect.getBounds());
2194
2195 if (r.isEmpty()) {
2196 return;
2197 }
2198
2199 // Begin Rasterizer for Clip Shape
2200 boolean skipClip = true;
2201 byte[] clipAlpha = null;
2202
2203 if (clipState == CLIP_SHAPE) {
2204
2205 int box[] = new int[4];
2206
2207 clipRegion.getBounds(box);
2208 Rectangle devR = new Rectangle(box[0], box[1],
2209 box[2] - box[0],
2210 box[3] - box[1]);
2211 if (!devR.isEmpty()) {
2212 OutputManager mgr = getOutputManager();
2213 RegionIterator ri = clipRegion.getIterator();
2214 while (ri.nextYRange(box)) {
2215 int spany = box[1];
2216 int spanh = box[3] - spany;
2217 while (ri.nextXBand(box)) {
2218 int spanx = box[0];
2219 int spanw = box[2] - spanx;
2220 mgr.copyArea(this, null,
2221 spanw, 0,
2222 spanx, spany,
2223 spanw, spanh,
2224 fdx, fdy,
2225 null);
2226 }
2227 }
2228 }
2229 return;
2230 }
2231 // End Rasterizer for Clip Shape
2232
2233 getOutputManager().copyArea(this, null,
2234 r.width, 0,
2235 r.x, r.y, r.width,
2236 r.height, fdx, fdy,
2237 null);
2238 }
2239 */
2240
2241 public void drawLine(int x1, int y1, int x2, int y2) {
2242 try {
2243 drawpipe.drawLine(this, x1, y1, x2, y2);
2244 } catch (InvalidPipeException e) {
2245 try {
2246 revalidateAll();
2247 drawpipe.drawLine(this, x1, y1, x2, y2);
2248 } catch (InvalidPipeException e2) {
2249 // Still catching the exception; we are not yet ready to
2250 // validate the surfaceData correctly. Fail for now and
2251 // try again next time around.
2252 }
2253 } finally {
2254 surfaceData.markDirty();
2255 }
2256 }
2257
2258 public void drawRoundRect(int x, int y, int w, int h, int arcW, int arcH) {
2259 try {
2260 drawpipe.drawRoundRect(this, x, y, w, h, arcW, arcH);
2261 } catch (InvalidPipeException e) {
2262 try {
2263 revalidateAll();
2264 drawpipe.drawRoundRect(this, x, y, w, h, arcW, arcH);
2265 } catch (InvalidPipeException e2) {
2266 // Still catching the exception; we are not yet ready to
2267 // validate the surfaceData correctly. Fail for now and
2268 // try again next time around.
2269 }
2270 } finally {
2271 surfaceData.markDirty();
2272 }
2273 }
2274
2275 public void fillRoundRect(int x, int y, int w, int h, int arcW, int arcH) {
2276 try {
2277 fillpipe.fillRoundRect(this, x, y, w, h, arcW, arcH);
2278 } catch (InvalidPipeException e) {
2279 try {
2280 revalidateAll();
2281 fillpipe.fillRoundRect(this, x, y, w, h, arcW, arcH);
2282 } catch (InvalidPipeException e2) {
2283 // Still catching the exception; we are not yet ready to
2284 // validate the surfaceData correctly. Fail for now and
2285 // try again next time around.
2286 }
2287 } finally {
2288 surfaceData.markDirty();
2289 }
2290 }
2291
2292 public void drawOval(int x, int y, int w, int h) {
2293 try {
2294 drawpipe.drawOval(this, x, y, w, h);
2295 } catch (InvalidPipeException e) {
2296 try {
2297 revalidateAll();
2298 drawpipe.drawOval(this, x, y, w, h);
2299 } catch (InvalidPipeException e2) {
2300 // Still catching the exception; we are not yet ready to
2301 // validate the surfaceData correctly. Fail for now and
2302 // try again next time around.
2303 }
2304 } finally {
2305 surfaceData.markDirty();
2306 }
2307 }
2308
2309 public void fillOval(int x, int y, int w, int h) {
2310 try {
2311 fillpipe.fillOval(this, x, y, w, h);
2312 } catch (InvalidPipeException e) {
2313 try {
2314 revalidateAll();
2315 fillpipe.fillOval(this, x, y, w, h);
2316 } catch (InvalidPipeException e2) {
2317 // Still catching the exception; we are not yet ready to
2318 // validate the surfaceData correctly. Fail for now and
2319 // try again next time around.
2320 }
2321 } finally {
2322 surfaceData.markDirty();
2323 }
2324 }
2325
2326 public void drawArc(int x, int y, int w, int h,
2327 int startAngl, int arcAngl) {
2328 try {
2329 drawpipe.drawArc(this, x, y, w, h, startAngl, arcAngl);
2330 } catch (InvalidPipeException e) {
2331 try {
2332 revalidateAll();
2333 drawpipe.drawArc(this, x, y, w, h, startAngl, arcAngl);
2334 } catch (InvalidPipeException e2) {
2335 // Still catching the exception; we are not yet ready to
2336 // validate the surfaceData correctly. Fail for now and
2337 // try again next time around.
2338 }
2339 } finally {
2340 surfaceData.markDirty();
2341 }
2342 }
2343
2344 public void fillArc(int x, int y, int w, int h,
2345 int startAngl, int arcAngl) {
2346 try {
2347 fillpipe.fillArc(this, x, y, w, h, startAngl, arcAngl);
2348 } catch (InvalidPipeException e) {
2349 try {
2350 revalidateAll();
2351 fillpipe.fillArc(this, x, y, w, h, startAngl, arcAngl);
2352 } catch (InvalidPipeException e2) {
2353 // Still catching the exception; we are not yet ready to
2354 // validate the surfaceData correctly. Fail for now and
2355 // try again next time around.
2356 }
2357 } finally {
2358 surfaceData.markDirty();
2359 }
2360 }
2361
2362 public void drawPolyline(int[] xPoints, int[] yPoints, int nPoints) {
2363 try {
2364 drawpipe.drawPolyline(this, xPoints, yPoints, nPoints);
2365 } catch (InvalidPipeException e) {
2366 try {
2367 revalidateAll();
2368 drawpipe.drawPolyline(this, xPoints, yPoints, nPoints);
2369 } catch (InvalidPipeException e2) {
2370 // Still catching the exception; we are not yet ready to
2371 // validate the surfaceData correctly. Fail for now and
2372 // try again next time around.
2373 }
2374 } finally {
2375 surfaceData.markDirty();
2376 }
2377 }
2378
2379 public void drawPolygon(int[] xPoints, int[] yPoints, int nPoints) {
2380 try {
2381 drawpipe.drawPolygon(this, xPoints, yPoints, nPoints);
2382 } catch (InvalidPipeException e) {
2383 try {
2384 revalidateAll();
2385 drawpipe.drawPolygon(this, xPoints, yPoints, nPoints);
2386 } catch (InvalidPipeException e2) {
2387 // Still catching the exception; we are not yet ready to
2388 // validate the surfaceData correctly. Fail for now and
2389 // try again next time around.
2390 }
2391 } finally {
2392 surfaceData.markDirty();
2393 }
2394 }
2395
2396 public void fillPolygon(int[] xPoints, int[] yPoints, int nPoints) {
2397 try {
2398 fillpipe.fillPolygon(this, xPoints, yPoints, nPoints);
2399 } catch (InvalidPipeException e) {
2400 try {
2401 revalidateAll();
2402 fillpipe.fillPolygon(this, xPoints, yPoints, nPoints);
2403 } catch (InvalidPipeException e2) {
2404 // Still catching the exception; we are not yet ready to
2405 // validate the surfaceData correctly. Fail for now and
2406 // try again next time around.
2407 }
2408 } finally {
2409 surfaceData.markDirty();
2410 }
2411 }
2412
2413 public void drawRect (int x, int y, int w, int h) {
2414 try {
2415 drawpipe.drawRect(this, x, y, w, h);
2416 } catch (InvalidPipeException e) {
2417 try {
2418 revalidateAll();
2419 drawpipe.drawRect(this, x, y, w, h);
2420 } catch (InvalidPipeException e2) {
2421 // Still catching the exception; we are not yet ready to
2422 // validate the surfaceData correctly. Fail for now and
2423 // try again next time around.
2424 }
2425 } finally {
2426 surfaceData.markDirty();
2427 }
2428 }
2429
2430 public void fillRect (int x, int y, int w, int h) {
2431 try {
2432 fillpipe.fillRect(this, x, y, w, h);
2433 } catch (InvalidPipeException e) {
2434 try {
2435 revalidateAll();
2436 fillpipe.fillRect(this, x, y, w, h);
2437 } catch (InvalidPipeException e2) {
2438 // Still catching the exception; we are not yet ready to
2439 // validate the surfaceData correctly. Fail for now and
2440 // try again next time around.
2441 }
2442 } finally {
2443 surfaceData.markDirty();
2444 }
2445 }
2446
2447 private void revalidateAll() {
2448 try {
2449 // REMIND: This locking needs to be done around the
2450 // caller of this method so that the pipe stays valid
2451 // long enough to call the new primitive.
2452 // REMIND: No locking yet in screen SurfaceData objects!
2453 // surfaceData.lock();
2454 surfaceData = surfaceData.getReplacement();
2455 if (surfaceData == null) {
2456 surfaceData = NullSurfaceData.theInstance;
2457 }
2458
2459 invalidatePipe();
2460
2461 // this will recalculate the composite clip
2462 setDevClip(surfaceData.getBounds());
2463
2464 if (paintState <= PAINT_ALPHACOLOR) {
2465 validateColor();
2466 }
2467 if (composite instanceof XORComposite) {
2468 Color c = ((XORComposite) composite).getXorColor();
2469 setComposite(new XORComposite(c, surfaceData));
2470 }
2471 validatePipe();
2472 } finally {
2473 // REMIND: No locking yet in screen SurfaceData objects!
2474 // surfaceData.unlock();
2475 }
2476 }
2477
2478 public void clearRect(int x, int y, int w, int h) {
2479 // REMIND: has some "interesting" consequences if threads are
2480 // not synchronized
2481 Composite c = composite;
2482 Paint p = paint;
2483 setComposite(AlphaComposite.Src);
2484 setColor(getBackground());
2485 fillRect(x, y, w, h);
2486 setPaint(p);
2487 setComposite(c);
2488 }
2489
2490 /**
2491 * Strokes the outline of a Path using the settings of the current
2492 * graphics state. The rendering attributes applied include the
2493 * clip, transform, paint or color, composite and stroke attributes.
2494 * @param s The path to be drawn.
2495 * @see #setStroke
2496 * @see #setPaint
2497 * @see java.awt.Graphics#setColor
2498 * @see #transform
2499 * @see #setTransform
2500 * @see #clip
2501 * @see #setClip
2502 * @see #setComposite
2503 */
2504 public void draw(Shape s) {
2505 try {
2506 shapepipe.draw(this, s);
2507 } catch (InvalidPipeException e) {
2508 try {
2509 revalidateAll();
2510 shapepipe.draw(this, s);
2511 } catch (InvalidPipeException e2) {
2512 // Still catching the exception; we are not yet ready to
2513 // validate the surfaceData correctly. Fail for now and
2514 // try again next time around.
2515 }
2516 } finally {
2517 surfaceData.markDirty();
2518 }
2519 }
2520
2521
2522 /**
2523 * Fills the interior of a Path using the settings of the current
2524 * graphics state. The rendering attributes applied include the
2525 * clip, transform, paint or color, and composite.
2526 * @see #setPaint
2527 * @see java.awt.Graphics#setColor
2528 * @see #transform
2529 * @see #setTransform
2530 * @see #setComposite
2531 * @see #clip
2532 * @see #setClip
2533 */
2534 public void fill(Shape s) {
2535 try {
2536 shapepipe.fill(this, s);
2537 } catch (InvalidPipeException e) {
2538 try {
2539 revalidateAll();
2540 shapepipe.fill(this, s);
2541 } catch (InvalidPipeException e2) {
2542 // Still catching the exception; we are not yet ready to
2543 // validate the surfaceData correctly. Fail for now and
2544 // try again next time around.
2545 }
2546 } finally {
2547 surfaceData.markDirty();
2548 }
2549 }
2550
2551 /**
2552 * Returns true if the given AffineTransform is an integer
2553 * translation.
2554 */
2555 private static boolean isIntegerTranslation(AffineTransform xform) {
2556 if (xform.isIdentity()) {
2557 return true;
2558 }
2559 if (xform.getType() == AffineTransform.TYPE_TRANSLATION) {
2560 double tx = xform.getTranslateX();
2561 double ty = xform.getTranslateY();
2562 return (tx == (int)tx && ty == (int)ty);
2563 }
2564 return false;
2565 }
2566
2567 /**
2568 * Returns the index of the tile corresponding to the supplied position
2569 * given the tile grid offset and size along the same axis.
2570 */
2571 private static int getTileIndex(int p, int tileGridOffset, int tileSize) {
2572 p -= tileGridOffset;
2573 if (p < 0) {
2574 p += 1 - tileSize; // force round to -infinity (ceiling)
2575 }
2576 return p/tileSize;
2577 }
2578
2579 /**
2580 * Returns a rectangle in image coordinates that may be required
2581 * in order to draw the given image into the given clipping region
2582 * through a pair of AffineTransforms. In addition, horizontal and
2583 * vertical padding factors for antialising and interpolation may
2584 * be used.
2585 */
2586 private static Rectangle getImageRegion(RenderedImage img,
2587 Region compClip,
2588 AffineTransform transform,
2589 AffineTransform xform,
2590 int padX, int padY) {
2591 Rectangle imageRect =
2592 new Rectangle(img.getMinX(), img.getMinY(),
2593 img.getWidth(), img.getHeight());
2594
2595 Rectangle result = null;
2596 try {
2597 double[] p = new double[8];
2598 p[0] = p[2] = compClip.getLoX();
2599 p[4] = p[6] = compClip.getHiX();
2600 p[1] = p[5] = compClip.getLoY();
2601 p[3] = p[7] = compClip.getHiY();
2602
2603 // Inverse transform the output bounding rect
2604 transform.inverseTransform(p, 0, p, 0, 4);
2605 xform.inverseTransform(p, 0, p, 0, 4);
2606
2607 // Determine a bounding box for the inverse transformed region
2608 double x0,x1,y0,y1;
2609 x0 = x1 = p[0];
2610 y0 = y1 = p[1];
2611
2612 for (int i = 2; i < 8; ) {
2613 double pt = p[i++];
2614 if (pt < x0) {
2615 x0 = pt;
2616 } else if (pt > x1) {
2617 x1 = pt;
2618 }
2619 pt = p[i++];
2620 if (pt < y0) {
2621 y0 = pt;
2622 } else if (pt > y1) {
2623 y1 = pt;
2624 }
2625 }
2626
2627 // This is padding for anti-aliasing and such. It may
2628 // be more than is needed.
2629 int x = (int)x0 - padX;
2630 int w = (int)(x1 - x0 + 2*padX);
2631 int y = (int)y0 - padY;
2632 int h = (int)(y1 - y0 + 2*padY);
2633
2634 Rectangle clipRect = new Rectangle(x,y,w,h);
2635 result = clipRect.intersection(imageRect);
2636 } catch (NoninvertibleTransformException nte) {
2637 // Worst case bounds are the bounds of the image.
2638 result = imageRect;
2639 }
2640
2641 return result;
2642 }
2643
2644 /**
2645 * Draws an image, applying a transform from image space into user space
2646 * before drawing.
2647 * The transformation from user space into device space is done with
2648 * the current transform in the Graphics2D.
2649 * The given transformation is applied to the image before the
2650 * transform attribute in the Graphics2D state is applied.
2651 * The rendering attributes applied include the clip, transform,
2652 * and composite attributes. Note that the result is
2653 * undefined, if the given transform is noninvertible.
2654 * @param img The image to be drawn. Does nothing if img is null.
2655 * @param xform The transformation from image space into user space.
2656 * @see #transform
2657 * @see #setTransform
2658 * @see #setComposite
2659 * @see #clip
2660 * @see #setClip
2661 */
2662 public void drawRenderedImage(RenderedImage img,
2663 AffineTransform xform) {
2664
2665 if (img == null) {
2666 return;
2667 }
2668
2669 // BufferedImage case: use a simple drawImage call
2670 if (img instanceof BufferedImage) {
2671 BufferedImage bufImg = (BufferedImage)img;
2672 drawImage(bufImg,xform,null);
2673 return;
2674 }
2675
2676 // transformState tracks the state of transform and
2677 // transX, transY contain the integer casts of the
2678 // translation factors
2679 boolean isIntegerTranslate =
2680 (transformState <= TRANSFORM_INT_TRANSLATE) &&
2681 isIntegerTranslation(xform);
2682
2683 // Include padding for interpolation/antialiasing if necessary
2684 int pad = isIntegerTranslate ? 0 : 3;
2685
2686 Region clip;
2687 try {
2688 clip = getCompClip();
2689 } catch (InvalidPipeException e) {
2690 return;
2691 }
2692
2693 // Determine the region of the image that may contribute to
2694 // the clipped drawing area
2695 Rectangle region = getImageRegion(img,
2696 clip,
2697 transform,
2698 xform,
2699 pad, pad);
2700 if (region.width <= 0 || region.height <= 0) {
2701 return;
2702 }
2703
2704 // Attempt to optimize integer translation of tiled images.
2705 // Although theoretically we are O.K. if the concatenation of
2706 // the user transform and the device transform is an integer
2707 // translation, we'll play it safe and only optimize the case
2708 // where both are integer translations.
2709 if (isIntegerTranslate) {
2710 // Use optimized code
2711 // Note that drawTranslatedRenderedImage calls copyImage
2712 // which takes the user space to device space transform into
2713 // account, but we need to provide the image space to user space
2714 // translations.
2715
2716 drawTranslatedRenderedImage(img, region,
2717 (int) xform.getTranslateX(),
2718 (int) xform.getTranslateY());
2719 return;
2720 }
2721
2722 // General case: cobble the necessary region into a single Raster
2723 Raster raster = img.getData(region);
2724
2725 // Make a new Raster with the same contents as raster
2726 // but starting at (0, 0). This raster is thus in the same
2727 // coordinate system as the SampleModel of the original raster.
2728 WritableRaster wRaster =
2729 Raster.createWritableRaster(raster.getSampleModel(),
2730 raster.getDataBuffer(),
2731 null);
2732
2733 // If the original raster was in a different coordinate
2734 // system than its SampleModel, we need to perform an
2735 // additional translation in order to get the (minX, minY)
2736 // pixel of raster to be pixel (0, 0) of wRaster. We also
2737 // have to have the correct width and height.
2738 int minX = raster.getMinX();
2739 int minY = raster.getMinY();
2740 int width = raster.getWidth();
2741 int height = raster.getHeight();
2742 int px = minX - raster.getSampleModelTranslateX();
2743 int py = minY - raster.getSampleModelTranslateY();
2744 if (px != 0 || py != 0 || width != wRaster.getWidth() ||
2745 height != wRaster.getHeight()) {
2746 wRaster =
2747 wRaster.createWritableChild(px,
2748 py,
2749 width,
2750 height,
2751 0, 0,
2752 null);
2753 }
2754
2755 // Now we have a BufferedImage starting at (0, 0)
2756 // with the same contents that started at (minX, minY)
2757 // in raster. So we must draw the BufferedImage with a
2758 // translation of (minX, minY).
2759 AffineTransform transXform = (AffineTransform)xform.clone();
2760 transXform.translate(minX, minY);
2761
2762 ColorModel cm = img.getColorModel();
2763 BufferedImage bufImg = new BufferedImage(cm,
2764 wRaster,
2765 cm.isAlphaPremultiplied(),
2766 null);
2767 drawImage(bufImg, transXform, null);
2768 }
2769
2770 /**
2771 * Intersects {@code destRect} with {@code clip} and
2772 * overwrites {@code destRect} with the result.
2773 * Returns false if the intersection was empty, true otherwise.
2774 */
2775 private boolean clipTo(Rectangle destRect, Rectangle clip) {
2776 int x1 = Math.max(destRect.x, clip.x);
2777 int x2 = Math.min(destRect.x + destRect.width, clip.x + clip.width);
2778 int y1 = Math.max(destRect.y, clip.y);
2779 int y2 = Math.min(destRect.y + destRect.height, clip.y + clip.height);
2780 if (((x2 - x1) < 0) || ((y2 - y1) < 0)) {
2781 destRect.width = -1; // Set both just to be safe
2782 destRect.height = -1;
2783 return false;
2784 } else {
2785 destRect.x = x1;
2786 destRect.y = y1;
2787 destRect.width = x2 - x1;
2788 destRect.height = y2 - y1;
2789 return true;
2790 }
2791 }
2792
2793 /**
2794 * Draw a portion of a RenderedImage tile-by-tile with a given
2795 * integer image to user space translation. The user to
2796 * device transform must also be an integer translation.
2797 */
2798 private void drawTranslatedRenderedImage(RenderedImage img,
2799 Rectangle region,
2800 int i2uTransX,
2801 int i2uTransY) {
2802 // Cache tile grid info
2803 int tileGridXOffset = img.getTileGridXOffset();
2804 int tileGridYOffset = img.getTileGridYOffset();
2805 int tileWidth = img.getTileWidth();
2806 int tileHeight = img.getTileHeight();
2807
2808 // Determine the tile index extrema in each direction
2809 int minTileX =
2810 getTileIndex(region.x, tileGridXOffset, tileWidth);
2811 int minTileY =
2812 getTileIndex(region.y, tileGridYOffset, tileHeight);
2813 int maxTileX =
2814 getTileIndex(region.x + region.width - 1,
2815 tileGridXOffset, tileWidth);
2816 int maxTileY =
2817 getTileIndex(region.y + region.height - 1,
2818 tileGridYOffset, tileHeight);
2819
2820 // Create a single ColorModel to use for all BufferedImages
2821 ColorModel colorModel = img.getColorModel();
2822
2823 // Reuse the same Rectangle for each iteration
2824 Rectangle tileRect = new Rectangle();
2825
2826 for (int ty = minTileY; ty <= maxTileY; ty++) {
2827 for (int tx = minTileX; tx <= maxTileX; tx++) {
2828 // Get the current tile.
2829 Raster raster = img.getTile(tx, ty);
2830
2831 // Fill in tileRect with the tile bounds
2832 tileRect.x = tx*tileWidth + tileGridXOffset;
2833 tileRect.y = ty*tileHeight + tileGridYOffset;
2834 tileRect.width = tileWidth;
2835 tileRect.height = tileHeight;
2836
2837 // Clip the tile against the image bounds and
2838 // backwards mapped clip region
2839 // The result can't be empty
2840 clipTo(tileRect, region);
2841
2842 // Create a WritableRaster containing the tile
2843 WritableRaster wRaster = null;
2844 if (raster instanceof WritableRaster) {
2845 wRaster = (WritableRaster)raster;
2846 } else {
2847 // Create a WritableRaster in the same coordinate system
2848 // as the original raster.
2849 wRaster =
2850 Raster.createWritableRaster(raster.getSampleModel(),
2851 raster.getDataBuffer(),
2852 null);
2853 }
2854
2855 // Translate wRaster to start at (0, 0) and to contain
2856 // only the relevent portion of the tile
2857 wRaster = wRaster.createWritableChild(tileRect.x, tileRect.y,
2858 tileRect.width,
2859 tileRect.height,
2860 0, 0,
2861 null);
2862
2863 // Wrap wRaster in a BufferedImage
2864 BufferedImage bufImg =
2865 new BufferedImage(colorModel,
2866 wRaster,
2867 colorModel.isAlphaPremultiplied(),
2868 null);
2869 // Now we have a BufferedImage starting at (0, 0) that
2870 // represents data from a Raster starting at
2871 // (tileRect.x, tileRect.y). Additionally, it needs
2872 // to be translated by (i2uTransX, i2uTransY). We call
2873 // copyImage to draw just the region of interest
2874 // without needing to create a child image.
2875 copyImage(bufImg, tileRect.x + i2uTransX,
2876 tileRect.y + i2uTransY, 0, 0, tileRect.width,
2877 tileRect.height, null, null);
2878 }
2879 }
2880 }
2881
2882 public void drawRenderableImage(RenderableImage img,
2883 AffineTransform xform) {
2884
2885 if (img == null) {
2886 return;
2887 }
2888
2889 AffineTransform pipeTransform = transform;
2890 AffineTransform concatTransform = new AffineTransform(xform);
2891 concatTransform.concatenate(pipeTransform);
2892 AffineTransform reverseTransform;
2893
2894 RenderContext rc = new RenderContext(concatTransform);
2895
2896 try {
2897 reverseTransform = pipeTransform.createInverse();
2898 } catch (NoninvertibleTransformException nte) {
2899 rc = new RenderContext(pipeTransform);
2900 reverseTransform = new AffineTransform();
2901 }
2902
2903 RenderedImage rendering = img.createRendering(rc);
2904 drawRenderedImage(rendering,reverseTransform);
2905 }
2906
2907
2908
2909 /*
2910 * Transform the bounding box of the BufferedImage
2911 */
2912 protected Rectangle transformBounds(Rectangle rect,
2913 AffineTransform tx) {
2914 if (tx.isIdentity()) {
2915 return rect;
2916 }
2917
2918 Shape s = transformShape(tx, rect);
2919 return s.getBounds();
2920 }
2921
2922 // text rendering methods
2923 public void drawString(String str, int x, int y) {
2924 if (str == null) {
2925 throw new NullPointerException("String is null");
2926 }
2927
2928 if (font.hasLayoutAttributes()) {
2929 if (str.length() == 0) {
2930 return;
2931 }
2932 new TextLayout(str, font, getFontRenderContext()).draw(this, x, y);
2933 return;
2934 }
2935
2936 try {
2937 textpipe.drawString(this, str, x, y);
2938 } catch (InvalidPipeException e) {
2939 try {
2940 revalidateAll();
2941 textpipe.drawString(this, str, x, y);
2942 } catch (InvalidPipeException e2) {
2943 // Still catching the exception; we are not yet ready to
2944 // validate the surfaceData correctly. Fail for now and
2945 // try again next time around.
2946 }
2947 } finally {
2948 surfaceData.markDirty();
2949 }
2950 }
2951
2952 public void drawString(String str, float x, float y) {
2953 if (str == null) {
2954 throw new NullPointerException("String is null");
2955 }
2956
2957 if (font.hasLayoutAttributes()) {
2958 if (str.length() == 0) {
2959 return;
2960 }
2961 new TextLayout(str, font, getFontRenderContext()).draw(this, x, y);
2962 return;
2963 }
2964
2965 try {
2966 textpipe.drawString(this, str, x, y);
2967 } catch (InvalidPipeException e) {
2968 try {
2969 revalidateAll();
2970 textpipe.drawString(this, str, x, y);
2971 } catch (InvalidPipeException e2) {
2972 // Still catching the exception; we are not yet ready to
2973 // validate the surfaceData correctly. Fail for now and
2974 // try again next time around.
2975 }
2976 } finally {
2977 surfaceData.markDirty();
2978 }
2979 }
2980
2981 public void drawString(AttributedCharacterIterator iterator,
2982 int x, int y) {
2983 if (iterator == null) {
2984 throw new NullPointerException("AttributedCharacterIterator is null");
2985 }
2986 if (iterator.getBeginIndex() == iterator.getEndIndex()) {
2987 return; /* nothing to draw */
2988 }
2989 TextLayout tl = new TextLayout(iterator, getFontRenderContext());
2990 tl.draw(this, (float) x, (float) y);
2991 }
2992
2993 public void drawString(AttributedCharacterIterator iterator,
2994 float x, float y) {
2995 if (iterator == null) {
2996 throw new NullPointerException("AttributedCharacterIterator is null");
2997 }
2998 if (iterator.getBeginIndex() == iterator.getEndIndex()) {
2999 return; /* nothing to draw */
3000 }
3001 TextLayout tl = new TextLayout(iterator, getFontRenderContext());
3002 tl.draw(this, x, y);
3003 }
3004
3005 public void drawGlyphVector(GlyphVector gv, float x, float y)
3006 {
3007 if (gv == null) {
3008 throw new NullPointerException("GlyphVector is null");
3009 }
3010
3011 try {
3012 textpipe.drawGlyphVector(this, gv, x, y);
3013 } catch (InvalidPipeException e) {
3014 try {
3015 revalidateAll();
3016 textpipe.drawGlyphVector(this, gv, x, y);
3017 } catch (InvalidPipeException e2) {
3018 // Still catching the exception; we are not yet ready to
3019 // validate the surfaceData correctly. Fail for now and
3020 // try again next time around.
3021 }
3022 } finally {
3023 surfaceData.markDirty();
3024 }
3025 }
3026
3027 public void drawChars(char[] data, int offset, int length, int x, int y) {
3028
3029 if (data == null) {
3030 throw new NullPointerException("char data is null");
3031 }
3032 if (offset < 0 || length < 0 || offset + length < length ||
3033 offset + length > data.length) {
3034 throw new ArrayIndexOutOfBoundsException("bad offset/length");
3035 }
3036 if (font.hasLayoutAttributes()) {
3037 if (data.length == 0) {
3038 return;
3039 }
3040 new TextLayout(new String(data, offset, length),
3041 font, getFontRenderContext()).draw(this, x, y);
3042 return;
3043 }
3044
3045 try {
3046 textpipe.drawChars(this, data, offset, length, x, y);
3047 } catch (InvalidPipeException e) {
3048 try {
3049 revalidateAll();
3050 textpipe.drawChars(this, data, offset, length, x, y);
3051 } catch (InvalidPipeException e2) {
3052 // Still catching the exception; we are not yet ready to
3053 // validate the surfaceData correctly. Fail for now and
3054 // try again next time around.
3055 }
3056 } finally {
3057 surfaceData.markDirty();
3058 }
3059 }
3060
3061 public void drawBytes(byte[] data, int offset, int length, int x, int y) {
3062 if (data == null) {
3063 throw new NullPointerException("byte data is null");
3064 }
3065 if (offset < 0 || length < 0 || offset + length < length ||
3066 offset + length > data.length) {
3067 throw new ArrayIndexOutOfBoundsException("bad offset/length");
3068 }
3069 /* Byte data is interpreted as 8-bit ASCII. Re-use drawChars loops */
3070 char[] chData = new char[length];
3071 for (int i = length; i-- > 0; ) {
3072 chData[i] = (char)(data[i+offset] & 0xff);
3073 }
3074 if (font.hasLayoutAttributes()) {
3075 if (data.length == 0) {
3076 return;
3077 }
3078 new TextLayout(new String(chData),
3079 font, getFontRenderContext()).draw(this, x, y);
3080 return;
3081 }
3082
3083 try {
3084 textpipe.drawChars(this, chData, 0, length, x, y);
3085 } catch (InvalidPipeException e) {
3086 try {
3087 revalidateAll();
3088 textpipe.drawChars(this, chData, 0, length, x, y);
3089 } catch (InvalidPipeException e2) {
3090 // Still catching the exception; we are not yet ready to
3091 // validate the surfaceData correctly. Fail for now and
3092 // try again next time around.
3093 }
3094 } finally {
3095 surfaceData.markDirty();
3096 }
3097 }
3098 // end of text rendering methods
3099
3100 private Boolean drawHiDPIImage(Image img,
3101 int dx1, int dy1, int dx2, int dy2,
3102 int sx1, int sy1, int sx2, int sy2,
3103 Color bgcolor, ImageObserver observer,
3104 AffineTransform xform) {
3105
3106 if (img instanceof VolatileImage) {
3107 final SurfaceData sd = SurfaceManager.getManager(img)
3108 .getPrimarySurfaceData();
3109 final double scaleX = sd.getDefaultScaleX();
3110 final double scaleY = sd.getDefaultScaleY();
3111 if (scaleX == 1 && scaleY == 1) {
3112 return null;
3113 }
3114 sx1 = Region.clipRound(sx1 * scaleX);
3115 sx2 = Region.clipRound(sx2 * scaleX);
3116 sy1 = Region.clipRound(sy1 * scaleY);
3117 sy2 = Region.clipRound(sy2 * scaleY);
3118
3119 AffineTransform tx = null;
3120 if (xform != null) {
3121 tx = new AffineTransform(transform);
3122 transform(xform);
3123 }
3124 boolean result = scaleImage(img, dx1, dy1, dx2, dy2,
3125 sx1, sy1, sx2, sy2,
3126 bgcolor, observer);
3127 if (tx != null) {
3128 transform.setTransform(tx);
3129 invalidateTransform();
3130 }
3131 return result;
3132 } else if (img instanceof MultiResolutionImage) {
3133 // get scaled destination image size
3134
3135 int width = img.getWidth(observer);
3136 int height = img.getHeight(observer);
3137
3138 MultiResolutionImage mrImage = (MultiResolutionImage) img;
3139 Image resolutionVariant = getResolutionVariant(mrImage, width, height,
3140 dx1, dy1, dx2, dy2,
3141 sx1, sy1, sx2, sy2,
3142 xform);
3143
3144 if (resolutionVariant != img && resolutionVariant != null) {
3145 // recalculate source region for the resolution variant
3146
3147 ImageObserver rvObserver = MultiResolutionToolkitImage.
3148 getResolutionVariantObserver(img, observer,
3149 width, height, -1, -1);
3150
3151 int rvWidth = resolutionVariant.getWidth(rvObserver);
3152 int rvHeight = resolutionVariant.getHeight(rvObserver);
3153
3154 if (rvWidth < 0 || rvHeight < 0) {
3155 // The resolution variant is not loaded yet, try to use default resolution
3156 resolutionVariant = mrImage.getResolutionVariant(width, height);
3157 rvWidth = resolutionVariant.getWidth(rvObserver);
3158 rvHeight = resolutionVariant.getHeight(rvObserver);
3159 }
3160
3161 if (0 < width && 0 < height && 0 < rvWidth && 0 < rvHeight) {
3162
3163 double widthScale = ((double) rvWidth) / width;
3164 double heightScale = ((double) rvHeight) / height;
3165
3166 if (resolutionVariant instanceof VolatileImage) {
3167 SurfaceData sd = SurfaceManager
3168 .getManager(resolutionVariant)
3169 .getPrimarySurfaceData();
3170 widthScale *= sd.getDefaultScaleX();
3171 heightScale *= sd.getDefaultScaleY();
3172 }
3173
3174 sx1 = Region.clipScale(sx1, widthScale);
3175 sy1 = Region.clipScale(sy1, heightScale);
3176 sx2 = Region.clipScale(sx2, widthScale);
3177 sy2 = Region.clipScale(sy2, heightScale);
3178
3179 observer = rvObserver;
3180 img = resolutionVariant;
3181
3182 if (xform != null) {
3183 assert dx1 == 0 && dy1 == 0;
3184 assert dx2 == img.getWidth(observer);
3185 assert dy2 == img.getHeight(observer);
3186 AffineTransform renderTX = new AffineTransform(xform);
3187 renderTX.scale(1 / widthScale, 1 / heightScale);
3188 return transformImage(img, renderTX, observer);
3189 }
3190
3191 return scaleImage(img, dx1, dy1, dx2, dy2,
3192 sx1, sy1, sx2, sy2,
3193 bgcolor, observer);
3194 } else {
3195 return false; // Image variant is not initialized yet
3196 }
3197 }
3198 }
3199 return null;
3200 }
3201
3202 private boolean scaleImage(Image img, int dx1, int dy1, int dx2, int dy2,
3203 int sx1, int sy1, int sx2, int sy2,
3204 Color bgcolor, ImageObserver observer)
3205 {
3206 try {
3207 return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2, sx1, sy1,
3208 sx2, sy2, bgcolor, observer);
3209 } catch (InvalidPipeException e) {
3210 try {
3211 revalidateAll();
3212 return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2, sx1,
3213 sy1, sx2, sy2, bgcolor, observer);
3214 } catch (InvalidPipeException e2) {
3215 // Still catching the exception; we are not yet ready to
3216 // validate the surfaceData correctly. Fail for now and
3217 // try again next time around.
3218 return false;
3219 }
3220 } finally {
3221 surfaceData.markDirty();
3222 }
3223 }
3224
3225 private boolean transformImage(Image img,
3226 AffineTransform xform,
3227 ImageObserver observer)
3228 {
3229 try {
3230 return imagepipe.transformImage(this, img, xform, observer);
3231 } catch (InvalidPipeException e) {
3232 try {
3233 revalidateAll();
3234 return imagepipe.transformImage(this, img, xform, observer);
3235 } catch (InvalidPipeException e2) {
3236 // Still catching the exception; we are not yet ready to
3237 // validate the surfaceData correctly. Fail for now and
3238 // try again next time around.
3239 return false;
3240 }
3241 } finally {
3242 surfaceData.markDirty();
3243 }
3244 }
3245
3246 private Image getResolutionVariant(MultiResolutionImage img,
3247 int srcWidth, int srcHeight, int dx1, int dy1, int dx2, int dy2,
3248 int sx1, int sy1, int sx2, int sy2, AffineTransform xform) {
3249
3250 if (srcWidth <= 0 || srcHeight <= 0) {
3251 return null;
3252 }
3253
3254 int sw = sx2 - sx1;
3255 int sh = sy2 - sy1;
3256
3257 if (sw == 0 || sh == 0) {
3258 return null;
3259 }
3260
3261 AffineTransform tx;
3262
3263 if (xform == null) {
3264 tx = transform;
3265 } else {
3266 tx = new AffineTransform(transform);
3267 tx.concatenate(xform);
3268 }
3269
3270 int type = tx.getType();
3271 int dw = dx2 - dx1;
3272 int dh = dy2 - dy1;
3273
3274 double destImageWidth;
3275 double destImageHeight;
3276
3277 if (resolutionVariantHint == SunHints.INTVAL_RESOLUTION_VARIANT_BASE) {
3278 destImageWidth = srcWidth;
3279 destImageHeight = srcHeight;
3280 } else if (resolutionVariantHint == SunHints.INTVAL_RESOLUTION_VARIANT_DPI_FIT) {
3281 AffineTransform configTransform = getDefaultTransform();
3282 if (configTransform.isIdentity()) {
3283 destImageWidth = srcWidth;
3284 destImageHeight = srcHeight;
3285 } else {
3286 destImageWidth = srcWidth * configTransform.getScaleX();
3287 destImageHeight = srcHeight * configTransform.getScaleY();
3288 }
3289 } else {
3290 double destRegionWidth;
3291 double destRegionHeight;
3292
3293 if ((type & ~(TYPE_TRANSLATION | TYPE_FLIP)) == 0) {
3294 destRegionWidth = dw;
3295 destRegionHeight = dh;
3296 } else if ((type & ~(TYPE_TRANSLATION | TYPE_FLIP | TYPE_MASK_SCALE)) == 0) {
3297 destRegionWidth = dw * tx.getScaleX();
3298 destRegionHeight = dh * tx.getScaleY();
3299 } else {
3300 destRegionWidth = dw * Math.hypot(
3301 tx.getScaleX(), tx.getShearY());
3302 destRegionHeight = dh * Math.hypot(
3303 tx.getShearX(), tx.getScaleY());
3304 }
3305 destImageWidth = Math.abs(srcWidth * destRegionWidth / sw);
3306 destImageHeight = Math.abs(srcHeight * destRegionHeight / sh);
3307 }
3308
3309 Image resolutionVariant
3310 = img.getResolutionVariant(destImageWidth, destImageHeight);
3311
3312 if (resolutionVariant instanceof ToolkitImage
3313 && ((ToolkitImage) resolutionVariant).hasError()) {
3314 return null;
3315 }
3316
3317 return resolutionVariant;
3318 }
3319
3320 /**
3321 * Draws an image scaled to x,y,w,h in nonblocking mode with a
3322 * callback object.
3323 */
3324 public boolean drawImage(Image img, int x, int y, int width, int height,
3325 ImageObserver observer) {
3326 return drawImage(img, x, y, width, height, null, observer);
3327 }
3328
3329 /**
3330 * Not part of the advertised API but a useful utility method
3331 * to call internally. This is for the case where we are
3332 * drawing to/from given coordinates using a given width/height,
3333 * but we guarantee that the surfaceData's width/height of the src and dest
3334 * areas are equal (no scale needed). Note that this method intentionally
3335 * ignore scale factor of the source image, and copy it as is.
3336 */
3337 public boolean copyImage(Image img, int dx, int dy, int sx, int sy,
3338 int width, int height, Color bgcolor,
3339 ImageObserver observer) {
3340 try {
3341 return imagepipe.copyImage(this, img, dx, dy, sx, sy,
3342 width, height, bgcolor, observer);
3343 } catch (InvalidPipeException e) {
3344 try {
3345 revalidateAll();
3346 return imagepipe.copyImage(this, img, dx, dy, sx, sy,
3347 width, height, bgcolor, observer);
3348 } catch (InvalidPipeException e2) {
3349 // Still catching the exception; we are not yet ready to
3350 // validate the surfaceData correctly. Fail for now and
3351 // try again next time around.
3352 return false;
3353 }
3354 } finally {
3355 surfaceData.markDirty();
3356 }
3357 }
3358
3359 /**
3360 * Draws an image scaled to x,y,w,h in nonblocking mode with a
3361 * solid background color and a callback object.
3362 */
3363 public boolean drawImage(Image img, int x, int y, int width, int height,
3364 Color bg, ImageObserver observer) {
3365
3366 if (img == null) {
3367 return true;
3368 }
3369
3370 if ((width == 0) || (height == 0)) {
3371 return true;
3372 }
3373
3374 final int imgW = img.getWidth(null);
3375 final int imgH = img.getHeight(null);
3376 Boolean hidpiImageDrawn = drawHiDPIImage(img, x, y, x + width, y + height,
3377 0, 0, imgW, imgH, bg, observer,
3378 null);
3379 if (hidpiImageDrawn != null) {
3380 return hidpiImageDrawn;
3381 }
3382
3383 if (width == imgW && height == imgH) {
3384 return copyImage(img, x, y, 0, 0, width, height, bg, observer);
3385 }
3386
3387 try {
3388 return imagepipe.scaleImage(this, img, x, y, width, height,
3389 bg, observer);
3390 } catch (InvalidPipeException e) {
3391 try {
3392 revalidateAll();
3393 return imagepipe.scaleImage(this, img, x, y, width, height,
3394 bg, observer);
3395 } catch (InvalidPipeException e2) {
3396 // Still catching the exception; we are not yet ready to
3397 // validate the surfaceData correctly. Fail for now and
3398 // try again next time around.
3399 return false;
3400 }
3401 } finally {
3402 surfaceData.markDirty();
3403 }
3404 }
3405
3406 /**
3407 * Draws an image at x,y in nonblocking mode.
3408 */
3409 public boolean drawImage(Image img, int x, int y, ImageObserver observer) {
3410 return drawImage(img, x, y, null, observer);
3411 }
3412
3413 /**
3414 * Draws an image at x,y in nonblocking mode with a solid background
3415 * color and a callback object.
3416 */
3417 public boolean drawImage(Image img, int x, int y, Color bg,
3418 ImageObserver observer) {
3419
3420 if (img == null) {
3421 return true;
3422 }
3423
3424 final int imgW = img.getWidth(null);
3425 final int imgH = img.getHeight(null);
3426 Boolean hidpiImageDrawn = drawHiDPIImage(img, x, y, x + imgW, y + imgH,
3427 0, 0, imgW, imgH, bg, observer,
3428 null);
3429 if (hidpiImageDrawn != null) {
3430 return hidpiImageDrawn;
3431 }
3432
3433 try {
3434 return imagepipe.copyImage(this, img, x, y, bg, observer);
3435 } catch (InvalidPipeException e) {
3436 try {
3437 revalidateAll();
3438 return imagepipe.copyImage(this, img, x, y, bg, observer);
3439 } catch (InvalidPipeException e2) {
3440 // Still catching the exception; we are not yet ready to
3441 // validate the surfaceData correctly. Fail for now and
3442 // try again next time around.
3443 return false;
3444 }
3445 } finally {
3446 surfaceData.markDirty();
3447 }
3448 }
3449
3450 /**
3451 * Draws a subrectangle of an image scaled to a destination rectangle
3452 * in nonblocking mode with a callback object.
3453 */
3454 public boolean drawImage(Image img,
3455 int dx1, int dy1, int dx2, int dy2,
3456 int sx1, int sy1, int sx2, int sy2,
3457 ImageObserver observer) {
3458 return drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, null,
3459 observer);
3460 }
3461
3462 /**
3463 * Draws a subrectangle of an image scaled to a destination rectangle in
3464 * nonblocking mode with a solid background color and a callback object.
3465 */
3466 public boolean drawImage(Image img,
3467 int dx1, int dy1, int dx2, int dy2,
3468 int sx1, int sy1, int sx2, int sy2,
3469 Color bgcolor, ImageObserver observer) {
3470
3471 if (img == null) {
3472 return true;
3473 }
3474
3475 if (dx1 == dx2 || dy1 == dy2 ||
3476 sx1 == sx2 || sy1 == sy2)
3477 {
3478 return true;
3479 }
3480
3481 Boolean hidpiImageDrawn = drawHiDPIImage(img, dx1, dy1, dx2, dy2,
3482 sx1, sy1, sx2, sy2,
3483 bgcolor, observer, null);
3484
3485 if (hidpiImageDrawn != null) {
3486 return hidpiImageDrawn;
3487 }
3488
3489 if (((sx2 - sx1) == (dx2 - dx1)) &&
3490 ((sy2 - sy1) == (dy2 - dy1)))
3491 {
3492 // Not a scale - forward it to a copy routine
3493 int srcX, srcY, dstX, dstY, width, height;
3494 if (sx2 > sx1) {
3495 width = sx2 - sx1;
3496 srcX = sx1;
3497 dstX = dx1;
3498 } else {
3499 width = sx1 - sx2;
3500 srcX = sx2;
3501 dstX = dx2;
3502 }
3503 if (sy2 > sy1) {
3504 height = sy2-sy1;
3505 srcY = sy1;
3506 dstY = dy1;
3507 } else {
3508 height = sy1-sy2;
3509 srcY = sy2;
3510 dstY = dy2;
3511 }
3512 return copyImage(img, dstX, dstY, srcX, srcY,
3513 width, height, bgcolor, observer);
3514 }
3515
3516 try {
3517 return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2,
3518 sx1, sy1, sx2, sy2, bgcolor,
3519 observer);
3520 } catch (InvalidPipeException e) {
3521 try {
3522 revalidateAll();
3523 return imagepipe.scaleImage(this, img, dx1, dy1, dx2, dy2,
3524 sx1, sy1, sx2, sy2, bgcolor,
3525 observer);
3526 } catch (InvalidPipeException e2) {
3527 // Still catching the exception; we are not yet ready to
3528 // validate the surfaceData correctly. Fail for now and
3529 // try again next time around.
3530 return false;
3531 }
3532 } finally {
3533 surfaceData.markDirty();
3534 }
3535 }
3536
3537 /**
3538 * Draw an image, applying a transform from image space into user space
3539 * before drawing.
3540 * The transformation from user space into device space is done with
3541 * the current transform in the Graphics2D.
3542 * The given transformation is applied to the image before the
3543 * transform attribute in the Graphics2D state is applied.
3544 * The rendering attributes applied include the clip, transform,
3545 * paint or color and composite attributes. Note that the result is
3546 * undefined, if the given transform is non-invertible.
3547 * @param img The image to be drawn.
3548 * @param xform The transformation from image space into user space.
3549 * @param observer The image observer to be notified on the image producing
3550 * progress.
3551 * @see #transform
3552 * @see #setComposite
3553 * @see #setClip
3554 */
3555 public boolean drawImage(Image img,
3556 AffineTransform xform,
3557 ImageObserver observer) {
3558
3559 if (img == null) {
3560 return true;
3561 }
3562
3563 if (xform == null || xform.isIdentity()) {
3564 return drawImage(img, 0, 0, null, observer);
3565 }
3566
3567 final int w = img.getWidth(null);
3568 final int h = img.getHeight(null);
3569 Boolean hidpiImageDrawn = drawHiDPIImage(img, 0, 0, w, h, 0, 0, w, h,
3570 null, observer, xform);
3571
3572 if (hidpiImageDrawn != null) {
3573 return hidpiImageDrawn;
3574 }
3575
3576 return transformImage(img, xform, observer);
3577 }
3578
3579 public void drawImage(BufferedImage bImg,
3580 BufferedImageOp op,
3581 int x,
3582 int y) {
3583
3584 if (bImg == null) {
3585 return;
3586 }
3587
3588 try {
3589 imagepipe.transformImage(this, bImg, op, x, y);
3590 } catch (InvalidPipeException e) {
3591 try {
3592 revalidateAll();
3593 imagepipe.transformImage(this, bImg, op, x, y);
3594 } catch (InvalidPipeException e2) {
3595 // Still catching the exception; we are not yet ready to
3596 // validate the surfaceData correctly. Fail for now and
3597 // try again next time around.
3598 }
3599 } finally {
3600 surfaceData.markDirty();
3601 }
3602 }
3603
3604 /**
3605 * Get the rendering context of the font
3606 * within this Graphics2D context.
3607 */
3608 public FontRenderContext getFontRenderContext() {
3609 if (cachedFRC == null) {
3610 int aahint = textAntialiasHint;
3611 if (aahint == SunHints.INTVAL_TEXT_ANTIALIAS_DEFAULT &&
3612 antialiasHint == SunHints.INTVAL_ANTIALIAS_ON) {
3613 aahint = SunHints.INTVAL_TEXT_ANTIALIAS_ON;
3614 }
3615 // Translation components should be excluded from the FRC transform
3616 AffineTransform tx = null;
3617 if (transformState >= TRANSFORM_TRANSLATESCALE) {
3618 if (transform.getTranslateX() == 0 &&
3619 transform.getTranslateY() == 0) {
3620 tx = transform;
3621 } else {
3622 tx = new AffineTransform(transform.getScaleX(),
3623 transform.getShearY(),
3624 transform.getShearX(),
3625 transform.getScaleY(),
3626 0, 0);
3627 }
3628 }
3629 cachedFRC = new FontRenderContext(tx,
3630 SunHints.Value.get(SunHints.INTKEY_TEXT_ANTIALIASING, aahint),
3631 SunHints.Value.get(SunHints.INTKEY_FRACTIONALMETRICS,
3632 fractionalMetricsHint));
3633 }
3634 return cachedFRC;
3635 }
3636 private FontRenderContext cachedFRC;
3637
3638 /**
3639 * This object has no resources to dispose of per se, but the
3640 * doc comments for the base method in java.awt.Graphics imply
3641 * that this object will not be useable after it is disposed.
3642 * So, we sabotage the object to prevent further use to prevent
3643 * developers from relying on behavior that may not work on
3644 * other, less forgiving, VMs that really need to dispose of
3645 * resources.
3646 */
3647 public void dispose() {
3648 surfaceData = NullSurfaceData.theInstance;
3649 invalidatePipe();
3650 }
3651
3652 /**
3653 * Graphics has a finalize method that automatically calls dispose()
3654 * for subclasses. For SunGraphics2D we do not need to be finalized
3655 * so that method simply causes us to be enqueued on the Finalizer
3656 * queues for no good reason. Unfortunately, that method and
3657 * implementation are now considered part of the public contract
3658 * of that base class so we can not remove or gut the method.
3659 * We override it here with an empty method and the VM is smart
3660 * enough to know that if our override is empty then it should not
3661 * mark us as finalizeable.
3662 */
3663 @SuppressWarnings("deprecation")
3664 public void finalize() {
3665 // DO NOT REMOVE THIS METHOD
3666 }
3667
3668 /**
3669 * Returns destination that this Graphics renders to. This could be
3670 * either an Image or a Component; subclasses of SurfaceData are
3671 * responsible for returning the appropriate object.
3672 */
3673 public Object getDestination() {
3674 return surfaceData.getDestination();
3675 }
3676
3677 /**
3678 * {@inheritDoc}
3679 *
3680 * @see sun.java2d.DestSurfaceProvider#getDestSurface
3681 */
3682 @Override
3683 public Surface getDestSurface() {
3684 return surfaceData;
3685 }
3686 }