History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/sun/print/ProxyGraphics2D.java (1 of 18352 files). Show all

Unified · Split

java/pkg/sun/print/ProxyGraphics2D.java+1622−0
@@ -0,0 +1,1622 @@
1+/*
2+ * Copyright (c) 1998, 2006, 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.print;
27+
28+import java.util.Map;
29+
30+import java.awt.Color;
31+import java.awt.Composite;
32+import java.awt.Graphics;
33+import java.awt.Graphics2D;
34+import java.awt.Font;
35+import java.awt.FontMetrics;
36+import java.awt.font.FontRenderContext;
37+import java.awt.Graphics;
38+import java.awt.GraphicsConfiguration;
39+import java.awt.Image;
40+import java.awt.Paint;
41+import java.awt.Rectangle;
42+import java.awt.Shape;
43+import java.awt.Stroke;
44+import java.awt.RenderingHints;
45+import java.awt.RenderingHints.Key;
46+
47+import java.awt.font.GlyphVector;
48+
49+import java.awt.geom.AffineTransform;
50+import java.awt.geom.Rectangle2D;
51+import java.awt.geom.NoninvertibleTransformException;
52+import java.awt.image.BufferedImage;
53+import java.awt.image.BufferedImageOp;
54+import java.awt.image.ImageObserver;
55+import java.awt.image.RenderedImage;
56+import java.awt.image.renderable.RenderContext;
57+import java.awt.image.renderable.RenderableImage;
58+import java.awt.print.PrinterGraphics;
59+import java.awt.print.PrinterJob;
60+
61+import java.text.AttributedCharacterIterator;
62+
63+public class ProxyGraphics2D extends Graphics2D implements PrinterGraphics {
64+
65+ /**
66+ * Drawing methods will be forwarded to this object.
67+ */
68+ Graphics2D mGraphics;
69+
70+ /**
71+ * The PrinterJob controlling the current printing.
72+ */
73+ PrinterJob mPrinterJob;
74+
75+ /**
76+ * The new ProxyGraphics2D will forward all graphics
77+ * calls to 'graphics'.
78+ */
79+ public ProxyGraphics2D(Graphics2D graphics, PrinterJob printerJob) {
80+ mGraphics = graphics;
81+ mPrinterJob = printerJob;
82+ }
83+
84+ /**
85+ * Return the Graphics2D object that does the drawing
86+ * for this instance.
87+ */
88+ public Graphics2D getDelegate() {
89+ return mGraphics;
90+ }
91+
92+ /**
93+ * Set the Graphics2D instance which will do the
94+ * drawing.
95+ */
96+ public void setDelegate(Graphics2D graphics) {
97+ mGraphics = graphics;
98+ }
99+
100+ public PrinterJob getPrinterJob() {
101+ return mPrinterJob;
102+ }
103+
104+ /**
105+ * Returns the device configuration associated with this Graphics2D.
106+ */
107+ public GraphicsConfiguration getDeviceConfiguration() {
108+ return ((RasterPrinterJob)mPrinterJob).getPrinterGraphicsConfig();
109+ }
110+
111+/* The Delegated Graphics Methods */
112+
113+ /**
114+ * Creates a new <code>Graphics</code> object that is
115+ * a copy of this <code>Graphics</code> object.
116+ * @return a new graphics context that is a copy of
117+ * this graphics context.
118+ * @since JDK1.0
119+ */
120+ public Graphics create() {
121+ return new ProxyGraphics2D((Graphics2D) mGraphics.create(),
122+ mPrinterJob);
123+ }
124+
125+ /**
126+ * Translates the origin of the graphics context to the point
127+ * (<i>x</i>,&nbsp;<i>y</i>) in the current coordinate system.
128+ * Modifies this graphics context so that its new origin corresponds
129+ * to the point (<i>x</i>,&nbsp;<i>y</i>) in this graphics context's
130+ * original coordinate system. All coordinates used in subsequent
131+ * rendering operations on this graphics context will be relative
132+ * to this new origin.
133+ * @param x the <i>x</i> coordinate.
134+ * @param y the <i>y</i> coordinate.
135+ * @since JDK1.0
136+ */
137+ public void translate(int x, int y) {
138+ mGraphics.translate(x, y);
139+ }
140+
141+ /**
142+ * Concatenates the current transform of this Graphics2D with a
143+ * translation transformation.
144+ * This is equivalent to calling transform(T), where T is an
145+ * AffineTransform represented by the following matrix:
146+ * <pre>
147+ * [ 1 0 tx ]
148+ * [ 0 1 ty ]
149+ * [ 0 0 1 ]
150+ * </pre>
151+ */
152+ public void translate(double tx, double ty) {
153+ mGraphics.translate(tx, ty);
154+ }
155+
156+ /**
157+ * Concatenates the current transform of this Graphics2D with a
158+ * rotation transformation.
159+ * This is equivalent to calling transform(R), where R is an
160+ * AffineTransform represented by the following matrix:
161+ * <pre>
162+ * [ cos(theta) -sin(theta) 0 ]
163+ * [ sin(theta) cos(theta) 0 ]
164+ * [ 0 0 1 ]
165+ * </pre>
166+ * Rotating with a positive angle theta rotates points on the positive
167+ * x axis toward the positive y axis.
168+ * @param theta The angle of rotation in radians.
169+ */
170+ public void rotate(double theta) {
171+ mGraphics.rotate(theta);
172+ }
173+
174+ /**
175+ * Concatenates the current transform of this Graphics2D with a
176+ * translated rotation transformation.
177+ * This is equivalent to the following sequence of calls:
178+ * <pre>
179+ * translate(x, y);
180+ * rotate(theta);
181+ * translate(-x, -y);
182+ * </pre>
183+ * Rotating with a positive angle theta rotates points on the positive
184+ * x axis toward the positive y axis.
185+ * @param theta The angle of rotation in radians.
186+ * @param x The x coordinate of the origin of the rotation
187+ * @param y The x coordinate of the origin of the rotation
188+ */
189+ public void rotate(double theta, double x, double y) {
190+ mGraphics.rotate(theta, x, y);
191+ }
192+
193+ /**
194+ * Concatenates the current transform of this Graphics2D with a
195+ * scaling transformation.
196+ * This is equivalent to calling transform(S), where S is an
197+ * AffineTransform represented by the following matrix:
198+ * <pre>
199+ * [ sx 0 0 ]
200+ * [ 0 sy 0 ]
201+ * [ 0 0 1 ]
202+ * </pre>
203+ */
204+ public void scale(double sx, double sy) {
205+ mGraphics.scale(sx, sy);
206+ }
207+
208+ /**
209+ * Concatenates the current transform of this Graphics2D with a
210+ * shearing transformation.
211+ * This is equivalent to calling transform(SH), where SH is an
212+ * AffineTransform represented by the following matrix:
213+ * <pre>
214+ * [ 1 shx 0 ]
215+ * [ shy 1 0 ]
216+ * [ 0 0 1 ]
217+ * </pre>
218+ * @param shx The factor by which coordinates are shifted towards the
219+ * positive X axis direction according to their Y coordinate
220+ * @param shy The factor by which coordinates are shifted towards the
221+ * positive Y axis direction according to their X coordinate
222+ */
223+ public void shear(double shx, double shy) {
224+ mGraphics.shear(shx, shy);
225+ }
226+
227+ /**
228+ * Gets this graphics context's current color.
229+ * @return this graphics context's current color.
230+ * @see java.awt.Color
231+ * @see java.awt.Graphics#setColor
232+ * @since JDK1.0
233+ */
234+ public Color getColor() {
235+ return mGraphics.getColor();
236+ }
237+
238+ /**
239+ * Sets this graphics context's current color to the specified
240+ * color. All subsequent graphics operations using this graphics
241+ * context use this specified color.
242+ * @param c the new rendering color.
243+ * @see java.awt.Color
244+ * @see java.awt.Graphics#getColor
245+ * @since JDK1.0
246+ */
247+ public void setColor(Color c) {
248+ mGraphics.setColor(c);
249+ }
250+
251+ /**
252+ * Sets the paint mode of this graphics context to overwrite the
253+ * destination with this graphics context's current color.
254+ * This sets the logical pixel operation function to the paint or
255+ * overwrite mode. All subsequent rendering operations will
256+ * overwrite the destination with the current color.
257+ * @since JDK1.0
258+ */
259+ public void setPaintMode() {
260+ mGraphics.setPaintMode();
261+ }
262+
263+ /**
264+ * Sets the paint mode of this graphics context to alternate between
265+ * this graphics context's current color and the new specified color.
266+ * This specifies that logical pixel operations are performed in the
267+ * XOR mode, which alternates pixels between the current color and
268+ * a specified XOR color.
269+ * <p>
270+ * When drawing operations are performed, pixels which are the
271+ * current color are changed to the specified color, and vice versa.
272+ * <p>
273+ * Pixels that are of colors other than those two colors are changed
274+ * in an unpredictable but reversible manner; if the same figure is
275+ * drawn twice, then all pixels are restored to their original values.
276+ * @param c1 the XOR alternation color
277+ * @since JDK1.0
278+ */
279+ public void setXORMode(Color c1) {
280+ mGraphics.setXORMode(c1);
281+ }
282+
283+ /**
284+ * Gets the current font.
285+ * @return this graphics context's current font.
286+ * @see java.awt.Font
287+ * @see java.awt.Graphics#setFont
288+ * @since JDK1.0
289+ */
290+ public Font getFont() {
291+ return mGraphics.getFont();
292+ }
293+
294+ /**
295+ * Sets this graphics context's font to the specified font.
296+ * All subsequent text operations using this graphics context
297+ * use this font.
298+ * @param font the font.
299+ * @see java.awt.Graphics#getFont
300+ * @see java.awt.Graphics#drawChars(java.lang.String, int, int)
301+ * @see java.awt.Graphics#drawString(byte[], int, int, int, int)
302+ * @see java.awt.Graphics#drawBytes(char[], int, int, int, int)
303+ * @since JDK1.0
304+ */
305+ public void setFont(Font font) {
306+ mGraphics.setFont(font);
307+ }
308+
309+ /**
310+ * Gets the font metrics for the specified font.
311+ * @return the font metrics for the specified font.
312+ * @param f the specified font
313+ * @see java.awt.Graphics#getFont
314+ * @see java.awt.FontMetrics
315+ * @see java.awt.Graphics#getFontMetrics()
316+ * @since JDK1.0
317+ */
318+ public FontMetrics getFontMetrics(Font f) {
319+ return mGraphics.getFontMetrics(f);
320+ }
321+
322+ /**
323+ * Get the rendering context of the font
324+ * within this Graphics2D context.
325+ */
326+ public FontRenderContext getFontRenderContext() {
327+ return mGraphics.getFontRenderContext();
328+ }
329+
330+ /**
331+ * Returns the bounding rectangle of the current clipping area.
332+ * The coordinates in the rectangle are relative to the coordinate
333+ * system origin of this graphics context.
334+ * @return the bounding rectangle of the current clipping area.
335+ * @see java.awt.Graphics#getClip
336+ * @see java.awt.Graphics#clipRect
337+ * @see java.awt.Graphics#setClip(int, int, int, int)
338+ * @see java.awt.Graphics#setClip(Shape)
339+ * @since JDK1.1
340+ */
341+ public Rectangle getClipBounds() {
342+ return mGraphics.getClipBounds();
343+ }
344+
345+
346+ /**
347+ * Intersects the current clip with the specified rectangle.
348+ * The resulting clipping area is the intersection of the current
349+ * clipping area and the specified rectangle.
350+ * This method can only be used to make the current clip smaller.
351+ * To set the current clip larger, use any of the setClip methods.
352+ * Rendering operations have no effect outside of the clipping area.
353+ * @param x the x coordinate of the rectangle to intersect the clip with
354+ * @param y the y coordinate of the rectangle to intersect the clip with
355+ * @param width the width of the rectangle to intersect the clip with
356+ * @param height the height of the rectangle to intersect the clip with
357+ * @see #setClip(int, int, int, int)
358+ * @see #setClip(Shape)
359+ */
360+ public void clipRect(int x, int y, int width, int height) {
361+ mGraphics.clipRect(x, y, width, height);
362+ }
363+
364+
365+ /**
366+ * Sets the current clip to the rectangle specified by the given
367+ * coordinates.
368+ * Rendering operations have no effect outside of the clipping area.
369+ * @param x the <i>x</i> coordinate of the new clip rectangle.
370+ * @param y the <i>y</i> coordinate of the new clip rectangle.
371+ * @param width the width of the new clip rectangle.
372+ * @param height the height of the new clip rectangle.
373+ * @see java.awt.Graphics#clipRect
374+ * @see java.awt.Graphics#setClip(Shape)
375+ * @since JDK1.1
376+ */
377+ public void setClip(int x, int y, int width, int height) {
378+ mGraphics.setClip(x, y, width, height);
379+ }
380+
381+ /**
382+ * Gets the current clipping area.
383+ * @return a <code>Shape</code> object representing the
384+ * current clipping area.
385+ * @see java.awt.Graphics#getClipBounds
386+ * @see java.awt.Graphics#clipRect
387+ * @see java.awt.Graphics#setClip(int, int, int, int)
388+ * @see java.awt.Graphics#setClip(Shape)
389+ * @since JDK1.1
390+ */
391+ public Shape getClip() {
392+ return mGraphics.getClip();
393+ }
394+
395+
396+ /**
397+ * Sets the current clipping area to an arbitrary clip shape.
398+ * Not all objects which implement the <code>Shape</code>
399+ * interface can be used to set the clip. The only
400+ * <code>Shape</code> objects which are guaranteed to be
401+ * supported are <code>Shape</code> objects which are
402+ * obtained via the <code>getClip</code> method and via
403+ * <code>Rectangle</code> objects.
404+ * @see java.awt.Graphics#getClip()
405+ * @see java.awt.Graphics#clipRect
406+ * @see java.awt.Graphics#setClip(int, int, int, int)
407+ * @since JDK1.1
408+ */
409+ public void setClip(Shape clip) {
410+ mGraphics.setClip(clip);
411+ }
412+
413+
414+ /**
415+ * Copies an area of the component by a distance specified by
416+ * <code>dx</code> and <code>dy</code>. From the point specified
417+ * by <code>x</code> and <code>y</code>, this method
418+ * copies downwards and to the right. To copy an area of the
419+ * component to the left or upwards, specify a negative value for
420+ * <code>dx</code> or <code>dy</code>.
421+ * If a portion of the source rectangle lies outside the bounds
422+ * of the component, or is obscured by another window or component,
423+ * <code>copyArea</code> will be unable to copy the associated
424+ * pixels. The area that is omitted can be refreshed by calling
425+ * the component's <code>paint</code> method.
426+ * @param x the <i>x</i> coordinate of the source rectangle.
427+ * @param y the <i>y</i> coordinate of the source rectangle.
428+ * @param width the width of the source rectangle.
429+ * @param height the height of the source rectangle.
430+ * @param dx the horizontal distance to copy the pixels.
431+ * @param dy the vertical distance to copy the pixels.
432+ * @since JDK1.0
433+ */
434+ public void copyArea(int x, int y, int width, int height,
435+ int dx, int dy) {
436+ mGraphics.copyArea(x, y, width, height, dx, dy);
437+ }
438+
439+ /**
440+ * Draws a line, using the current color, between the points
441+ * <code>(x1,&nbsp;y1)</code> and <code>(x2,&nbsp;y2)</code>
442+ * in this graphics context's coordinate system.
443+ * @param x1 the first point's <i>x</i> coordinate.
444+ * @param y1 the first point's <i>y</i> coordinate.
445+ * @param x2 the second point's <i>x</i> coordinate.
446+ * @param y2 the second point's <i>y</i> coordinate.
447+ * @since JDK1.0
448+ */
449+ public void drawLine(int x1, int y1, int x2, int y2) {
450+ mGraphics.drawLine(x1, y1, x2, y2);
451+ }
452+
453+
454+ /**
455+ * Fills the specified rectangle.
456+ * The left and right edges of the rectangle are at
457+ * <code>x</code> and <code>x&nbsp;+&nbsp;width&nbsp;-&nbsp;1</code>.
458+ * The top and bottom edges are at
459+ * <code>y</code> and <code>y&nbsp;+&nbsp;height&nbsp;-&nbsp;1</code>.
460+ * The resulting rectangle covers an area
461+ * <code>width</code> pixels wide by
462+ * <code>height</code> pixels tall.
463+ * The rectangle is filled using the graphics context's current color.
464+ * @param x the <i>x</i> coordinate
465+ * of the rectangle to be filled.
466+ * @param y the <i>y</i> coordinate
467+ * of the rectangle to be filled.
468+ * @param width the width of the rectangle to be filled.
469+ * @param height the height of the rectangle to be filled.
470+ * @see java.awt.Graphics#fillRect
471+ * @see java.awt.Graphics#clearRect
472+ * @since JDK1.0
473+ */
474+ public void fillRect(int x, int y, int width, int height) {
475+ mGraphics.fillRect(x, y, width, height);
476+ }
477+
478+ /**
479+ * Clears the specified rectangle by filling it with the background
480+ * color of the current drawing surface. This operation does not
481+ * use the current paint mode.
482+ * <p>
483+ * Beginning with Java&nbsp;1.1, the background color
484+ * of offscreen images may be system dependent. Applications should
485+ * use <code>setColor</code> followed by <code>fillRect</code> to
486+ * ensure that an offscreen image is cleared to a specific color.
487+ * @param x the <i>x</i> coordinate of the rectangle to clear.
488+ * @param y the <i>y</i> coordinate of the rectangle to clear.
489+ * @param width the width of the rectangle to clear.
490+ * @param height the height of the rectangle to clear.
491+ * @see java.awt.Graphics#fillRect(int, int, int, int)
492+ * @see java.awt.Graphics#drawRect
493+ * @see java.awt.Graphics#setColor(java.awt.Color)
494+ * @see java.awt.Graphics#setPaintMode
495+ * @see java.awt.Graphics#setXORMode(java.awt.Color)
496+ * @since JDK1.0
497+ */
498+ public void clearRect(int x, int y, int width, int height) {
499+ mGraphics.clearRect(x, y, width, height);
500+ }
501+
502+ /**
503+ * Draws an outlined round-cornered rectangle using this graphics
504+ * context's current color. The left and right edges of the rectangle
505+ * are at <code>x</code> and <code>x&nbsp;+&nbsp;width</code>,
506+ * respectively. The top and bottom edges of the rectangle are at
507+ * <code>y</code> and <code>y&nbsp;+&nbsp;height</code>.
508+ * @param x the <i>x</i> coordinate of the rectangle to be drawn.
509+ * @param y the <i>y</i> coordinate of the rectangle to be drawn.
510+ * @param width the width of the rectangle to be drawn.
511+ * @param height the height of the rectangle to be drawn.
512+ * @param arcWidth the horizontal diameter of the arc
513+ * at the four corners.
514+ * @param arcHeight the vertical diameter of the arc
515+ * at the four corners.
516+ * @see java.awt.Graphics#fillRoundRect
517+ * @since JDK1.0
518+ */
519+ public void drawRoundRect(int x, int y, int width, int height,
520+ int arcWidth, int arcHeight) {
521+ mGraphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);
522+ }
523+
524+ /**
525+ * Fills the specified rounded corner rectangle with the current color.
526+ * The left and right edges of the rectangle
527+ * are at <code>x</code> and <code>x&nbsp;+&nbsp;width&nbsp;-&nbsp;1</code>,
528+ * respectively. The top and bottom edges of the rectangle are at
529+ * <code>y</code> and <code>y&nbsp;+&nbsp;height&nbsp;-&nbsp;1</code>.
530+ * @param x the <i>x</i> coordinate of the rectangle to be filled.
531+ * @param y the <i>y</i> coordinate of the rectangle to be filled.
532+ * @param width the width of the rectangle to be filled.
533+ * @param height the height of the rectangle to be filled.
534+ * @param arcWidth the horizontal diameter
535+ * of the arc at the four corners.
536+ * @param arcHeight the vertical diameter
537+ * of the arc at the four corners.
538+ * @see java.awt.Graphics#drawRoundRect
539+ * @since JDK1.0
540+ */
541+ public void fillRoundRect(int x, int y, int width, int height,
542+ int arcWidth, int arcHeight) {
543+ mGraphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight);
544+ }
545+
546+ /**
547+ * Draws the outline of an oval.
548+ * The result is a circle or ellipse that fits within the
549+ * rectangle specified by the <code>x</code>, <code>y</code>,
550+ * <code>width</code>, and <code>height</code> arguments.
551+ * <p>
552+ * The oval covers an area that is
553+ * <code>width&nbsp;+&nbsp;1</code> pixels wide
554+ * and <code>height&nbsp;+&nbsp;1</code> pixels tall.
555+ * @param x the <i>x</i> coordinate of the upper left
556+ * corner of the oval to be drawn.
557+ * @param y the <i>y</i> coordinate of the upper left
558+ * corner of the oval to be drawn.
559+ * @param width the width of the oval to be drawn.
560+ * @param height the height of the oval to be drawn.
561+ * @see java.awt.Graphics#fillOval
562+ * @since JDK1.0
563+ */
564+ public void drawOval(int x, int y, int width, int height) {
565+ mGraphics.drawOval(x, y, width, height);
566+ }
567+
568+ /**
569+ * Fills an oval bounded by the specified rectangle with the
570+ * current color.
571+ * @param x the <i>x</i> coordinate of the upper left corner
572+ * of the oval to be filled.
573+ * @param y the <i>y</i> coordinate of the upper left corner
574+ * of the oval to be filled.
575+ * @param width the width of the oval to be filled.
576+ * @param height the height of the oval to be filled.
577+ * @see java.awt.Graphics#drawOval
578+ * @since JDK1.0
579+ */
580+ public void fillOval(int x, int y, int width, int height) {
581+ mGraphics.fillOval(x, y, width, height);
582+ }
583+
584+ /**
585+ * Draws the outline of a circular or elliptical arc
586+ * covering the specified rectangle.
587+ * <p>
588+ * The resulting arc begins at <code>startAngle</code> and extends
589+ * for <code>arcAngle</code> degrees, using the current color.
590+ * Angles are interpreted such that 0&nbsp;degrees
591+ * is at the 3&nbsp;o'clock position.
592+ * A positive value indicates a counter-clockwise rotation
593+ * while a negative value indicates a clockwise rotation.
594+ * <p>
595+ * The center of the arc is the center of the rectangle whose origin
596+ * is (<i>x</i>,&nbsp;<i>y</i>) and whose size is specified by the
597+ * <code>width</code> and <code>height</code> arguments.
598+ * <p>
599+ * The resulting arc covers an area
600+ * <code>width&nbsp;+&nbsp;1</code> pixels wide
601+ * by <code>height&nbsp;+&nbsp;1</code> pixels tall.
602+ * @param x the <i>x</i> coordinate of the
603+ * upper-left corner of the arc to be drawn.
604+ * @param y the <i>y</i> coordinate of the
605+ * upper-left corner of the arc to be drawn.
606+ * @param width the width of the arc to be drawn.
607+ * @param height the height of the arc to be drawn.
608+ * @param startAngle the beginning angle.
609+ * @param arcAngle the angular extent of the arc,
610+ * relative to the start angle.
611+ * @see java.awt.Graphics#fillArc
612+ * @since JDK1.0
613+ */
614+ public void drawArc(int x, int y, int width, int height,
615+ int startAngle, int arcAngle) {
616+ mGraphics.drawArc(x, y, width, height, startAngle, arcAngle);
617+ }
618+
619+ /**
620+ * Fills a circular or elliptical arc covering the specified rectangle.
621+ * <p>
622+ * The resulting arc begins at <code>startAngle</code> and extends
623+ * for <code>arcAngle</code> degrees.
624+ * Angles are interpreted such that 0&nbsp;degrees
625+ * is at the 3&nbsp;o'clock position.
626+ * A positive value indicates a counter-clockwise rotation
627+ * while a negative value indicates a clockwise rotation.
628+ * <p>
629+ * The center of the arc is the center of the rectangle whose origin
630+ * is (<i>x</i>,&nbsp;<i>y</i>) and whose size is specified by the
631+ * <code>width</code> and <code>height</code> arguments.
632+ * <p>
633+ * The resulting arc covers an area
634+ * <code>width&nbsp;+&nbsp;1</code> pixels wide
635+ * by <code>height&nbsp;+&nbsp;1</code> pixels tall.
636+ * @param x the <i>x</i> coordinate of the
637+ * upper-left corner of the arc to be filled.
638+ * @param y the <i>y</i> coordinate of the
639+ * upper-left corner of the arc to be filled.
640+ * @param width the width of the arc to be filled.
641+ * @param height the height of the arc to be filled.
642+ * @param startAngle the beginning angle.
643+ * @param arcAngle the angular extent of the arc,
644+ * relative to the start angle.
645+ * @see java.awt.Graphics#drawArc
646+ * @since JDK1.0
647+ */
648+ public void fillArc(int x, int y, int width, int height,
649+ int startAngle, int arcAngle) {
650+ mGraphics.fillArc(x, y, width, height, startAngle, arcAngle);
651+ }
652+
653+ /**
654+ * Draws a sequence of connected lines defined by
655+ * arrays of <i>x</i> and <i>y</i> coordinates.
656+ * Each pair of (<i>x</i>,&nbsp;<i>y</i>) coordinates defines a point.
657+ * The figure is not closed if the first point
658+ * differs from the last point.
659+ * @param xPoints an array of <i>x</i> points
660+ * @param yPoints an array of <i>y</i> points
661+ * @param nPoints the total number of points
662+ * @see java.awt.Graphics#drawPolygon(int[], int[], int)
663+ * @since JDK1.1
664+ */
665+ public void drawPolyline(int xPoints[], int yPoints[],
666+ int nPoints) {
667+ mGraphics.drawPolyline(xPoints, yPoints, nPoints);
668+ }
669+
670+ /**
671+ * Draws a closed polygon defined by
672+ * arrays of <i>x</i> and <i>y</i> coordinates.
673+ * Each pair of (<i>x</i>,&nbsp;<i>y</i>) coordinates defines a point.
674+ * <p>
675+ * This method draws the polygon defined by <code>nPoint</code> line
676+ * segments, where the first <code>nPoint&nbsp;-&nbsp;1</code>
677+ * line segments are line segments from
678+ * <code>(xPoints[i&nbsp;-&nbsp;1],&nbsp;yPoints[i&nbsp;-&nbsp;1])</code>
679+ * to <code>(xPoints[i],&nbsp;yPoints[i])</code>, for
680+ * 1&nbsp;&le;&nbsp;<i>i</i>&nbsp;&le;&nbsp;<code>nPoints</code>.
681+ * The figure is automatically closed by drawing a line connecting
682+ * the final point to the first point, if those points are different.
683+ * @param xPoints a an array of <code>x</code> coordinates.
684+ * @param yPoints a an array of <code>y</code> coordinates.
685+ * @param nPoints a the total number of points.
686+ * @see java.awt.Graphics#fillPolygon
687+ * @see java.awt.Graphics#drawPolyline
688+ * @since JDK1.0
689+ */
690+ public void drawPolygon(int xPoints[], int yPoints[],
691+ int nPoints) {
692+ mGraphics.drawPolygon(xPoints, yPoints, nPoints);
693+ }
694+
695+ /**
696+ * Fills a closed polygon defined by
697+ * arrays of <i>x</i> and <i>y</i> coordinates.
698+ * <p>
699+ * This method draws the polygon defined by <code>nPoint</code> line
700+ * segments, where the first <code>nPoint&nbsp;-&nbsp;1</code>
701+ * line segments are line segments from
702+ * <code>(xPoints[i&nbsp;-&nbsp;1],&nbsp;yPoints[i&nbsp;-&nbsp;1])</code>
703+ * to <code>(xPoints[i],&nbsp;yPoints[i])</code>, for
704+ * 1&nbsp;&le;&nbsp;<i>i</i>&nbsp;&le;&nbsp;<code>nPoints</code>.
705+ * The figure is automatically closed by drawing a line connecting
706+ * the final point to the first point, if those points are different.
707+ * <p>
708+ * The area inside the polygon is defined using an
709+ * even-odd fill rule, also known as the alternating rule.
710+ * @param xPoints a an array of <code>x</code> coordinates.
711+ * @param yPoints a an array of <code>y</code> coordinates.
712+ * @param nPoints a the total number of points.
713+ * @see java.awt.Graphics#drawPolygon(int[], int[], int)
714+ * @since JDK1.0
715+ */
716+ public void fillPolygon(int xPoints[], int yPoints[],
717+ int nPoints) {
718+ mGraphics.fillPolygon(xPoints, yPoints, nPoints);
719+ }
720+
721+ /**
722+ * Draws the text given by the specified string, using this
723+ * graphics context's current font and color. The baseline of the
724+ * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in this
725+ * graphics context's coordinate system.
726+ * @param str the string to be drawn.
727+ * @param x the <i>x</i> coordinate.
728+ * @param y the <i>y</i> coordinate.
729+ * @see java.awt.Graphics#drawBytes
730+ * @see java.awt.Graphics#drawChars
731+ * @since JDK1.0
732+ */
733+ public void drawString(String str, int x, int y) {
734+ mGraphics.drawString(str, x, y);
735+ }
736+
737+ /**
738+ * Draws the text given by the specified iterator, using this
739+ * graphics context's current color. The iterator has to specify a font
740+ * for each character. The baseline of the
741+ * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in this
742+ * graphics context's coordinate system.
743+ * The rendering attributes applied include the clip, transform,
744+ * paint or color, and composite attributes.
745+ * For characters in script systems such as Hebrew and Arabic,
746+ * the glyphs may be draw from right to left, in which case the
747+ * coordinate supplied is the the location of the leftmost character
748+ * on the baseline.
749+ * @param iterator the iterator whose text is to be drawn
750+ * @param x,y the coordinates where the iterator's text should be drawn.
751+ * @see #setPaint
752+ * @see java.awt.Graphics#setColor
753+ * @see #setTransform
754+ * @see #setComposite
755+ * @see #setClip
756+ */
757+ public void drawString(AttributedCharacterIterator iterator,
758+ int x, int y) {
759+ mGraphics.drawString(iterator, x, y);
760+ }
761+
762+ /**
763+ * Draws the text given by the specified iterator, using this
764+ * graphics context's current color. The iterator has to specify a font
765+ * for each character. The baseline of the
766+ * first character is at position (<i>x</i>,&nbsp;<i>y</i>) in this
767+ * graphics context's coordinate system.
768+ * The rendering attributes applied include the clip, transform,
769+ * paint or color, and composite attributes.
770+ * For characters in script systems such as Hebrew and Arabic,
771+ * the glyphs may be draw from right to left, in which case the
772+ * coordinate supplied is the the location of the leftmost character
773+ * on the baseline.
774+ * @param iterator the iterator whose text is to be drawn
775+ * @param x,y the coordinates where the iterator's text should be drawn.
776+ * @see #setPaint
777+ * @see java.awt.Graphics#setColor
778+ * @see #setTransform
779+ * @see #setComposite
780+ * @see #setClip
781+ */
782+ public void drawString(AttributedCharacterIterator iterator,
783+ float x, float y) {
784+ mGraphics.drawString(iterator, x, y);
785+ }
786+
787+ /**
788+ * Draws as much of the specified image as is currently available.
789+ * The image is drawn with its top-left corner at
790+ * (<i>x</i>,&nbsp;<i>y</i>) in this graphics context's coordinate
791+ * space. Transparent pixels in the image do not affect whatever
792+ * pixels are already there.
793+ * <p>
794+ * This method returns immediately in all cases, even if the
795+ * complete image has not yet been loaded, and it has not been dithered
796+ * and converted for the current output device.
797+ * <p>
798+ * If the image has not yet been completely loaded, then
799+ * <code>drawImage</code> returns <code>false</code>. As more of
800+ * the image becomes available, the process that draws the image notifies
801+ * the specified image observer.
802+ * @param img the specified image to be drawn.
803+ * @param x the <i>x</i> coordinate.
804+ * @param y the <i>y</i> coordinate.
805+ * @param observer object to be notified as more of
806+ * the image is converted.
807+ * @see java.awt.Image
808+ * @see java.awt.image.ImageObserver
809+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
810+ * @since JDK1.0
811+ */
812+ public boolean drawImage(Image img, int x, int y,
813+ ImageObserver observer) {
814+
815+ return mGraphics.drawImage(img, x, y, observer);
816+ }
817+
818+ /**
819+ * Draws as much of the specified image as has already been scaled
820+ * to fit inside the specified rectangle.
821+ * <p>
822+ * The image is drawn inside the specified rectangle of this
823+ * graphics context's coordinate space, and is scaled if
824+ * necessary. Transparent pixels do not affect whatever pixels
825+ * are already there.
826+ * <p>
827+ * This method returns immediately in all cases, even if the
828+ * entire image has not yet been scaled, dithered, and converted
829+ * for the current output device.
830+ * If the current output representation is not yet complete, then
831+ * <code>drawImage</code> returns <code>false</code>. As more of
832+ * the image becomes available, the process that draws the image notifies
833+ * the image observer by calling its <code>imageUpdate</code> method.
834+ * <p>
835+ * A scaled version of an image will not necessarily be
836+ * available immediately just because an unscaled version of the
837+ * image has been constructed for this output device. Each size of
838+ * the image may be cached separately and generated from the original
839+ * data in a separate image production sequence.
840+ * @param img the specified image to be drawn.
841+ * @param x the <i>x</i> coordinate.
842+ * @param y the <i>y</i> coordinate.
843+ * @param width the width of the rectangle.
844+ * @param height the height of the rectangle.
845+ * @param observer object to be notified as more of
846+ * the image is converted.
847+ * @see java.awt.Image
848+ * @see java.awt.image.ImageObserver
849+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
850+ * @since JDK1.0
851+ */
852+ public boolean drawImage(Image img, int x, int y,
853+ int width, int height,
854+ ImageObserver observer) {
855+
856+ return mGraphics.drawImage(img, x, y, width, height, observer);
857+ }
858+
859+ /**
860+ * Draws as much of the specified image as is currently available.
861+ * The image is drawn with its top-left corner at
862+ * (<i>x</i>,&nbsp;<i>y</i>) in this graphics context's coordinate
863+ * space. Transparent pixels are drawn in the specified
864+ * background color.
865+ * <p>
866+ * This operation is equivalent to filling a rectangle of the
867+ * width and height of the specified image with the given color and then
868+ * drawing the image on top of it, but possibly more efficient.
869+ * <p>
870+ * This method returns immediately in all cases, even if the
871+ * complete image has not yet been loaded, and it has not been dithered
872+ * and converted for the current output device.
873+ * <p>
874+ * If the image has not yet been completely loaded, then
875+ * <code>drawImage</code> returns <code>false</code>. As more of
876+ * the image becomes available, the process that draws the image notifies
877+ * the specified image observer.
878+ * @param img the specified image to be drawn.
879+ * @param x the <i>x</i> coordinate.
880+ * @param y the <i>y</i> coordinate.
881+ * @param bgcolor the background color to paint under the
882+ * non-opaque portions of the image.
883+ * @param observer object to be notified as more of
884+ * the image is converted.
885+ * @see java.awt.Image
886+ * @see java.awt.image.ImageObserver
887+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
888+ * @since JDK1.0
889+ */
890+ public boolean drawImage(Image img, int x, int y,
891+ Color bgcolor,
892+ ImageObserver observer) {
893+
894+ if (img == null) {
895+ return true;
896+ }
897+
898+ boolean result;
899+
900+ if (needToCopyBgColorImage(img)) {
901+ BufferedImage imageCopy = getBufferedImageCopy(img, bgcolor);
902+ result = mGraphics.drawImage(imageCopy, x, y, null);
903+ } else {
904+ result = mGraphics.drawImage(img, x, y, bgcolor, observer);
905+ }
906+
907+ return result;
908+ }
909+
910+ /**
911+ * Draws as much of the specified image as has already been scaled
912+ * to fit inside the specified rectangle.
913+ * <p>
914+ * The image is drawn inside the specified rectangle of this
915+ * graphics context's coordinate space, and is scaled if
916+ * necessary. Transparent pixels are drawn in the specified
917+ * background color.
918+ * This operation is equivalent to filling a rectangle of the
919+ * width and height of the specified image with the given color and then
920+ * drawing the image on top of it, but possibly more efficient.
921+ * <p>
922+ * This method returns immediately in all cases, even if the
923+ * entire image has not yet been scaled, dithered, and converted
924+ * for the current output device.
925+ * If the current output representation is not yet complete then
926+ * <code>drawImage</code> returns <code>false</code>. As more of
927+ * the image becomes available, the process that draws the image notifies
928+ * the specified image observer.
929+ * <p>
930+ * A scaled version of an image will not necessarily be
931+ * available immediately just because an unscaled version of the
932+ * image has been constructed for this output device. Each size of
933+ * the image may be cached separately and generated from the original
934+ * data in a separate image production sequence.
935+ * @param img the specified image to be drawn.
936+ * @param x the <i>x</i> coordinate.
937+ * @param y the <i>y</i> coordinate.
938+ * @param width the width of the rectangle.
939+ * @param height the height of the rectangle.
940+ * @param bgcolor the background color to paint under the
941+ * non-opaque portions of the image.
942+ * @param observer object to be notified as more of
943+ * the image is converted.
944+ * @see java.awt.Image
945+ * @see java.awt.image.ImageObserver
946+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
947+ * @since JDK1.0
948+ */
949+ public boolean drawImage(Image img, int x, int y,
950+ int width, int height,
951+ Color bgcolor,
952+ ImageObserver observer) {
953+
954+ if (img == null) {
955+ return true;
956+ }
957+
958+ boolean result;
959+
960+ if (needToCopyBgColorImage(img)) {
961+ BufferedImage imageCopy = getBufferedImageCopy(img, bgcolor);
962+ result = mGraphics.drawImage(imageCopy, x, y, width, height, null);
963+ } else {
964+ result = mGraphics.drawImage(img, x, y, width, height,
965+ bgcolor, observer);
966+ }
967+
968+ return result;
969+ }
970+
971+ /**
972+ * Draws as much of the specified area of the specified image as is
973+ * currently available, scaling it on the fly to fit inside the
974+ * specified area of the destination drawable surface. Transparent pixels
975+ * do not affect whatever pixels are already there.
976+ * <p>
977+ * This method returns immediately in all cases, even if the
978+ * image area to be drawn has not yet been scaled, dithered, and converted
979+ * for the current output device.
980+ * If the current output representation is not yet complete then
981+ * <code>drawImage</code> returns <code>false</code>. As more of
982+ * the image becomes available, the process that draws the image notifies
983+ * the specified image observer.
984+ * <p>
985+ * This method always uses the unscaled version of the image
986+ * to render the scaled rectangle and performs the required
987+ * scaling on the fly. It does not use a cached, scaled version
988+ * of the image for this operation. Scaling of the image from source
989+ * to destination is performed such that the first coordinate
990+ * of the source rectangle is mapped to the first coordinate of
991+ * the destination rectangle, and the second source coordinate is
992+ * mapped to the second destination coordinate. The subimage is
993+ * scaled and flipped as needed to preserve those mappings.
994+ * @param img the specified image to be drawn
995+ * @param dx1 the <i>x</i> coordinate of the first corner of the
996+ * destination rectangle.
997+ * @param dy1 the <i>y</i> coordinate of the first corner of the
998+ * destination rectangle.
999+ * @param dx2 the <i>x</i> coordinate of the second corner of the
1000+ * destination rectangle.
1001+ * @param dy2 the <i>y</i> coordinate of the second corner of the
1002+ * destination rectangle.
1003+ * @param sx1 the <i>x</i> coordinate of the first corner of the
1004+ * source rectangle.
1005+ * @param sy1 the <i>y</i> coordinate of the first corner of the
1006+ * source rectangle.
1007+ * @param sx2 the <i>x</i> coordinate of the second corner of the
1008+ * source rectangle.
1009+ * @param sy2 the <i>y</i> coordinate of the second corner of the
1010+ * source rectangle.
1011+ * @param observer object to be notified as more of the image is
1012+ * scaled and converted.
1013+ * @see java.awt.Image
1014+ * @see java.awt.image.ImageObserver
1015+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
1016+ * @since JDK1.1
1017+ */
1018+ public boolean drawImage(Image img,
1019+ int dx1, int dy1, int dx2, int dy2,
1020+ int sx1, int sy1, int sx2, int sy2,
1021+ ImageObserver observer) {
1022+ return mGraphics.drawImage(img, dx1, dy1, dx2, dy2,
1023+ sx1, sy1, sx2, sy2,
1024+ observer);
1025+ }
1026+
1027+ /**
1028+ * Draws as much of the specified area of the specified image as is
1029+ * currently available, scaling it on the fly to fit inside the
1030+ * specified area of the destination drawable surface.
1031+ * <p>
1032+ * Transparent pixels are drawn in the specified background color.
1033+ * This operation is equivalent to filling a rectangle of the
1034+ * width and height of the specified image with the given color and then
1035+ * drawing the image on top of it, but possibly more efficient.
1036+ * <p>
1037+ * This method returns immediately in all cases, even if the
1038+ * image area to be drawn has not yet been scaled, dithered, and converted
1039+ * for the current output device.
1040+ * If the current output representation is not yet complete then
1041+ * <code>drawImage</code> returns <code>false</code>. As more of
1042+ * the image becomes available, the process that draws the image notifies
1043+ * the specified image observer.
1044+ * <p>
1045+ * This method always uses the unscaled version of the image
1046+ * to render the scaled rectangle and performs the required
1047+ * scaling on the fly. It does not use a cached, scaled version
1048+ * of the image for this operation. Scaling of the image from source
1049+ * to destination is performed such that the first coordinate
1050+ * of the source rectangle is mapped to the first coordinate of
1051+ * the destination rectangle, and the second source coordinate is
1052+ * mapped to the second destination coordinate. The subimage is
1053+ * scaled and flipped as needed to preserve those mappings.
1054+ * @param img the specified image to be drawn
1055+ * @param dx1 the <i>x</i> coordinate of the first corner of the
1056+ * destination rectangle.
1057+ * @param dy1 the <i>y</i> coordinate of the first corner of the
1058+ * destination rectangle.
1059+ * @param dx2 the <i>x</i> coordinate of the second corner of the
1060+ * destination rectangle.
1061+ * @param dy2 the <i>y</i> coordinate of the second corner of the
1062+ * destination rectangle.
1063+ * @param sx1 the <i>x</i> coordinate of the first corner of the
1064+ * source rectangle.
1065+ * @param sy1 the <i>y</i> coordinate of the first corner of the
1066+ * source rectangle.
1067+ * @param sx2 the <i>x</i> coordinate of the second corner of the
1068+ * source rectangle.
1069+ * @param sy2 the <i>y</i> coordinate of the second corner of the
1070+ * source rectangle.
1071+ * @param bgcolor the background color to paint under the
1072+ * non-opaque portions of the image.
1073+ * @param observer object to be notified as more of the image is
1074+ * scaled and converted.
1075+ * @see java.awt.Image
1076+ * @see java.awt.image.ImageObserver
1077+ * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int)
1078+ * @since JDK1.1
1079+ */
1080+ public boolean drawImage(Image img,
1081+ int dx1, int dy1, int dx2, int dy2,
1082+ int sx1, int sy1, int sx2, int sy2,
1083+ Color bgcolor,
1084+ ImageObserver observer) {
1085+
1086+ if (img == null) {
1087+ return true;
1088+ }
1089+
1090+ boolean result;
1091+ if (needToCopyBgColorImage(img)) {
1092+ BufferedImage imageCopy = getBufferedImageCopy(img, bgcolor);
1093+ result = mGraphics.drawImage(imageCopy,
1094+ dx1, dy1, dx2, dy2,
1095+ sy1, sy1, sx2, sy2,
1096+ null);
1097+ } else {
1098+ result = mGraphics.drawImage(img,
1099+ dx1, dy1, dx2, dy2,
1100+ sy1, sy1, sx2, sy2,
1101+ bgcolor,
1102+ observer);
1103+ }
1104+
1105+ return result;
1106+ }
1107+
1108+ /**
1109+ * Return true if drawing <code>img</code> will
1110+ * invoke a Java2D bug (#4258675). The bug in question
1111+ * occurs when a draw image call with a background color
1112+ * parameter tries to render a sheared
1113+ * or rotated image. The portions of the bounding
1114+ * rectangle not covered by the sheared image
1115+ * are incorrectly drawn with the background color.
1116+ */
1117+ private boolean needToCopyBgColorImage(Image img) {
1118+
1119+ boolean needToCopy;
1120+
1121+ AffineTransform transform = getTransform();
1122+
1123+ return (transform.getType()
1124+ & (AffineTransform.TYPE_GENERAL_ROTATION
1125+ | AffineTransform.TYPE_GENERAL_TRANSFORM)) != 0;
1126+ }
1127+
1128+ /**
1129+ * Return a new <code>BufferedImage</code>
1130+ * that contains a copy of the provided
1131+ * <code>Image</code> where its
1132+ * transparent pixels have been replaced by
1133+ * <code>bgcolor</code>. If the new
1134+ * <code>BufferedImage</code> can not be created,
1135+ * probably because the original image has not
1136+ * finished loading, then <code>null</code> is
1137+ * returned.
1138+ */
1139+ private BufferedImage getBufferedImageCopy(Image img, Color bgcolor) {
1140+
1141+ BufferedImage imageCopy = null;
1142+
1143+ int width = img.getWidth(null);
1144+ int height = img.getHeight(null);
1145+
1146+ if (width > 0 && height > 0) {
1147+
1148+ int imageType;
1149+
1150+ /* Try to minimize the depth of the BufferedImage
1151+ * we are about to create by, if possible, making
1152+ * it the same depth as the original image.
1153+ */
1154+ if (img instanceof BufferedImage) {
1155+ BufferedImage bufImage = (BufferedImage) img;
1156+ imageType = bufImage.getType();
1157+ } else {
1158+ imageType = BufferedImage.TYPE_INT_ARGB;
1159+ }
1160+
1161+ imageCopy = new BufferedImage(width, height, imageType);
1162+
1163+ /* Copy the original image into the new buffer
1164+ * without any transformations.
1165+ * This will replace the transparent pixels
1166+ * in the original with background color.
1167+ */
1168+ Graphics g = imageCopy.createGraphics();
1169+ g.drawImage(img, 0, 0, bgcolor, null);
1170+ g.dispose();
1171+
1172+ /* We couldn't get the width or height of the image
1173+ * so just return null.
1174+ */
1175+ } else {
1176+ imageCopy = null;
1177+ }
1178+
1179+ return imageCopy;
1180+ }
1181+
1182+ /**
1183+ * Draws an image, applying a transform from image space into user space
1184+ * before drawing.
1185+ * The transformation from user space into device space is done with
1186+ * the current transform in the Graphics2D.
1187+ * The given transformation is applied to the image before the
1188+ * transform attribute in the Graphics2D state is applied.
1189+ * The rendering attributes applied include the clip, transform,
1190+ * and composite attributes. Note that the result is
1191+ * undefined, if the given transform is noninvertible.
1192+ * @param img The image to be drawn.
1193+ * @param xform The transformation from image space into user space.
1194+ * @see #transform
1195+ * @see #setTransform
1196+ * @see #setComposite
1197+ * @see #clip
1198+ * @see #setClip
1199+ */
1200+ public void drawRenderedImage(RenderedImage img,
1201+ AffineTransform xform) {
1202+ mGraphics.drawRenderedImage(img, xform);
1203+ }
1204+
1205+
1206+
1207+ public void drawRenderableImage(RenderableImage img,
1208+ AffineTransform xform) {
1209+
1210+ if (img == null) {
1211+ return;
1212+ }
1213+
1214+ AffineTransform pipeTransform = getTransform();
1215+ AffineTransform concatTransform = new AffineTransform(xform);
1216+ concatTransform.concatenate(pipeTransform);
1217+ AffineTransform reverseTransform;
1218+
1219+ RenderContext rc = new RenderContext(concatTransform);
1220+
1221+ try {
1222+ reverseTransform = pipeTransform.createInverse();
1223+ } catch (NoninvertibleTransformException nte) {
1224+ rc = new RenderContext(pipeTransform);
1225+ reverseTransform = new AffineTransform();
1226+ }
1227+
1228+ RenderedImage rendering = img.createRendering(rc);
1229+ drawRenderedImage(rendering,reverseTransform);
1230+ }
1231+
1232+ /**
1233+ * Disposes of this graphics context and releases
1234+ * any system resources that it is using.
1235+ * A <code>Graphics</code> object cannot be used after
1236+ * <code>dispose</code>has been called.
1237+ * <p>
1238+ * When a Java program runs, a large number of <code>Graphics</code>
1239+ * objects can be created within a short time frame.
1240+ * Although the finalization process of the garbage collector
1241+ * also disposes of the same system resources, it is preferable
1242+ * to manually free the associated resources by calling this
1243+ * method rather than to rely on a finalization process which
1244+ * may not run to completion for a long period of time.
1245+ * <p>
1246+ * Graphics objects which are provided as arguments to the
1247+ * <code>paint</code> and <code>update</code> methods
1248+ * of components are automatically released by the system when
1249+ * those methods return. For efficiency, programmers should
1250+ * call <code>dispose</code> when finished using
1251+ * a <code>Graphics</code> object only if it was created
1252+ * directly from a component or another <code>Graphics</code> object.
1253+ * @see java.awt.Graphics#finalize
1254+ * @see java.awt.Component#paint
1255+ * @see java.awt.Component#update
1256+ * @see java.awt.Component#getGraphics
1257+ * @see java.awt.Graphics#create
1258+ * @since JDK1.0
1259+ */
1260+ public void dispose() {
1261+ mGraphics.dispose();
1262+ }
1263+
1264+ /**
1265+ * Empty finalizer as no clean up needed here.
1266+ */
1267+ public void finalize() {
1268+ }
1269+
1270+
1271+/* The Delegated Graphics2D Methods */
1272+
1273+ /**
1274+ * Strokes the outline of a Shape using the settings of the current
1275+ * graphics state. The rendering attributes applied include the
1276+ * clip, transform, paint or color, composite and stroke attributes.
1277+ * @param s The shape to be drawn.
1278+ * @see #setStroke
1279+ * @see #setPaint
1280+ * @see java.awt.Graphics#setColor
1281+ * @see #transform
1282+ * @see #setTransform
1283+ * @see #clip
1284+ * @see #setClip
1285+ * @see #setComposite
1286+ */
1287+ public void draw(Shape s) {
1288+ mGraphics.draw(s);
1289+ }
1290+
1291+ /**
1292+ * Draws an image, applying a transform from image space into user space
1293+ * before drawing.
1294+ * The transformation from user space into device space is done with
1295+ * the current transform in the Graphics2D.
1296+ * The given transformation is applied to the image before the
1297+ * transform attribute in the Graphics2D state is applied.
1298+ * The rendering attributes applied include the clip, transform,
1299+ * and composite attributes. Note that the result is
1300+ * undefined, if the given transform is noninvertible.
1301+ * @param img The image to be drawn.
1302+ * @param xform The transformation from image space into user space.
1303+ * @param obs The image observer to be notified as more of the image
1304+ * is converted.
1305+ * @see #transform
1306+ * @see #setTransform
1307+ * @see #setComposite
1308+ * @see #clip
1309+ * @see #setClip
1310+ */
1311+ public boolean drawImage(Image img,
1312+ AffineTransform xform,
1313+ ImageObserver obs) {
1314+
1315+ return mGraphics.drawImage(img, xform, obs);
1316+ }
1317+
1318+ /**
1319+ * Draws a BufferedImage that is filtered with a BufferedImageOp.
1320+ * The rendering attributes applied include the clip, transform
1321+ * and composite attributes. This is equivalent to:
1322+ * <pre>
1323+ * img1 = op.filter(img, null);
1324+ * drawImage(img1, new AffineTransform(1f,0f,0f,1f,x,y), null);
1325+ * </pre>
1326+ * @param op The filter to be applied to the image before drawing.
1327+ * @param img The BufferedImage to be drawn.
1328+ * @param x,y The location in user space where the image should be drawn.
1329+ * @see #transform
1330+ * @see #setTransform
1331+ * @see #setComposite
1332+ * @see #clip
1333+ * @see #setClip
1334+ */
1335+ public void drawImage(BufferedImage img,
1336+ BufferedImageOp op,
1337+ int x,
1338+ int y) {
1339+
1340+ mGraphics.drawImage(img, op, x, y);
1341+ }
1342+
1343+
1344+ /**
1345+ * Draws a string of text.
1346+ * The rendering attributes applied include the clip, transform,
1347+ * paint or color, font and composite attributes.
1348+ * @param s The string to be drawn.
1349+ * @param x,y The coordinates where the string should be drawn.
1350+ * @see #setPaint
1351+ * @see java.awt.Graphics#setColor
1352+ * @see java.awt.Graphics#setFont
1353+ * @see #transform
1354+ * @see #setTransform
1355+ * @see #setComposite
1356+ * @see #clip
1357+ * @see #setClip
1358+ */
1359+ public void drawString(String str,
1360+ float x,
1361+ float y) {
1362+ mGraphics.drawString(str, x, y);
1363+ }
1364+
1365+ /**
1366+ * Draws a GlyphVector.
1367+ * The rendering attributes applied include the clip, transform,
1368+ * paint or color, and composite attributes. The GlyphVector specifies
1369+ * individual glyphs from a Font.
1370+ * @param g The GlyphVector to be drawn.
1371+ * @param x,y The coordinates where the glyphs should be drawn.
1372+ * @see #setPaint
1373+ * @see java.awt.Graphics#setColor
1374+ * @see #transform
1375+ * @see #setTransform
1376+ * @see #setComposite
1377+ * @see #clip
1378+ * @see #setClip
1379+ */
1380+ public void drawGlyphVector(GlyphVector g,
1381+ float x,
1382+ float y) {
1383+ mGraphics.drawGlyphVector(g, x, y);
1384+ }
1385+
1386+ /**
1387+ * Fills the interior of a Shape using the settings of the current
1388+ * graphics state. The rendering attributes applied include the
1389+ * clip, transform, paint or color, and composite.
1390+ * @see #setPaint
1391+ * @see java.awt.Graphics#setColor
1392+ * @see #transform
1393+ * @see #setTransform
1394+ * @see #setComposite
1395+ * @see #clip
1396+ * @see #setClip
1397+ */
1398+ public void fill(Shape s) {
1399+ mGraphics.fill(s);
1400+ }
1401+
1402+ /**
1403+ * Checks to see if the outline of a Shape intersects the specified
1404+ * Rectangle in device space.
1405+ * The rendering attributes taken into account include the
1406+ * clip, transform, and stroke attributes.
1407+ * @param rect The area in device space to check for a hit.
1408+ * @param s The shape to check for a hit.
1409+ * @param onStroke Flag to choose between testing the stroked or
1410+ * the filled shape.
1411+ * @return True if there is a hit, false otherwise.
1412+ * @see #setStroke
1413+ * @see #fill
1414+ * @see #draw
1415+ * @see #transform
1416+ * @see #setTransform
1417+ * @see #clip
1418+ * @see #setClip
1419+ */
1420+ public boolean hit(Rectangle rect,
1421+ Shape s,
1422+ boolean onStroke) {
1423+
1424+ return mGraphics.hit(rect, s, onStroke);
1425+ }
1426+
1427+ /**
1428+ * Sets the Composite in the current graphics state. Composite is used
1429+ * in all drawing methods such as drawImage, drawString, draw,
1430+ * and fill. It specifies how new pixels are to be combined with
1431+ * the existing pixels on the graphics device in the rendering process.
1432+ * @param comp The Composite object to be used for drawing.
1433+ * @see java.awt.Graphics#setXORMode
1434+ * @see java.awt.Graphics#setPaintMode
1435+ * @see AlphaComposite
1436+ */
1437+ public void setComposite(Composite comp) {
1438+ mGraphics.setComposite(comp);
1439+ }
1440+
1441+
1442+ /**
1443+ * Sets the Paint in the current graphics state.
1444+ * @param paint The Paint object to be used to generate color in
1445+ * the rendering process.
1446+ * @see java.awt.Graphics#setColor
1447+ * @see GradientPaint
1448+ * @see TexturePaint
1449+ */
1450+ public void setPaint(Paint paint) {
1451+ mGraphics.setPaint(paint);
1452+ }
1453+
1454+ /**
1455+ * Sets the Stroke in the current graphics state.
1456+ * @param s The Stroke object to be used to stroke a Shape in
1457+ * the rendering process.
1458+ * @see BasicStroke
1459+ */
1460+ public void setStroke(Stroke s) {
1461+ mGraphics.setStroke(s);
1462+ }
1463+
1464+ /**
1465+ * Sets the preferences for the rendering algorithms.
1466+ * Hint categories include controls for rendering quality and
1467+ * overall time/quality trade-off in the rendering process.
1468+ * @param hintCategory The category of hint to be set.
1469+ * @param hintValue The value indicating preferences for the specified
1470+ * hint category.
1471+ * @see RenderingHints
1472+ */
1473+ public void setRenderingHint(Key hintCategory, Object hintValue) {
1474+ mGraphics.setRenderingHint(hintCategory, hintValue);
1475+ }
1476+
1477+ /**
1478+ * Returns the preferences for the rendering algorithms.
1479+ * @param hintCategory The category of hint to be set.
1480+ * @return The preferences for rendering algorithms.
1481+ * @see RenderingHings
1482+ */
1483+ public Object getRenderingHint(Key hintCategory) {
1484+ return mGraphics.getRenderingHint(hintCategory);
1485+ }
1486+
1487+ /**
1488+ * Sets the preferences for the rendering algorithms.
1489+ * Hint categories include controls for rendering quality and
1490+ * overall time/quality trade-off in the rendering process.
1491+ * @param hints The rendering hints to be set
1492+ * @see RenderingHints
1493+ */
1494+ public void setRenderingHints(Map<?,?> hints) {
1495+ mGraphics.setRenderingHints(hints);
1496+ }
1497+
1498+ /**
1499+ * Adds a number of preferences for the rendering algorithms.
1500+ * Hint categories include controls for rendering quality and
1501+ * overall time/quality trade-off in the rendering process.
1502+ * @param hints The rendering hints to be set
1503+ * @see RenderingHints
1504+ */
1505+ public void addRenderingHints(Map<?,?> hints) {
1506+ mGraphics.addRenderingHints(hints);
1507+ }
1508+
1509+ /**
1510+ * Gets the preferences for the rendering algorithms.
1511+ * Hint categories include controls for rendering quality and
1512+ * overall time/quality trade-off in the rendering process.
1513+ * @see RenderingHints
1514+ */
1515+ public RenderingHints getRenderingHints() {
1516+ return mGraphics.getRenderingHints();
1517+ }
1518+
1519+ /**
1520+ * Composes a Transform object with the transform in this
1521+ * Graphics2D according to the rule last-specified-first-applied.
1522+ * If the currrent transform is Cx, the result of composition
1523+ * with Tx is a new transform Cx'. Cx' becomes the current
1524+ * transform for this Graphics2D.
1525+ * Transforming a point p by the updated transform Cx' is
1526+ * equivalent to first transforming p by Tx and then transforming
1527+ * the result by the original transform Cx. In other words,
1528+ * Cx'(p) = Cx(Tx(p)).
1529+ * A copy of the Tx is made, if necessary, so further
1530+ * modifications to Tx do not affect rendering.
1531+ * @param Tx The Transform object to be composed with the current
1532+ * transform.
1533+ * @see #setTransform
1534+ * @see TransformChain
1535+ * @see AffineTransform
1536+ */
1537+ public void transform(AffineTransform Tx) {
1538+ mGraphics.transform(Tx);
1539+ }
1540+
1541+ /**
1542+ * Sets the Transform in the current graphics state.
1543+ * @param Tx The Transform object to be used in the rendering process.
1544+ * @see #transform
1545+ * @see TransformChain
1546+ * @see AffineTransform
1547+ */
1548+ public void setTransform(AffineTransform Tx) {
1549+ mGraphics.setTransform(Tx);
1550+ }
1551+
1552+ /**
1553+ * Returns the current Transform in the Graphics2D state.
1554+ * @see #transform
1555+ * @see #setTransform
1556+ */
1557+ public AffineTransform getTransform() {
1558+ return mGraphics.getTransform();
1559+ }
1560+
1561+ /**
1562+ * Returns the current Paint in the Graphics2D state.
1563+ * @see #setPaint
1564+ * @see java.awt.Graphics#setColor
1565+ */
1566+ public Paint getPaint() {
1567+ return mGraphics.getPaint();
1568+ }
1569+
1570+ /**
1571+ * Returns the current Composite in the Graphics2D state.
1572+ * @see #setComposite
1573+ */
1574+ public Composite getComposite() {
1575+ return mGraphics.getComposite();
1576+ }
1577+
1578+ /**
1579+ * Sets the background color in this context used for clearing a region.
1580+ * When Graphics2D is constructed for a component, the backgroung color is
1581+ * inherited from the component. Setting the background color in the
1582+ * Graphics2D context only affects the subsequent clearRect() calls and
1583+ * not the background color of the component. To change the background
1584+ * of the component, use appropriate methods of the component.
1585+ * @param color The background color that should be used in
1586+ * subsequent calls to clearRect().
1587+ * @see getBackground
1588+ * @see Graphics.clearRect()
1589+ */
1590+ public void setBackground(Color color) {
1591+ mGraphics.setBackground(color);
1592+ }
1593+
1594+ /**
1595+ * Returns the background color used for clearing a region.
1596+ * @see setBackground
1597+ */
1598+ public Color getBackground() {
1599+ return mGraphics.getBackground();
1600+ }
1601+
1602+ /**
1603+ * Returns the current Stroke in the Graphics2D state.
1604+ * @see setStroke
1605+ */
1606+ public Stroke getStroke() {
1607+ return mGraphics.getStroke();
1608+ }
1609+
1610+ /**
1611+ * Intersects the current clip with the interior of the specified Shape
1612+ * and sets the current clip to the resulting intersection.
1613+ * The indicated shape is transformed with the current transform in the
1614+ * Graphics2D state before being intersected with the current clip.
1615+ * This method is used to make the current clip smaller.
1616+ * To make the clip larger, use any setClip method.
1617+ * @param s The Shape to be intersected with the current clip.
1618+ */
1619+ public void clip(Shape s) {
1620+ mGraphics.clip(s);
1621+ }
1622+}