1 /* 2 * Copyright (c) 2000, 2018, 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.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 ProxyGraphics(Graphics graphics)57 public ProxyGraphics(Graphics graphics) { 58 g = graphics; 59 } 60 getGraphics()61 Graphics getGraphics() { 62 return g; 63 } 64 65 /** 66 * Creates a new {@code Graphics} object that is 67 * a copy of this {@code Graphics} object. 68 * @return a new graphics context that is a copy of 69 * this graphics context. 70 */ create()71 public Graphics create() { 72 return new ProxyGraphics(g.create()); 73 } 74 75 /** 76 * Creates a new {@code Graphics} object based on this 77 * {@code Graphics} object, but with a new translation and clip area. 78 * The new {@code Graphics} 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} 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 0}) 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 0}), and its size 97 * is specified by the {@code width} and {@code height} 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 */ create(int x, int y, int width, int height)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 */ translate(int x, int y)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 */ getColor()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 */ setColor(Color c)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 */ setPaintMode()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 */ setXORMode(Color c1)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 */ getFont()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 */ setFont(Font font)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 */ getFontMetrics()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 */ getFontMetrics(Font f)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)}, this method returns 235 * {@code null}. 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} 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 1.1 245 */ getClipBounds()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)}, 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 */ clipRect(int x, int y, int width, int height)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 1.1 286 */ setClip(int x, int y, int width, int height)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)}, this method returns 297 * {@code null}. 298 * @return a {@code Shape} object representing the 299 * current clipping area, or {@code null} 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 1.1 306 */ getClip()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} 314 * interface can be used to set the clip. The only 315 * {@code Shape} objects that are guaranteed to be 316 * supported are {@code Shape} objects that are 317 * obtained via the {@code getClip} method and via 318 * {@code Rectangle} 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} 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 1.1 326 */ setClip(Shape clip)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} and {@code dy}. From the point specified 334 * by {@code x} and {@code y}, 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} or {@code dy}. 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} 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} 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 */ copyArea(int x, int y, int width, int height, int dx, int dy)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 */ drawLine(int x1, int y1, int x2, int y2)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} and <code>x + width - 1</code>. 372 * The top and bottom edges are at 373 * {@code y} and <code>y + height - 1</code>. 374 * The resulting rectangle covers an area 375 * {@code width} pixels wide by 376 * {@code height} 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 */ fillRect(int x, int y, int width, int height)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} and <code>x + width</code>. 395 * The top and bottom edges are at 396 * {@code y} 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 */ drawRect(int x, int y, int width, int height)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} followed by {@code fillRect} 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 */ clearRect(int x, int y, int width, int height)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} and <code>x + width</code>, 438 * respectively. The top and bottom edges of the rectangle are at 439 * {@code y} 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 */ drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)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} and <code>x + width - 1</code>, 459 * respectively. The top and bottom edges of the rectangle are at 460 * {@code y} 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 */ fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)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 */ draw3DRect(int x, int y, int width, int height, boolean raised)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 */ fill3DRect(int x, int y, int width, int height, boolean raised)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 y}, 524 * {@code width}, and {@code height} 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 */ drawOval(int x, int y, int width, int height)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 */ fillOval(int x, int y, int width, int height)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} and extends 561 * for {@code arcAngle} 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} and {@code height} 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 */ drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)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} and extends 602 * for {@code arcAngle} 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} and {@code height} 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 */ fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)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 1.1 651 */ drawPolyline(int[] xPoints, int[] yPoints, int nPoints)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} 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}. 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} coordinates. 671 * @param yPoints a an array of {@code y} coordinates. 672 * @param nPoints a the total number of points. 673 * @see java.awt.Graphics#fillPolygon 674 * @see java.awt.Graphics#drawPolyline 675 */ drawPolygon(int[] xPoints, int[] yPoints, int nPoints)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} object. 684 * @param p the polygon to draw. 685 * @see java.awt.Graphics#fillPolygon 686 * @see java.awt.Graphics#drawPolyline 687 */ drawPolygon(Polygon p)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} 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}. 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} coordinates. 708 * @param yPoints a an array of {@code y} coordinates. 709 * @param nPoints a the total number of points. 710 * @see java.awt.Graphics#drawPolygon(int[], int[], int) 711 */ fillPolygon(int[] xPoints, int[] yPoints, int nPoints)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 */ fillPolygon(Polygon p)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 */ drawString(String str, int x, int y)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 */ drawString(AttributedCharacterIterator iterator, int x, int y)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 */ drawChars(char[] data, int offset, int length, int x, int y)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 */ drawBytes(byte[] data, int offset, int length, int x, int y)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} returns {@code false}. 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 */ drawImage(Image img, int x, int y, ImageObserver observer)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} returns {@code false}. As more of 839 * the image becomes available, the process that draws the image notifies 840 * the image observer by calling its {@code imageUpdate} 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 */ drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)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} returns {@code false}. 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 */ drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer)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} returns {@code false}. 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 */ drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer)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} returns {@code false}. 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 1.1 992 */ drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)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} returns {@code false}. 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 1.1 1055 */ drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer)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} object cannot be used after 1072 * {@code dispose} has been called. 1073 * <p> 1074 * When a Java program runs, a large number of {@code Graphics} 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} and {@code update} methods 1084 * of components are automatically released by the system when 1085 * those methods return. For efficiency, programmers should 1086 * call {@code dispose} when finished using 1087 * a {@code Graphics} object only if it was created 1088 * directly from a component or another {@code Graphics} 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 */ dispose()1095 public void dispose() { 1096 g.dispose(); 1097 } 1098 1099 /** 1100 * Empty finalizer as no clean up needed here. 1101 */ 1102 @SuppressWarnings("deprecation") finalize()1103 public void finalize() { 1104 } 1105 1106 /** 1107 * Returns a {@code String} object representing this 1108 * {@code Graphics} object's value. 1109 * @return a string representation of this graphics context. 1110 */ toString()1111 public String toString() { 1112 return getClass().getName() + "[font=" + getFont() + ",color=" + getColor() + "]"; 1113 } 1114 1115 /** 1116 * @deprecated As of JDK version 1.1, 1117 * replaced by {@code getClipBounds()}. 1118 */ 1119 @Deprecated getClipRect()1120 public Rectangle getClipRect() { 1121 return g.getClipRect(); 1122 } 1123 1124 /** 1125 * Returns true if the specified rectangular area intersects 1126 * the bounding rectangle of the current clipping area. 1127 * The coordinates in the rectangle are relative to the coordinate 1128 * system origin of this graphics context. 1129 * 1130 * @param x the x coordinate of the rectangle to test against the clip 1131 * @param y the y coordinate of the rectangle to test against the clip 1132 * @param width the width of the rectangle to test against the clip 1133 * @param height the height of the rectangle to test against the clip 1134 */ hitClip(int x, int y, int width, int height)1135 public boolean hitClip(int x, int y, int width, int height) { 1136 return g.hitClip(x, y, width, height); 1137 } 1138 1139 /** 1140 * Returns the bounding rectangle of the current clipping area. 1141 * The coordinates in the rectangle are relative to the coordinate 1142 * system origin of this graphics context. This method differs 1143 * from {@link #getClipBounds() getClipBounds} in that an existing 1144 * rectangle is used instead of allocating a new one. 1145 * This method refers to the user clip, which is independent of the 1146 * clipping associated with device bounds and window visibility. 1147 * If no clip has previously been set, or if the clip has been 1148 * cleared using {@code setClip(null)}, this method returns the 1149 * specified {@code Rectangle}. 1150 * @param r the rectangle where the current clipping area is 1151 * copied to. Any current values in this rectangle are 1152 * overwritten. 1153 * @return the bounding rectangle of the current clipping area. 1154 */ getClipBounds(Rectangle r)1155 public Rectangle getClipBounds(Rectangle r) { 1156 return g.getClipBounds(r); 1157 } 1158 } 1159