|
1 /* |
|
2 * Copyright 2000-2007 Sun Microsystems, Inc. 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. Sun designates this |
|
8 * particular file as subject to the "Classpath" exception as provided |
|
9 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara, |
|
22 * CA 95054 USA or visit www.sun.com if you need additional information or |
|
23 * have any questions. |
|
24 */ |
|
25 |
|
26 package sun.print; |
|
27 |
|
28 import java.awt.Color; |
|
29 import java.awt.Font; |
|
30 import java.awt.FontMetrics; |
|
31 import java.awt.Graphics; |
|
32 import java.awt.Image; |
|
33 import java.awt.Polygon; |
|
34 import java.awt.Rectangle; |
|
35 import java.awt.Shape; |
|
36 |
|
37 import java.awt.image.ImageObserver; |
|
38 |
|
39 import java.text.AttributedCharacterIterator; |
|
40 |
|
41 /** |
|
42 * Implements the Graphics API but does all |
|
43 * rendering through a second Graphics instance. |
|
44 * The primary use of this class is to provide |
|
45 * a Graphics instance without the 2D API to |
|
46 * an application, but to implement the rendering |
|
47 * with a Graphics2D instance. |
|
48 */ |
|
49 public class ProxyGraphics extends Graphics { |
|
50 |
|
51 /** |
|
52 * The Graphics instance that performs the |
|
53 * drawing for this Graphics. |
|
54 */ |
|
55 private Graphics g; |
|
56 |
|
57 public ProxyGraphics(Graphics graphics) { |
|
58 g = graphics; |
|
59 } |
|
60 |
|
61 Graphics getGraphics() { |
|
62 return g; |
|
63 } |
|
64 |
|
65 /** |
|
66 * Creates a new <code>Graphics</code> object that is |
|
67 * a copy of this <code>Graphics</code> object. |
|
68 * @return a new graphics context that is a copy of |
|
69 * this graphics context. |
|
70 */ |
|
71 public Graphics create() { |
|
72 return new ProxyGraphics(g.create()); |
|
73 } |
|
74 |
|
75 /** |
|
76 * Creates a new <code>Graphics</code> object based on this |
|
77 * <code>Graphics</code> object, but with a new translation and clip area. |
|
78 * The new <code>Graphics</code> object has its origin |
|
79 * translated to the specified point (<i>x</i>, <i>y</i>). |
|
80 * Its clip area is determined by the intersection of the original |
|
81 * clip area with the specified rectangle. The arguments are all |
|
82 * interpreted in the coordinate system of the original |
|
83 * <code>Graphics</code> object. The new graphics context is |
|
84 * identical to the original, except in two respects: |
|
85 * <p> |
|
86 * <ul> |
|
87 * <li> |
|
88 * The new graphics context is translated by (<i>x</i>, <i>y</i>). |
|
89 * That is to say, the point (<code>0</code>, <code>0</code>) in the |
|
90 * new graphics context is the same as (<i>x</i>, <i>y</i>) in |
|
91 * the original graphics context. |
|
92 * <li> |
|
93 * The new graphics context has an additional clipping rectangle, in |
|
94 * addition to whatever (translated) clipping rectangle it inherited |
|
95 * from the original graphics context. The origin of the new clipping |
|
96 * rectangle is at (<code>0</code>, <code>0</code>), and its size |
|
97 * is specified by the <code>width</code> and <code>height</code> |
|
98 * arguments. |
|
99 * </ul> |
|
100 * <p> |
|
101 * @param x the <i>x</i> coordinate. |
|
102 * @param y the <i>y</i> coordinate. |
|
103 * @param width the width of the clipping rectangle. |
|
104 * @param height the height of the clipping rectangle. |
|
105 * @return a new graphics context. |
|
106 * @see java.awt.Graphics#translate |
|
107 * @see java.awt.Graphics#clipRect |
|
108 */ |
|
109 public Graphics create(int x, int y, int width, int height) { |
|
110 return new ProxyGraphics(g.create(x, y, width, height)); |
|
111 } |
|
112 |
|
113 /** |
|
114 * Translates the origin of the graphics context to the point |
|
115 * (<i>x</i>, <i>y</i>) in the current coordinate system. |
|
116 * Modifies this graphics context so that its new origin corresponds |
|
117 * to the point (<i>x</i>, <i>y</i>) in this graphics context's |
|
118 * original coordinate system. All coordinates used in subsequent |
|
119 * rendering operations on this graphics context will be relative |
|
120 * to this new origin. |
|
121 * @param x the <i>x</i> coordinate. |
|
122 * @param y the <i>y</i> coordinate. |
|
123 */ |
|
124 public void translate(int x, int y) { |
|
125 g.translate(x, y); |
|
126 } |
|
127 |
|
128 /** |
|
129 * Gets this graphics context's current color. |
|
130 * @return this graphics context's current color. |
|
131 * @see java.awt.Color |
|
132 * @see java.awt.Graphics#setColor |
|
133 */ |
|
134 public Color getColor() { |
|
135 return g.getColor(); |
|
136 } |
|
137 |
|
138 /** |
|
139 * Sets this graphics context's current color to the specified |
|
140 * color. All subsequent graphics operations using this graphics |
|
141 * context use this specified color. |
|
142 * @param c the new rendering color. |
|
143 * @see java.awt.Color |
|
144 * @see java.awt.Graphics#getColor |
|
145 */ |
|
146 public void setColor(Color c) { |
|
147 g.setColor(c); |
|
148 } |
|
149 |
|
150 /** |
|
151 * Sets the paint mode of this graphics context to overwrite the |
|
152 * destination with this graphics context's current color. |
|
153 * This sets the logical pixel operation function to the paint or |
|
154 * overwrite mode. All subsequent rendering operations will |
|
155 * overwrite the destination with the current color. |
|
156 */ |
|
157 public void setPaintMode() { |
|
158 g.setPaintMode(); |
|
159 } |
|
160 |
|
161 /** |
|
162 * Sets the paint mode of this graphics context to alternate between |
|
163 * this graphics context's current color and the new specified color. |
|
164 * This specifies that logical pixel operations are performed in the |
|
165 * XOR mode, which alternates pixels between the current color and |
|
166 * a specified XOR color. |
|
167 * <p> |
|
168 * When drawing operations are performed, pixels which are the |
|
169 * current color are changed to the specified color, and vice versa. |
|
170 * <p> |
|
171 * Pixels that are of colors other than those two colors are changed |
|
172 * in an unpredictable but reversible manner; if the same figure is |
|
173 * drawn twice, then all pixels are restored to their original values. |
|
174 * @param c1 the XOR alternation color |
|
175 */ |
|
176 public void setXORMode(Color c1) { |
|
177 g.setXORMode(c1); |
|
178 } |
|
179 |
|
180 /** |
|
181 * Gets the current font. |
|
182 * @return this graphics context's current font. |
|
183 * @see java.awt.Font |
|
184 * @see java.awt.Graphics#setFont |
|
185 */ |
|
186 public Font getFont() { |
|
187 return g.getFont(); |
|
188 } |
|
189 |
|
190 /** |
|
191 * Sets this graphics context's font to the specified font. |
|
192 * All subsequent text operations using this graphics context |
|
193 * use this font. |
|
194 * @param font the font. |
|
195 * @see java.awt.Graphics#getFont |
|
196 * @see java.awt.Graphics#drawString(java.lang.String, int, int) |
|
197 * @see java.awt.Graphics#drawBytes(byte[], int, int, int, int) |
|
198 * @see java.awt.Graphics#drawChars(char[], int, int, int, int) |
|
199 */ |
|
200 public void setFont(Font font) { |
|
201 g.setFont(font); |
|
202 } |
|
203 |
|
204 /** |
|
205 * Gets the font metrics of the current font. |
|
206 * @return the font metrics of this graphics |
|
207 * context's current font. |
|
208 * @see java.awt.Graphics#getFont |
|
209 * @see java.awt.FontMetrics |
|
210 * @see java.awt.Graphics#getFontMetrics(Font) |
|
211 */ |
|
212 public FontMetrics getFontMetrics() { |
|
213 return g.getFontMetrics(); |
|
214 } |
|
215 |
|
216 /** |
|
217 * Gets the font metrics for the specified font. |
|
218 * @return the font metrics for the specified font. |
|
219 * @param f the specified font |
|
220 * @see java.awt.Graphics#getFont |
|
221 * @see java.awt.FontMetrics |
|
222 * @see java.awt.Graphics#getFontMetrics() |
|
223 */ |
|
224 public FontMetrics getFontMetrics(Font f) { |
|
225 return g.getFontMetrics(f); |
|
226 } |
|
227 |
|
228 |
|
229 /** |
|
230 * Returns the bounding rectangle of the current clipping area. |
|
231 * This method refers to the user clip, which is independent of the |
|
232 * clipping associated with device bounds and window visibility. |
|
233 * If no clip has previously been set, or if the clip has been |
|
234 * cleared using <code>setClip(null)</code>, this method returns |
|
235 * <code>null</code>. |
|
236 * The coordinates in the rectangle are relative to the coordinate |
|
237 * system origin of this graphics context. |
|
238 * @return the bounding rectangle of the current clipping area, |
|
239 * or <code>null</code> if no clip is set. |
|
240 * @see java.awt.Graphics#getClip |
|
241 * @see java.awt.Graphics#clipRect |
|
242 * @see java.awt.Graphics#setClip(int, int, int, int) |
|
243 * @see java.awt.Graphics#setClip(Shape) |
|
244 * @since JDK1.1 |
|
245 */ |
|
246 public Rectangle getClipBounds() { |
|
247 return g.getClipBounds(); |
|
248 } |
|
249 |
|
250 /** |
|
251 * Intersects the current clip with the specified rectangle. |
|
252 * The resulting clipping area is the intersection of the current |
|
253 * clipping area and the specified rectangle. If there is no |
|
254 * current clipping area, either because the clip has never been |
|
255 * set, or the clip has been cleared using <code>setClip(null)</code>, |
|
256 * the specified rectangle becomes the new clip. |
|
257 * This method sets the user clip, which is independent of the |
|
258 * clipping associated with device bounds and window visibility. |
|
259 * This method can only be used to make the current clip smaller. |
|
260 * To set the current clip larger, use any of the setClip methods. |
|
261 * Rendering operations have no effect outside of the clipping area. |
|
262 * @param x the x coordinate of the rectangle to intersect the clip with |
|
263 * @param y the y coordinate of the rectangle to intersect the clip with |
|
264 * @param width the width of the rectangle to intersect the clip with |
|
265 * @param height the height of the rectangle to intersect the clip with |
|
266 * @see #setClip(int, int, int, int) |
|
267 * @see #setClip(Shape) |
|
268 */ |
|
269 public void clipRect(int x, int y, int width, int height) { |
|
270 g.clipRect(x, y, width, height); |
|
271 } |
|
272 |
|
273 /** |
|
274 * Sets the current clip to the rectangle specified by the given |
|
275 * coordinates. This method sets the user clip, which is |
|
276 * independent of the clipping associated with device bounds |
|
277 * and window visibility. |
|
278 * Rendering operations have no effect outside of the clipping area. |
|
279 * @param x the <i>x</i> coordinate of the new clip rectangle. |
|
280 * @param y the <i>y</i> coordinate of the new clip rectangle. |
|
281 * @param width the width of the new clip rectangle. |
|
282 * @param height the height of the new clip rectangle. |
|
283 * @see java.awt.Graphics#clipRect |
|
284 * @see java.awt.Graphics#setClip(Shape) |
|
285 * @since JDK1.1 |
|
286 */ |
|
287 public void setClip(int x, int y, int width, int height) { |
|
288 g.setClip(x, y, width, height); |
|
289 } |
|
290 |
|
291 /** |
|
292 * Gets the current clipping area. |
|
293 * This method returns the user clip, which is independent of the |
|
294 * clipping associated with device bounds and window visibility. |
|
295 * If no clip has previously been set, or if the clip has been |
|
296 * cleared using <code>setClip(null)</code>, this method returns |
|
297 * <code>null</code>. |
|
298 * @return a <code>Shape</code> object representing the |
|
299 * current clipping area, or <code>null</code> if |
|
300 * no clip is set. |
|
301 * @see java.awt.Graphics#getClipBounds |
|
302 * @see java.awt.Graphics#clipRect |
|
303 * @see java.awt.Graphics#setClip(int, int, int, int) |
|
304 * @see java.awt.Graphics#setClip(Shape) |
|
305 * @since JDK1.1 |
|
306 */ |
|
307 public Shape getClip() { |
|
308 return g.getClip(); |
|
309 } |
|
310 |
|
311 /** |
|
312 * Sets the current clipping area to an arbitrary clip shape. |
|
313 * Not all objects that implement the <code>Shape</code> |
|
314 * interface can be used to set the clip. The only |
|
315 * <code>Shape</code> objects that are guaranteed to be |
|
316 * supported are <code>Shape</code> objects that are |
|
317 * obtained via the <code>getClip</code> method and via |
|
318 * <code>Rectangle</code> objects. This method sets the |
|
319 * user clip, which is independent of the clipping associated |
|
320 * with device bounds and window visibility. |
|
321 * @param clip the <code>Shape</code> to use to set the clip |
|
322 * @see java.awt.Graphics#getClip() |
|
323 * @see java.awt.Graphics#clipRect |
|
324 * @see java.awt.Graphics#setClip(int, int, int, int) |
|
325 * @since JDK1.1 |
|
326 */ |
|
327 public void setClip(Shape clip) { |
|
328 g.setClip(clip); |
|
329 } |
|
330 |
|
331 /** |
|
332 * Copies an area of the component by a distance specified by |
|
333 * <code>dx</code> and <code>dy</code>. From the point specified |
|
334 * by <code>x</code> and <code>y</code>, this method |
|
335 * copies downwards and to the right. To copy an area of the |
|
336 * component to the left or upwards, specify a negative value for |
|
337 * <code>dx</code> or <code>dy</code>. |
|
338 * If a portion of the source rectangle lies outside the bounds |
|
339 * of the component, or is obscured by another window or component, |
|
340 * <code>copyArea</code> will be unable to copy the associated |
|
341 * pixels. The area that is omitted can be refreshed by calling |
|
342 * the component's <code>paint</code> method. |
|
343 * @param x the <i>x</i> coordinate of the source rectangle. |
|
344 * @param y the <i>y</i> coordinate of the source rectangle. |
|
345 * @param width the width of the source rectangle. |
|
346 * @param height the height of the source rectangle. |
|
347 * @param dx the horizontal distance to copy the pixels. |
|
348 * @param dy the vertical distance to copy the pixels. |
|
349 */ |
|
350 public void copyArea(int x, int y, int width, int height, |
|
351 int dx, int dy) { |
|
352 g.copyArea(x, y, width, height, dx, dy); |
|
353 } |
|
354 |
|
355 /** |
|
356 * Draws a line, using the current color, between the points |
|
357 * <code>(x1, y1)</code> and <code>(x2, y2)</code> |
|
358 * in this graphics context's coordinate system. |
|
359 * @param x1 the first point's <i>x</i> coordinate. |
|
360 * @param y1 the first point's <i>y</i> coordinate. |
|
361 * @param x2 the second point's <i>x</i> coordinate. |
|
362 * @param y2 the second point's <i>y</i> coordinate. |
|
363 */ |
|
364 public void drawLine(int x1, int y1, int x2, int y2) { |
|
365 g.drawLine(x1, y1, x2, y2); |
|
366 } |
|
367 |
|
368 /** |
|
369 * Fills the specified rectangle. |
|
370 * The left and right edges of the rectangle are at |
|
371 * <code>x</code> and <code>x + width - 1</code>. |
|
372 * The top and bottom edges are at |
|
373 * <code>y</code> and <code>y + height - 1</code>. |
|
374 * The resulting rectangle covers an area |
|
375 * <code>width</code> pixels wide by |
|
376 * <code>height</code> pixels tall. |
|
377 * The rectangle is filled using the graphics context's current color. |
|
378 * @param x the <i>x</i> coordinate |
|
379 * of the rectangle to be filled. |
|
380 * @param y the <i>y</i> coordinate |
|
381 * of the rectangle to be filled. |
|
382 * @param width the width of the rectangle to be filled. |
|
383 * @param height the height of the rectangle to be filled. |
|
384 * @see java.awt.Graphics#clearRect |
|
385 * @see java.awt.Graphics#drawRect |
|
386 */ |
|
387 public void fillRect(int x, int y, int width, int height) { |
|
388 g.fillRect(x, y, width, height); |
|
389 } |
|
390 |
|
391 /** |
|
392 * Draws the outline of the specified rectangle. |
|
393 * The left and right edges of the rectangle are at |
|
394 * <code>x</code> and <code>x + width</code>. |
|
395 * The top and bottom edges are at |
|
396 * <code>y</code> and <code>y + height</code>. |
|
397 * The rectangle is drawn using the graphics context's current color. |
|
398 * @param x the <i>x</i> coordinate |
|
399 * of the rectangle to be drawn. |
|
400 * @param y the <i>y</i> coordinate |
|
401 * of the rectangle to be drawn. |
|
402 * @param width the width of the rectangle to be drawn. |
|
403 * @param height the height of the rectangle to be drawn. |
|
404 * @see java.awt.Graphics#fillRect |
|
405 * @see java.awt.Graphics#clearRect |
|
406 */ |
|
407 public void drawRect(int x, int y, int width, int height) { |
|
408 g.drawRect(x, y, width, height); |
|
409 } |
|
410 |
|
411 /** |
|
412 * Clears the specified rectangle by filling it with the background |
|
413 * color of the current drawing surface. This operation does not |
|
414 * use the current paint mode. |
|
415 * <p> |
|
416 * Beginning with Java 1.1, the background color |
|
417 * of offscreen images may be system dependent. Applications should |
|
418 * use <code>setColor</code> followed by <code>fillRect</code> to |
|
419 * ensure that an offscreen image is cleared to a specific color. |
|
420 * @param x the <i>x</i> coordinate of the rectangle to clear. |
|
421 * @param y the <i>y</i> coordinate of the rectangle to clear. |
|
422 * @param width the width of the rectangle to clear. |
|
423 * @param height the height of the rectangle to clear. |
|
424 * @see java.awt.Graphics#fillRect(int, int, int, int) |
|
425 * @see java.awt.Graphics#drawRect |
|
426 * @see java.awt.Graphics#setColor(java.awt.Color) |
|
427 * @see java.awt.Graphics#setPaintMode |
|
428 * @see java.awt.Graphics#setXORMode(java.awt.Color) |
|
429 */ |
|
430 public void clearRect(int x, int y, int width, int height) { |
|
431 g.clearRect(x, y, width, height); |
|
432 } |
|
433 |
|
434 /** |
|
435 * Draws an outlined round-cornered rectangle using this graphics |
|
436 * context's current color. The left and right edges of the rectangle |
|
437 * are at <code>x</code> and <code>x + width</code>, |
|
438 * respectively. The top and bottom edges of the rectangle are at |
|
439 * <code>y</code> and <code>y + height</code>. |
|
440 * @param x the <i>x</i> coordinate of the rectangle to be drawn. |
|
441 * @param y the <i>y</i> coordinate of the rectangle to be drawn. |
|
442 * @param width the width of the rectangle to be drawn. |
|
443 * @param height the height of the rectangle to be drawn. |
|
444 * @param arcWidth the horizontal diameter of the arc |
|
445 * at the four corners. |
|
446 * @param arcHeight the vertical diameter of the arc |
|
447 * at the four corners. |
|
448 * @see java.awt.Graphics#fillRoundRect |
|
449 */ |
|
450 public void drawRoundRect(int x, int y, int width, int height, |
|
451 int arcWidth, int arcHeight) { |
|
452 g.drawRoundRect(x, y, width, height, arcWidth, arcHeight); |
|
453 } |
|
454 |
|
455 /** |
|
456 * Fills the specified rounded corner rectangle with the current color. |
|
457 * The left and right edges of the rectangle |
|
458 * are at <code>x</code> and <code>x + width - 1</code>, |
|
459 * respectively. The top and bottom edges of the rectangle are at |
|
460 * <code>y</code> and <code>y + height - 1</code>. |
|
461 * @param x the <i>x</i> coordinate of the rectangle to be filled. |
|
462 * @param y the <i>y</i> coordinate of the rectangle to be filled. |
|
463 * @param width the width of the rectangle to be filled. |
|
464 * @param height the height of the rectangle to be filled. |
|
465 * @param arcWidth the horizontal diameter |
|
466 * of the arc at the four corners. |
|
467 * @param arcHeight the vertical diameter |
|
468 * of the arc at the four corners. |
|
469 * @see java.awt.Graphics#drawRoundRect |
|
470 */ |
|
471 public void fillRoundRect(int x, int y, int width, int height, |
|
472 int arcWidth, int arcHeight) { |
|
473 g.fillRoundRect(x, y, width, height, arcWidth, arcHeight); |
|
474 } |
|
475 |
|
476 /** |
|
477 * Draws a 3-D highlighted outline of the specified rectangle. |
|
478 * The edges of the rectangle are highlighted so that they |
|
479 * appear to be beveled and lit from the upper left corner. |
|
480 * <p> |
|
481 * The colors used for the highlighting effect are determined |
|
482 * based on the current color. |
|
483 * The resulting rectangle covers an area that is |
|
484 * <code>width + 1</code> pixels wide |
|
485 * by <code>height + 1</code> pixels tall. |
|
486 * @param x the <i>x</i> coordinate of the rectangle to be drawn. |
|
487 * @param y the <i>y</i> coordinate of the rectangle to be drawn. |
|
488 * @param width the width of the rectangle to be drawn. |
|
489 * @param height the height of the rectangle to be drawn. |
|
490 * @param raised a boolean that determines whether the rectangle |
|
491 * appears to be raised above the surface |
|
492 * or sunk into the surface. |
|
493 * @see java.awt.Graphics#fill3DRect |
|
494 */ |
|
495 public void draw3DRect(int x, int y, int width, int height, |
|
496 boolean raised) { |
|
497 g.draw3DRect(x, y, width, height, raised); |
|
498 } |
|
499 |
|
500 /** |
|
501 * Paints a 3-D highlighted rectangle filled with the current color. |
|
502 * The edges of the rectangle will be highlighted so that it appears |
|
503 * as if the edges were beveled and lit from the upper left corner. |
|
504 * The colors used for the highlighting effect will be determined from |
|
505 * the current color. |
|
506 * @param x the <i>x</i> coordinate of the rectangle to be filled. |
|
507 * @param y the <i>y</i> coordinate of the rectangle to be filled. |
|
508 * @param width the width of the rectangle to be filled. |
|
509 * @param height the height of the rectangle to be filled. |
|
510 * @param raised a boolean value that determines whether the |
|
511 * rectangle appears to be raised above the surface |
|
512 * or etched into the surface. |
|
513 * @see java.awt.Graphics#draw3DRect |
|
514 */ |
|
515 public void fill3DRect(int x, int y, int width, int height, |
|
516 boolean raised) { |
|
517 g.fill3DRect(x, y, width, height, raised); |
|
518 } |
|
519 |
|
520 /** |
|
521 * Draws the outline of an oval. |
|
522 * The result is a circle or ellipse that fits within the |
|
523 * rectangle specified by the <code>x</code>, <code>y</code>, |
|
524 * <code>width</code>, and <code>height</code> arguments. |
|
525 * <p> |
|
526 * The oval covers an area that is |
|
527 * <code>width + 1</code> pixels wide |
|
528 * and <code>height + 1</code> pixels tall. |
|
529 * @param x the <i>x</i> coordinate of the upper left |
|
530 * corner of the oval to be drawn. |
|
531 * @param y the <i>y</i> coordinate of the upper left |
|
532 * corner of the oval to be drawn. |
|
533 * @param width the width of the oval to be drawn. |
|
534 * @param height the height of the oval to be drawn. |
|
535 * @see java.awt.Graphics#fillOval |
|
536 */ |
|
537 public void drawOval(int x, int y, int width, int height) { |
|
538 g.drawOval(x, y, width, height); |
|
539 } |
|
540 |
|
541 /** |
|
542 * Fills an oval bounded by the specified rectangle with the |
|
543 * current color. |
|
544 * @param x the <i>x</i> coordinate of the upper left corner |
|
545 * of the oval to be filled. |
|
546 * @param y the <i>y</i> coordinate of the upper left corner |
|
547 * of the oval to be filled. |
|
548 * @param width the width of the oval to be filled. |
|
549 * @param height the height of the oval to be filled. |
|
550 * @see java.awt.Graphics#drawOval |
|
551 */ |
|
552 public void fillOval(int x, int y, int width, int height) { |
|
553 g.fillOval(x, y, width, height); |
|
554 } |
|
555 |
|
556 /** |
|
557 * Draws the outline of a circular or elliptical arc |
|
558 * covering the specified rectangle. |
|
559 * <p> |
|
560 * The resulting arc begins at <code>startAngle</code> and extends |
|
561 * for <code>arcAngle</code> degrees, using the current color. |
|
562 * Angles are interpreted such that 0 degrees |
|
563 * is at the 3 o'clock position. |
|
564 * A positive value indicates a counter-clockwise rotation |
|
565 * while a negative value indicates a clockwise rotation. |
|
566 * <p> |
|
567 * The center of the arc is the center of the rectangle whose origin |
|
568 * is (<i>x</i>, <i>y</i>) and whose size is specified by the |
|
569 * <code>width</code> and <code>height</code> arguments. |
|
570 * <p> |
|
571 * The resulting arc covers an area |
|
572 * <code>width + 1</code> pixels wide |
|
573 * by <code>height + 1</code> pixels tall. |
|
574 * <p> |
|
575 * The angles are specified relative to the non-square extents of |
|
576 * the bounding rectangle such that 45 degrees always falls on the |
|
577 * line from the center of the ellipse to the upper right corner of |
|
578 * the bounding rectangle. As a result, if the bounding rectangle is |
|
579 * noticeably longer in one axis than the other, the angles to the |
|
580 * start and end of the arc segment will be skewed farther along the |
|
581 * longer axis of the bounds. |
|
582 * @param x the <i>x</i> coordinate of the |
|
583 * upper-left corner of the arc to be drawn. |
|
584 * @param y the <i>y</i> coordinate of the |
|
585 * upper-left corner of the arc to be drawn. |
|
586 * @param width the width of the arc to be drawn. |
|
587 * @param height the height of the arc to be drawn. |
|
588 * @param startAngle the beginning angle. |
|
589 * @param arcAngle the angular extent of the arc, |
|
590 * relative to the start angle. |
|
591 * @see java.awt.Graphics#fillArc |
|
592 */ |
|
593 public void drawArc(int x, int y, int width, int height, |
|
594 int startAngle, int arcAngle) { |
|
595 g.drawArc(x, y, width, height, startAngle, arcAngle); |
|
596 } |
|
597 |
|
598 /** |
|
599 * Fills a circular or elliptical arc covering the specified rectangle. |
|
600 * <p> |
|
601 * The resulting arc begins at <code>startAngle</code> and extends |
|
602 * for <code>arcAngle</code> degrees. |
|
603 * Angles are interpreted such that 0 degrees |
|
604 * is at the 3 o'clock position. |
|
605 * A positive value indicates a counter-clockwise rotation |
|
606 * while a negative value indicates a clockwise rotation. |
|
607 * <p> |
|
608 * The center of the arc is the center of the rectangle whose origin |
|
609 * is (<i>x</i>, <i>y</i>) and whose size is specified by the |
|
610 * <code>width</code> and <code>height</code> arguments. |
|
611 * <p> |
|
612 * The resulting arc covers an area |
|
613 * <code>width + 1</code> pixels wide |
|
614 * by <code>height + 1</code> pixels tall. |
|
615 * <p> |
|
616 * The angles are specified relative to the non-square extents of |
|
617 * the bounding rectangle such that 45 degrees always falls on the |
|
618 * line from the center of the ellipse to the upper right corner of |
|
619 * the bounding rectangle. As a result, if the bounding rectangle is |
|
620 * noticeably longer in one axis than the other, the angles to the |
|
621 * start and end of the arc segment will be skewed farther along the |
|
622 * longer axis of the bounds. |
|
623 * @param x the <i>x</i> coordinate of the |
|
624 * upper-left corner of the arc to be filled. |
|
625 * @param y the <i>y</i> coordinate of the |
|
626 * upper-left corner of the arc to be filled. |
|
627 * @param width the width of the arc to be filled. |
|
628 * @param height the height of the arc to be filled. |
|
629 * @param startAngle the beginning angle. |
|
630 * @param arcAngle the angular extent of the arc, |
|
631 * relative to the start angle. |
|
632 * @see java.awt.Graphics#drawArc |
|
633 */ |
|
634 public void fillArc(int x, int y, int width, int height, |
|
635 int startAngle, int arcAngle) { |
|
636 |
|
637 g.fillArc(x, y, width, height, startAngle, arcAngle); |
|
638 } |
|
639 |
|
640 /** |
|
641 * Draws a sequence of connected lines defined by |
|
642 * arrays of <i>x</i> and <i>y</i> coordinates. |
|
643 * Each pair of (<i>x</i>, <i>y</i>) coordinates defines a point. |
|
644 * The figure is not closed if the first point |
|
645 * differs from the last point. |
|
646 * @param xPoints an array of <i>x</i> points |
|
647 * @param yPoints an array of <i>y</i> points |
|
648 * @param nPoints the total number of points |
|
649 * @see java.awt.Graphics#drawPolygon(int[], int[], int) |
|
650 * @since JDK1.1 |
|
651 */ |
|
652 public void drawPolyline(int xPoints[], int yPoints[], |
|
653 int nPoints) { |
|
654 g.drawPolyline(xPoints, yPoints, nPoints); |
|
655 } |
|
656 |
|
657 /** |
|
658 * Draws a closed polygon defined by |
|
659 * arrays of <i>x</i> and <i>y</i> coordinates. |
|
660 * Each pair of (<i>x</i>, <i>y</i>) coordinates defines a point. |
|
661 * <p> |
|
662 * This method draws the polygon defined by <code>nPoint</code> line |
|
663 * segments, where the first <code>nPoint - 1</code> |
|
664 * line segments are line segments from |
|
665 * <code>(xPoints[i - 1], yPoints[i - 1])</code> |
|
666 * to <code>(xPoints[i], yPoints[i])</code>, for |
|
667 * 1 ≤ <i>i</i> ≤ <code>nPoints</code>. |
|
668 * The figure is automatically closed by drawing a line connecting |
|
669 * the final point to the first point, if those points are different. |
|
670 * @param xPoints a an array of <code>x</code> coordinates. |
|
671 * @param yPoints a an array of <code>y</code> coordinates. |
|
672 * @param nPoints a the total number of points. |
|
673 * @see java.awt.Graphics#fillPolygon |
|
674 * @see java.awt.Graphics#drawPolyline |
|
675 */ |
|
676 public void drawPolygon(int xPoints[], int yPoints[], |
|
677 int nPoints) { |
|
678 g.drawPolygon(xPoints, yPoints, nPoints); |
|
679 } |
|
680 |
|
681 /** |
|
682 * Draws the outline of a polygon defined by the specified |
|
683 * <code>Polygon</code> object. |
|
684 * @param p the polygon to draw. |
|
685 * @see java.awt.Graphics#fillPolygon |
|
686 * @see java.awt.Graphics#drawPolyline |
|
687 */ |
|
688 public void drawPolygon(Polygon p) { |
|
689 g.drawPolygon(p); |
|
690 } |
|
691 |
|
692 /** |
|
693 * Fills a closed polygon defined by |
|
694 * arrays of <i>x</i> and <i>y</i> coordinates. |
|
695 * <p> |
|
696 * This method draws the polygon defined by <code>nPoint</code> line |
|
697 * segments, where the first <code>nPoint - 1</code> |
|
698 * line segments are line segments from |
|
699 * <code>(xPoints[i - 1], yPoints[i - 1])</code> |
|
700 * to <code>(xPoints[i], yPoints[i])</code>, for |
|
701 * 1 ≤ <i>i</i> ≤ <code>nPoints</code>. |
|
702 * The figure is automatically closed by drawing a line connecting |
|
703 * the final point to the first point, if those points are different. |
|
704 * <p> |
|
705 * The area inside the polygon is defined using an |
|
706 * even-odd fill rule, also known as the alternating rule. |
|
707 * @param xPoints a an array of <code>x</code> coordinates. |
|
708 * @param yPoints a an array of <code>y</code> coordinates. |
|
709 * @param nPoints a the total number of points. |
|
710 * @see java.awt.Graphics#drawPolygon(int[], int[], int) |
|
711 */ |
|
712 public void fillPolygon(int xPoints[], int yPoints[], |
|
713 int nPoints) { |
|
714 g.fillPolygon(xPoints, yPoints, nPoints); |
|
715 } |
|
716 |
|
717 /** |
|
718 * Fills the polygon defined by the specified Polygon object with |
|
719 * the graphics context's current color. |
|
720 * <p> |
|
721 * The area inside the polygon is defined using an |
|
722 * even-odd fill rule, also known as the alternating rule. |
|
723 * @param p the polygon to fill. |
|
724 * @see java.awt.Graphics#drawPolygon(int[], int[], int) |
|
725 */ |
|
726 public void fillPolygon(Polygon p) { |
|
727 g.fillPolygon(p); |
|
728 } |
|
729 |
|
730 /** |
|
731 * Draws the text given by the specified string, using this |
|
732 * graphics context's current font and color. The baseline of the |
|
733 * leftmost character is at position (<i>x</i>, <i>y</i>) in this |
|
734 * graphics context's coordinate system. |
|
735 * @param str the string to be drawn. |
|
736 * @param x the <i>x</i> coordinate. |
|
737 * @param y the <i>y</i> coordinate. |
|
738 * @see java.awt.Graphics#drawBytes |
|
739 * @see java.awt.Graphics#drawChars |
|
740 */ |
|
741 public void drawString(String str, int x, int y) { |
|
742 g.drawString(str, x, y); |
|
743 } |
|
744 |
|
745 /** |
|
746 * Draws the text given by the specified iterator, using this |
|
747 * graphics context's current color. The iterator has to specify a font |
|
748 * for each character. The baseline of the |
|
749 * leftmost character is at position (<i>x</i>, <i>y</i>) in this |
|
750 * graphics context's coordinate system. |
|
751 * @param iterator the iterator whose text is to be drawn |
|
752 * @param x the <i>x</i> coordinate. |
|
753 * @param y the <i>y</i> coordinate. |
|
754 * @see java.awt.Graphics#drawBytes |
|
755 * @see java.awt.Graphics#drawChars |
|
756 */ |
|
757 public void drawString(AttributedCharacterIterator iterator, |
|
758 int x, int y) { |
|
759 g.drawString(iterator, x, y); |
|
760 } |
|
761 |
|
762 /** |
|
763 * Draws the text given by the specified character array, using this |
|
764 * graphics context's current font and color. The baseline of the |
|
765 * first character is at position (<i>x</i>, <i>y</i>) in this |
|
766 * graphics context's coordinate system. |
|
767 * @param data the array of characters to be drawn |
|
768 * @param offset the start offset in the data |
|
769 * @param length the number of characters to be drawn |
|
770 * @param x the <i>x</i> coordinate of the baseline of the text |
|
771 * @param y the <i>y</i> coordinate of the baseline of the text |
|
772 * @see java.awt.Graphics#drawBytes |
|
773 * @see java.awt.Graphics#drawString |
|
774 */ |
|
775 public void drawChars(char data[], int offset, int length, int x, int y) { |
|
776 g.drawChars(data, offset, length, x, y); |
|
777 } |
|
778 |
|
779 /** |
|
780 * Draws the text given by the specified byte array, using this |
|
781 * graphics context's current font and color. The baseline of the |
|
782 * first character is at position (<i>x</i>, <i>y</i>) in this |
|
783 * graphics context's coordinate system. |
|
784 * @param data the data to be drawn |
|
785 * @param offset the start offset in the data |
|
786 * @param length the number of bytes that are drawn |
|
787 * @param x the <i>x</i> coordinate of the baseline of the text |
|
788 * @param y the <i>y</i> coordinate of the baseline of the text |
|
789 * @see java.awt.Graphics#drawChars |
|
790 * @see java.awt.Graphics#drawString |
|
791 */ |
|
792 public void drawBytes(byte data[], int offset, int length, int x, int y) { |
|
793 g.drawBytes(data, offset, length, x, y); |
|
794 } |
|
795 |
|
796 /** |
|
797 * Draws as much of the specified image as is currently available. |
|
798 * The image is drawn with its top-left corner at |
|
799 * (<i>x</i>, <i>y</i>) in this graphics context's coordinate |
|
800 * space. Transparent pixels in the image do not affect whatever |
|
801 * pixels are already there. |
|
802 * <p> |
|
803 * This method returns immediately in all cases, even if the |
|
804 * complete image has not yet been loaded, and it has not been dithered |
|
805 * and converted for the current output device. |
|
806 * <p> |
|
807 * If the image has not yet been completely loaded, then |
|
808 * <code>drawImage</code> returns <code>false</code>. As more of |
|
809 * the image becomes available, the process that draws the image notifies |
|
810 * the specified image observer. |
|
811 * @param img the specified image to be drawn. |
|
812 * @param x the <i>x</i> coordinate. |
|
813 * @param y the <i>y</i> coordinate. |
|
814 * @param observer object to be notified as more of |
|
815 * the image is converted. |
|
816 * @see java.awt.Image |
|
817 * @see java.awt.image.ImageObserver |
|
818 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
819 */ |
|
820 public boolean drawImage(Image img, int x, int y, |
|
821 ImageObserver observer) { |
|
822 return g.drawImage(img, x, y, observer); |
|
823 } |
|
824 |
|
825 /** |
|
826 * Draws as much of the specified image as has already been scaled |
|
827 * to fit inside the specified rectangle. |
|
828 * <p> |
|
829 * The image is drawn inside the specified rectangle of this |
|
830 * graphics context's coordinate space, and is scaled if |
|
831 * necessary. Transparent pixels do not affect whatever pixels |
|
832 * are already there. |
|
833 * <p> |
|
834 * This method returns immediately in all cases, even if the |
|
835 * entire image has not yet been scaled, dithered, and converted |
|
836 * for the current output device. |
|
837 * If the current output representation is not yet complete, then |
|
838 * <code>drawImage</code> returns <code>false</code>. As more of |
|
839 * the image becomes available, the process that draws the image notifies |
|
840 * the image observer by calling its <code>imageUpdate</code> method. |
|
841 * <p> |
|
842 * A scaled version of an image will not necessarily be |
|
843 * available immediately just because an unscaled version of the |
|
844 * image has been constructed for this output device. Each size of |
|
845 * the image may be cached separately and generated from the original |
|
846 * data in a separate image production sequence. |
|
847 * @param img the specified image to be drawn. |
|
848 * @param x the <i>x</i> coordinate. |
|
849 * @param y the <i>y</i> coordinate. |
|
850 * @param width the width of the rectangle. |
|
851 * @param height the height of the rectangle. |
|
852 * @param observer object to be notified as more of |
|
853 * the image is converted. |
|
854 * @see java.awt.Image |
|
855 * @see java.awt.image.ImageObserver |
|
856 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
857 */ |
|
858 public boolean drawImage(Image img, int x, int y, |
|
859 int width, int height, |
|
860 ImageObserver observer) { |
|
861 return g.drawImage(img, x, y, width, height, observer); |
|
862 } |
|
863 |
|
864 /** |
|
865 * Draws as much of the specified image as is currently available. |
|
866 * The image is drawn with its top-left corner at |
|
867 * (<i>x</i>, <i>y</i>) in this graphics context's coordinate |
|
868 * space. Transparent pixels are drawn in the specified |
|
869 * background color. |
|
870 * <p> |
|
871 * This operation is equivalent to filling a rectangle of the |
|
872 * width and height of the specified image with the given color and then |
|
873 * drawing the image on top of it, but possibly more efficient. |
|
874 * <p> |
|
875 * This method returns immediately in all cases, even if the |
|
876 * complete image has not yet been loaded, and it has not been dithered |
|
877 * and converted for the current output device. |
|
878 * <p> |
|
879 * If the image has not yet been completely loaded, then |
|
880 * <code>drawImage</code> returns <code>false</code>. As more of |
|
881 * the image becomes available, the process that draws the image notifies |
|
882 * the specified image observer. |
|
883 * @param img the specified image to be drawn. |
|
884 * @param x the <i>x</i> coordinate. |
|
885 * @param y the <i>y</i> coordinate. |
|
886 * @param bgcolor the background color to paint under the |
|
887 * non-opaque portions of the image. |
|
888 * @param observer object to be notified as more of |
|
889 * the image is converted. |
|
890 * @see java.awt.Image |
|
891 * @see java.awt.image.ImageObserver |
|
892 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
893 */ |
|
894 public boolean drawImage(Image img, int x, int y, |
|
895 Color bgcolor, |
|
896 ImageObserver observer) { |
|
897 return g.drawImage(img, x, y, bgcolor, observer); |
|
898 } |
|
899 |
|
900 /** |
|
901 * Draws as much of the specified image as has already been scaled |
|
902 * to fit inside the specified rectangle. |
|
903 * <p> |
|
904 * The image is drawn inside the specified rectangle of this |
|
905 * graphics context's coordinate space, and is scaled if |
|
906 * necessary. Transparent pixels are drawn in the specified |
|
907 * background color. |
|
908 * This operation is equivalent to filling a rectangle of the |
|
909 * width and height of the specified image with the given color and then |
|
910 * drawing the image on top of it, but possibly more efficient. |
|
911 * <p> |
|
912 * This method returns immediately in all cases, even if the |
|
913 * entire image has not yet been scaled, dithered, and converted |
|
914 * for the current output device. |
|
915 * If the current output representation is not yet complete then |
|
916 * <code>drawImage</code> returns <code>false</code>. As more of |
|
917 * the image becomes available, the process that draws the image notifies |
|
918 * the specified image observer. |
|
919 * <p> |
|
920 * A scaled version of an image will not necessarily be |
|
921 * available immediately just because an unscaled version of the |
|
922 * image has been constructed for this output device. Each size of |
|
923 * the image may be cached separately and generated from the original |
|
924 * data in a separate image production sequence. |
|
925 * @param img the specified image to be drawn. |
|
926 * @param x the <i>x</i> coordinate. |
|
927 * @param y the <i>y</i> coordinate. |
|
928 * @param width the width of the rectangle. |
|
929 * @param height the height of the rectangle. |
|
930 * @param bgcolor the background color to paint under the |
|
931 * non-opaque portions of the image. |
|
932 * @param observer object to be notified as more of |
|
933 * the image is converted. |
|
934 * @see java.awt.Image |
|
935 * @see java.awt.image.ImageObserver |
|
936 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
937 */ |
|
938 public boolean drawImage(Image img, int x, int y, |
|
939 int width, int height, |
|
940 Color bgcolor, |
|
941 ImageObserver observer) { |
|
942 |
|
943 return g.drawImage(img, x, y, width, height, bgcolor, observer); |
|
944 } |
|
945 |
|
946 /** |
|
947 * Draws as much of the specified area of the specified image as is |
|
948 * currently available, scaling it on the fly to fit inside the |
|
949 * specified area of the destination drawable surface. Transparent pixels |
|
950 * do not affect whatever pixels are already there. |
|
951 * <p> |
|
952 * This method returns immediately in all cases, even if the |
|
953 * image area to be drawn has not yet been scaled, dithered, and converted |
|
954 * for the current output device. |
|
955 * If the current output representation is not yet complete then |
|
956 * <code>drawImage</code> returns <code>false</code>. As more of |
|
957 * the image becomes available, the process that draws the image notifies |
|
958 * the specified image observer. |
|
959 * <p> |
|
960 * This method always uses the unscaled version of the image |
|
961 * to render the scaled rectangle and performs the required |
|
962 * scaling on the fly. It does not use a cached, scaled version |
|
963 * of the image for this operation. Scaling of the image from source |
|
964 * to destination is performed such that the first coordinate |
|
965 * of the source rectangle is mapped to the first coordinate of |
|
966 * the destination rectangle, and the second source coordinate is |
|
967 * mapped to the second destination coordinate. The subimage is |
|
968 * scaled and flipped as needed to preserve those mappings. |
|
969 * @param img the specified image to be drawn |
|
970 * @param dx1 the <i>x</i> coordinate of the first corner of the |
|
971 * destination rectangle. |
|
972 * @param dy1 the <i>y</i> coordinate of the first corner of the |
|
973 * destination rectangle. |
|
974 * @param dx2 the <i>x</i> coordinate of the second corner of the |
|
975 * destination rectangle. |
|
976 * @param dy2 the <i>y</i> coordinate of the second corner of the |
|
977 * destination rectangle. |
|
978 * @param sx1 the <i>x</i> coordinate of the first corner of the |
|
979 * source rectangle. |
|
980 * @param sy1 the <i>y</i> coordinate of the first corner of the |
|
981 * source rectangle. |
|
982 * @param sx2 the <i>x</i> coordinate of the second corner of the |
|
983 * source rectangle. |
|
984 * @param sy2 the <i>y</i> coordinate of the second corner of the |
|
985 * source rectangle. |
|
986 * @param observer object to be notified as more of the image is |
|
987 * scaled and converted. |
|
988 * @see java.awt.Image |
|
989 * @see java.awt.image.ImageObserver |
|
990 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
991 * @since JDK1.1 |
|
992 */ |
|
993 public boolean drawImage(Image img, |
|
994 int dx1, int dy1, int dx2, int dy2, |
|
995 int sx1, int sy1, int sx2, int sy2, |
|
996 ImageObserver observer) { |
|
997 |
|
998 return g.drawImage(img, dx1, dy1, dx2, dy2, |
|
999 sx1, sy1, sx2, sy2, |
|
1000 observer); |
|
1001 } |
|
1002 |
|
1003 /** |
|
1004 * Draws as much of the specified area of the specified image as is |
|
1005 * currently available, scaling it on the fly to fit inside the |
|
1006 * specified area of the destination drawable surface. |
|
1007 * <p> |
|
1008 * Transparent pixels are drawn in the specified background color. |
|
1009 * This operation is equivalent to filling a rectangle of the |
|
1010 * width and height of the specified image with the given color and then |
|
1011 * drawing the image on top of it, but possibly more efficient. |
|
1012 * <p> |
|
1013 * This method returns immediately in all cases, even if the |
|
1014 * image area to be drawn has not yet been scaled, dithered, and converted |
|
1015 * for the current output device. |
|
1016 * If the current output representation is not yet complete then |
|
1017 * <code>drawImage</code> returns <code>false</code>. As more of |
|
1018 * the image becomes available, the process that draws the image notifies |
|
1019 * the specified image observer. |
|
1020 * <p> |
|
1021 * This method always uses the unscaled version of the image |
|
1022 * to render the scaled rectangle and performs the required |
|
1023 * scaling on the fly. It does not use a cached, scaled version |
|
1024 * of the image for this operation. Scaling of the image from source |
|
1025 * to destination is performed such that the first coordinate |
|
1026 * of the source rectangle is mapped to the first coordinate of |
|
1027 * the destination rectangle, and the second source coordinate is |
|
1028 * mapped to the second destination coordinate. The subimage is |
|
1029 * scaled and flipped as needed to preserve those mappings. |
|
1030 * @param img the specified image to be drawn |
|
1031 * @param dx1 the <i>x</i> coordinate of the first corner of the |
|
1032 * destination rectangle. |
|
1033 * @param dy1 the <i>y</i> coordinate of the first corner of the |
|
1034 * destination rectangle. |
|
1035 * @param dx2 the <i>x</i> coordinate of the second corner of the |
|
1036 * destination rectangle. |
|
1037 * @param dy2 the <i>y</i> coordinate of the second corner of the |
|
1038 * destination rectangle. |
|
1039 * @param sx1 the <i>x</i> coordinate of the first corner of the |
|
1040 * source rectangle. |
|
1041 * @param sy1 the <i>y</i> coordinate of the first corner of the |
|
1042 * source rectangle. |
|
1043 * @param sx2 the <i>x</i> coordinate of the second corner of the |
|
1044 * source rectangle. |
|
1045 * @param sy2 the <i>y</i> coordinate of the second corner of the |
|
1046 * source rectangle. |
|
1047 * @param bgcolor the background color to paint under the |
|
1048 * non-opaque portions of the image. |
|
1049 * @param observer object to be notified as more of the image is |
|
1050 * scaled and converted. |
|
1051 * @see java.awt.Image |
|
1052 * @see java.awt.image.ImageObserver |
|
1053 * @see java.awt.image.ImageObserver#imageUpdate(java.awt.Image, int, int, int, int, int) |
|
1054 * @since JDK1.1 |
|
1055 */ |
|
1056 public boolean drawImage(Image img, |
|
1057 int dx1, int dy1, int dx2, int dy2, |
|
1058 int sx1, int sy1, int sx2, int sy2, |
|
1059 Color bgcolor, |
|
1060 ImageObserver observer) { |
|
1061 |
|
1062 return g.drawImage(img, dx1, dy1, dx2, dy2, |
|
1063 sx1, sy1, sx2, sy2, |
|
1064 bgcolor, |
|
1065 observer); |
|
1066 } |
|
1067 |
|
1068 /** |
|
1069 * Disposes of this graphics context and releases |
|
1070 * any system resources that it is using. |
|
1071 * A <code>Graphics</code> object cannot be used after |
|
1072 * <code>dispose</code>has been called. |
|
1073 * <p> |
|
1074 * When a Java program runs, a large number of <code>Graphics</code> |
|
1075 * objects can be created within a short time frame. |
|
1076 * Although the finalization process of the garbage collector |
|
1077 * also disposes of the same system resources, it is preferable |
|
1078 * to manually free the associated resources by calling this |
|
1079 * method rather than to rely on a finalization process which |
|
1080 * may not run to completion for a long period of time. |
|
1081 * <p> |
|
1082 * Graphics objects which are provided as arguments to the |
|
1083 * <code>paint</code> and <code>update</code> methods |
|
1084 * of components are automatically released by the system when |
|
1085 * those methods return. For efficiency, programmers should |
|
1086 * call <code>dispose</code> when finished using |
|
1087 * a <code>Graphics</code> object only if it was created |
|
1088 * directly from a component or another <code>Graphics</code> object. |
|
1089 * @see java.awt.Graphics#finalize |
|
1090 * @see java.awt.Component#paint |
|
1091 * @see java.awt.Component#update |
|
1092 * @see java.awt.Component#getGraphics |
|
1093 * @see java.awt.Graphics#create |
|
1094 */ |
|
1095 public void dispose() { |
|
1096 g.dispose(); |
|
1097 } |
|
1098 |
|
1099 /** |
|
1100 * Empty finalizer as no clean up needed here. |
|
1101 */ |
|
1102 public void finalize() { |
|
1103 } |
|
1104 |
|
1105 /** |
|
1106 * Returns a <code>String</code> object representing this |
|
1107 * <code>Graphics</code> object's value. |
|
1108 * @return a string representation of this graphics context. |
|
1109 */ |
|
1110 public String toString() { |
|
1111 return getClass().getName() + "[font=" + getFont() + ",color=" + getColor() + "]"; |
|
1112 } |
|
1113 |
|
1114 /** |
|
1115 * @deprecated As of JDK version 1.1, |
|
1116 * replaced by <code>getClipBounds()</code>. |
|
1117 */ |
|
1118 @Deprecated |
|
1119 public Rectangle getClipRect() { |
|
1120 return g.getClipRect(); |
|
1121 } |
|
1122 |
|
1123 /** |
|
1124 * Returns true if the specified rectangular area intersects |
|
1125 * the bounding rectangle of the current clipping area. |
|
1126 * The coordinates in the rectangle are relative to the coordinate |
|
1127 * system origin of this graphics context. |
|
1128 * |
|
1129 * @param x the x coordinate of the rectangle to test against the clip |
|
1130 * @param y the y coordinate of the rectangle to test against the clip |
|
1131 * @param width the width of the rectangle to test against the clip |
|
1132 * @param height the height of the rectangle to test against the clip |
|
1133 */ |
|
1134 public boolean hitClip(int x, int y, int width, int height) { |
|
1135 return g.hitClip(x, y, width, height); |
|
1136 } |
|
1137 |
|
1138 /** |
|
1139 * Returns the bounding rectangle of the current clipping area. |
|
1140 * The coordinates in the rectangle are relative to the coordinate |
|
1141 * system origin of this graphics context. This method differs |
|
1142 * from {@link #getClipBounds() getClipBounds} in that an existing |
|
1143 * rectangle is used instead of allocating a new one. |
|
1144 * This method refers to the user clip, which is independent of the |
|
1145 * clipping associated with device bounds and window visibility. |
|
1146 * If no clip has previously been set, or if the clip has been |
|
1147 * cleared using <code>setClip(null)</code>, this method returns the |
|
1148 * specified <code>Rectangle</code>. |
|
1149 * @param r the rectangle where the current clipping area is |
|
1150 * copied to. Any current values in this rectangle are |
|
1151 * overwritten. |
|
1152 * @return the bounding rectangle of the current clipping area. |
|
1153 */ |
|
1154 public Rectangle getClipBounds(Rectangle r) { |
|
1155 return g.getClipBounds(r); |
|
1156 } |
|
1157 } |