1 /* 2 * Copyright (c) 1997, 2010, 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 javax.swing; 27 28 import java.awt.*; 29 import java.awt.image.*; 30 import java.text.AttributedCharacterIterator; 31 32 /** 33 * Graphics subclass supporting graphics debugging. Overrides most methods 34 * from Graphics. DebugGraphics objects are rarely created by hand. They 35 * are most frequently created automatically when a JComponent's 36 * debugGraphicsOptions are changed using the setDebugGraphicsOptions() 37 * method. 38 * <p> 39 * NOTE: You must turn off double buffering to use DebugGraphics: 40 * RepaintManager repaintManager = RepaintManager.currentManager(component); 41 * repaintManager.setDoubleBufferingEnabled(false); 42 * 43 * @see JComponent#setDebugGraphicsOptions 44 * @see RepaintManager#currentManager 45 * @see RepaintManager#setDoubleBufferingEnabled 46 * 47 * @author Dave Karlton 48 */ 49 public class DebugGraphics extends Graphics { 50 Graphics graphics; 51 Image buffer; 52 int debugOptions; 53 int graphicsID = graphicsCount++; 54 int xOffset, yOffset; 55 private static int graphicsCount = 0; 56 private static ImageIcon imageLoadingIcon = new ImageIcon(); 57 58 /** Log graphics operations. */ 59 public static final int LOG_OPTION = 1 << 0; 60 /** Flash graphics operations. */ 61 public static final int FLASH_OPTION = 1 << 1; 62 /** Show buffered operations in a separate <code>Frame</code>. */ 63 public static final int BUFFERED_OPTION = 1 << 2; 64 /** Don't debug graphics operations. */ 65 public static final int NONE_OPTION = -1; 66 67 static { 68 JComponent.DEBUG_GRAPHICS_LOADED = true; 69 } 70 71 /** 72 * Constructs a new debug graphics context that supports slowed 73 * down drawing. 74 */ DebugGraphics()75 public DebugGraphics() { 76 super(); 77 buffer = null; 78 xOffset = yOffset = 0; 79 } 80 81 /** 82 * Constructs a debug graphics context from an existing graphics 83 * context that slows down drawing for the specified component. 84 * 85 * @param graphics the Graphics context to slow down 86 * @param component the JComponent to draw slowly 87 */ DebugGraphics(Graphics graphics, JComponent component)88 public DebugGraphics(Graphics graphics, JComponent component) { 89 this(graphics); 90 setDebugOptions(component.shouldDebugGraphics()); 91 } 92 93 /** 94 * Constructs a debug graphics context from an existing graphics 95 * context that supports slowed down drawing. 96 * 97 * @param graphics the Graphics context to slow down 98 */ DebugGraphics(Graphics graphics)99 public DebugGraphics(Graphics graphics) { 100 this(); 101 this.graphics = graphics; 102 } 103 104 /** 105 * Overrides <code>Graphics.create</code> to return a DebugGraphics object. 106 */ create()107 public Graphics create() { 108 DebugGraphics debugGraphics; 109 110 debugGraphics = new DebugGraphics(); 111 debugGraphics.graphics = graphics.create(); 112 debugGraphics.debugOptions = debugOptions; 113 debugGraphics.buffer = buffer; 114 115 return debugGraphics; 116 } 117 118 /** 119 * Overrides <code>Graphics.create</code> to return a DebugGraphics object. 120 */ create(int x, int y, int width, int height)121 public Graphics create(int x, int y, int width, int height) { 122 DebugGraphics debugGraphics; 123 124 debugGraphics = new DebugGraphics(); 125 debugGraphics.graphics = graphics.create(x, y, width, height); 126 debugGraphics.debugOptions = debugOptions; 127 debugGraphics.buffer = buffer; 128 debugGraphics.xOffset = xOffset + x; 129 debugGraphics.yOffset = yOffset + y; 130 131 return debugGraphics; 132 } 133 134 135 //------------------------------------------------ 136 // NEW METHODS 137 //------------------------------------------------ 138 139 /** 140 * Sets the Color used to flash drawing operations. 141 */ setFlashColor(Color flashColor)142 public static void setFlashColor(Color flashColor) { 143 info().flashColor = flashColor; 144 } 145 146 /** 147 * Returns the Color used to flash drawing operations. 148 * @see #setFlashColor 149 */ flashColor()150 public static Color flashColor() { 151 return info().flashColor; 152 } 153 154 /** 155 * Sets the time delay of drawing operation flashing. 156 */ setFlashTime(int flashTime)157 public static void setFlashTime(int flashTime) { 158 info().flashTime = flashTime; 159 } 160 161 /** 162 * Returns the time delay of drawing operation flashing. 163 * @see #setFlashTime 164 */ flashTime()165 public static int flashTime() { 166 return info().flashTime; 167 } 168 169 /** 170 * Sets the number of times that drawing operations will flash. 171 */ setFlashCount(int flashCount)172 public static void setFlashCount(int flashCount) { 173 info().flashCount = flashCount; 174 } 175 176 /** Returns the number of times that drawing operations will flash. 177 * @see #setFlashCount 178 */ flashCount()179 public static int flashCount() { 180 return info().flashCount; 181 } 182 183 /** Sets the stream to which the DebugGraphics logs drawing operations. 184 */ setLogStream(java.io.PrintStream stream)185 public static void setLogStream(java.io.PrintStream stream) { 186 info().stream = stream; 187 } 188 189 /** Returns the stream to which the DebugGraphics logs drawing operations. 190 * @see #setLogStream 191 */ logStream()192 public static java.io.PrintStream logStream() { 193 return info().stream; 194 } 195 196 /** Sets the Font used for text drawing operations. 197 */ setFont(Font aFont)198 public void setFont(Font aFont) { 199 if (debugLog()) { 200 info().log(toShortString() + " Setting font: " + aFont); 201 } 202 graphics.setFont(aFont); 203 } 204 205 /** Returns the Font used for text drawing operations. 206 * @see #setFont 207 */ getFont()208 public Font getFont() { 209 return graphics.getFont(); 210 } 211 212 /** Sets the color to be used for drawing and filling lines and shapes. 213 */ setColor(Color aColor)214 public void setColor(Color aColor) { 215 if (debugLog()) { 216 info().log(toShortString() + " Setting color: " + aColor); 217 } 218 graphics.setColor(aColor); 219 } 220 221 /** Returns the Color used for text drawing operations. 222 * @see #setColor 223 */ getColor()224 public Color getColor() { 225 return graphics.getColor(); 226 } 227 228 229 //----------------------------------------------- 230 // OVERRIDDEN METHODS 231 //------------------------------------------------ 232 233 /** 234 * Overrides <code>Graphics.getFontMetrics</code>. 235 */ getFontMetrics()236 public FontMetrics getFontMetrics() { 237 return graphics.getFontMetrics(); 238 } 239 240 /** 241 * Overrides <code>Graphics.getFontMetrics</code>. 242 */ getFontMetrics(Font f)243 public FontMetrics getFontMetrics(Font f) { 244 return graphics.getFontMetrics(f); 245 } 246 247 /** 248 * Overrides <code>Graphics.translate</code>. 249 */ translate(int x, int y)250 public void translate(int x, int y) { 251 if (debugLog()) { 252 info().log(toShortString() + 253 " Translating by: " + new Point(x, y)); 254 } 255 xOffset += x; 256 yOffset += y; 257 graphics.translate(x, y); 258 } 259 260 /** 261 * Overrides <code>Graphics.setPaintMode</code>. 262 */ setPaintMode()263 public void setPaintMode() { 264 if (debugLog()) { 265 info().log(toShortString() + " Setting paint mode"); 266 } 267 graphics.setPaintMode(); 268 } 269 270 /** 271 * Overrides <code>Graphics.setXORMode</code>. 272 */ setXORMode(Color aColor)273 public void setXORMode(Color aColor) { 274 if (debugLog()) { 275 info().log(toShortString() + " Setting XOR mode: " + aColor); 276 } 277 graphics.setXORMode(aColor); 278 } 279 280 /** 281 * Overrides <code>Graphics.getClipBounds</code>. 282 */ getClipBounds()283 public Rectangle getClipBounds() { 284 return graphics.getClipBounds(); 285 } 286 287 /** 288 * Overrides <code>Graphics.clipRect</code>. 289 */ clipRect(int x, int y, int width, int height)290 public void clipRect(int x, int y, int width, int height) { 291 graphics.clipRect(x, y, width, height); 292 if (debugLog()) { 293 info().log(toShortString() + 294 " Setting clipRect: " + (new Rectangle(x, y, width, height)) + 295 " New clipRect: " + graphics.getClip()); 296 } 297 } 298 299 /** 300 * Overrides <code>Graphics.setClip</code>. 301 */ setClip(int x, int y, int width, int height)302 public void setClip(int x, int y, int width, int height) { 303 graphics.setClip(x, y, width, height); 304 if (debugLog()) { 305 info().log(toShortString() + 306 " Setting new clipRect: " + graphics.getClip()); 307 } 308 } 309 310 /** 311 * Overrides <code>Graphics.getClip</code>. 312 */ getClip()313 public Shape getClip() { 314 return graphics.getClip(); 315 } 316 317 /** 318 * Overrides <code>Graphics.setClip</code>. 319 */ setClip(Shape clip)320 public void setClip(Shape clip) { 321 graphics.setClip(clip); 322 if (debugLog()) { 323 info().log(toShortString() + 324 " Setting new clipRect: " + graphics.getClip()); 325 } 326 } 327 328 /** 329 * Overrides <code>Graphics.drawRect</code>. 330 */ drawRect(int x, int y, int width, int height)331 public void drawRect(int x, int y, int width, int height) { 332 DebugGraphicsInfo info = info(); 333 334 if (debugLog()) { 335 info().log(toShortString() + 336 " Drawing rect: " + 337 new Rectangle(x, y, width, height)); 338 } 339 340 if (isDrawingBuffer()) { 341 if (debugBuffered()) { 342 Graphics debugGraphics = debugGraphics(); 343 344 debugGraphics.drawRect(x, y, width, height); 345 debugGraphics.dispose(); 346 } 347 } else if (debugFlash()) { 348 Color oldColor = getColor(); 349 int i, count = (info.flashCount * 2) - 1; 350 351 for (i = 0; i < count; i++) { 352 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 353 graphics.drawRect(x, y, width, height); 354 Toolkit.getDefaultToolkit().sync(); 355 sleep(info.flashTime); 356 } 357 graphics.setColor(oldColor); 358 } 359 graphics.drawRect(x, y, width, height); 360 } 361 362 /** 363 * Overrides <code>Graphics.fillRect</code>. 364 */ fillRect(int x, int y, int width, int height)365 public void fillRect(int x, int y, int width, int height) { 366 DebugGraphicsInfo info = info(); 367 368 if (debugLog()) { 369 info().log(toShortString() + 370 " Filling rect: " + 371 new Rectangle(x, y, width, height)); 372 } 373 374 if (isDrawingBuffer()) { 375 if (debugBuffered()) { 376 Graphics debugGraphics = debugGraphics(); 377 378 debugGraphics.fillRect(x, y, width, height); 379 debugGraphics.dispose(); 380 } 381 } else if (debugFlash()) { 382 Color oldColor = getColor(); 383 int i, count = (info.flashCount * 2) - 1; 384 385 for (i = 0; i < count; i++) { 386 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 387 graphics.fillRect(x, y, width, height); 388 Toolkit.getDefaultToolkit().sync(); 389 sleep(info.flashTime); 390 } 391 graphics.setColor(oldColor); 392 } 393 graphics.fillRect(x, y, width, height); 394 } 395 396 /** 397 * Overrides <code>Graphics.clearRect</code>. 398 */ clearRect(int x, int y, int width, int height)399 public void clearRect(int x, int y, int width, int height) { 400 DebugGraphicsInfo info = info(); 401 402 if (debugLog()) { 403 info().log(toShortString() + 404 " Clearing rect: " + 405 new Rectangle(x, y, width, height)); 406 } 407 408 if (isDrawingBuffer()) { 409 if (debugBuffered()) { 410 Graphics debugGraphics = debugGraphics(); 411 412 debugGraphics.clearRect(x, y, width, height); 413 debugGraphics.dispose(); 414 } 415 } else if (debugFlash()) { 416 Color oldColor = getColor(); 417 int i, count = (info.flashCount * 2) - 1; 418 419 for (i = 0; i < count; i++) { 420 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 421 graphics.clearRect(x, y, width, height); 422 Toolkit.getDefaultToolkit().sync(); 423 sleep(info.flashTime); 424 } 425 graphics.setColor(oldColor); 426 } 427 graphics.clearRect(x, y, width, height); 428 } 429 430 /** 431 * Overrides <code>Graphics.drawRoundRect</code>. 432 */ drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight)433 public void drawRoundRect(int x, int y, int width, int height, 434 int arcWidth, int arcHeight) { 435 DebugGraphicsInfo info = info(); 436 437 if (debugLog()) { 438 info().log(toShortString() + 439 " Drawing round rect: " + 440 new Rectangle(x, y, width, height) + 441 " arcWidth: " + arcWidth + 442 " archHeight: " + arcHeight); 443 } 444 if (isDrawingBuffer()) { 445 if (debugBuffered()) { 446 Graphics debugGraphics = debugGraphics(); 447 448 debugGraphics.drawRoundRect(x, y, width, height, 449 arcWidth, arcHeight); 450 debugGraphics.dispose(); 451 } 452 } else if (debugFlash()) { 453 Color oldColor = getColor(); 454 int i, count = (info.flashCount * 2) - 1; 455 456 for (i = 0; i < count; i++) { 457 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 458 graphics.drawRoundRect(x, y, width, height, 459 arcWidth, arcHeight); 460 Toolkit.getDefaultToolkit().sync(); 461 sleep(info.flashTime); 462 } 463 graphics.setColor(oldColor); 464 } 465 graphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight); 466 } 467 468 /** 469 * Overrides <code>Graphics.fillRoundRect</code>. 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 DebugGraphicsInfo info = info(); 474 475 if (debugLog()) { 476 info().log(toShortString() + 477 " Filling round rect: " + 478 new Rectangle(x, y, width, height) + 479 " arcWidth: " + arcWidth + 480 " archHeight: " + arcHeight); 481 } 482 if (isDrawingBuffer()) { 483 if (debugBuffered()) { 484 Graphics debugGraphics = debugGraphics(); 485 486 debugGraphics.fillRoundRect(x, y, width, height, 487 arcWidth, arcHeight); 488 debugGraphics.dispose(); 489 } 490 } else if (debugFlash()) { 491 Color oldColor = getColor(); 492 int i, count = (info.flashCount * 2) - 1; 493 494 for (i = 0; i < count; i++) { 495 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 496 graphics.fillRoundRect(x, y, width, height, 497 arcWidth, arcHeight); 498 Toolkit.getDefaultToolkit().sync(); 499 sleep(info.flashTime); 500 } 501 graphics.setColor(oldColor); 502 } 503 graphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight); 504 } 505 506 /** 507 * Overrides <code>Graphics.drawLine</code>. 508 */ drawLine(int x1, int y1, int x2, int y2)509 public void drawLine(int x1, int y1, int x2, int y2) { 510 DebugGraphicsInfo info = info(); 511 512 if (debugLog()) { 513 info().log(toShortString() + 514 " Drawing line: from " + pointToString(x1, y1) + 515 " to " + pointToString(x2, y2)); 516 } 517 518 if (isDrawingBuffer()) { 519 if (debugBuffered()) { 520 Graphics debugGraphics = debugGraphics(); 521 522 debugGraphics.drawLine(x1, y1, x2, y2); 523 debugGraphics.dispose(); 524 } 525 } else if (debugFlash()) { 526 Color oldColor = getColor(); 527 int i, count = (info.flashCount * 2) - 1; 528 529 for (i = 0; i < count; i++) { 530 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 531 graphics.drawLine(x1, y1, x2, y2); 532 Toolkit.getDefaultToolkit().sync(); 533 sleep(info.flashTime); 534 } 535 graphics.setColor(oldColor); 536 } 537 graphics.drawLine(x1, y1, x2, y2); 538 } 539 540 /** 541 * Overrides <code>Graphics.draw3DRect</code>. 542 */ draw3DRect(int x, int y, int width, int height, boolean raised)543 public void draw3DRect(int x, int y, int width, int height, 544 boolean raised) { 545 DebugGraphicsInfo info = info(); 546 547 if (debugLog()) { 548 info().log(toShortString() + 549 " Drawing 3D rect: " + 550 new Rectangle(x, y, width, height) + 551 " Raised bezel: " + raised); 552 } 553 if (isDrawingBuffer()) { 554 if (debugBuffered()) { 555 Graphics debugGraphics = debugGraphics(); 556 557 debugGraphics.draw3DRect(x, y, width, height, raised); 558 debugGraphics.dispose(); 559 } 560 } else if (debugFlash()) { 561 Color oldColor = getColor(); 562 int i, count = (info.flashCount * 2) - 1; 563 564 for (i = 0; i < count; i++) { 565 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 566 graphics.draw3DRect(x, y, width, height, raised); 567 Toolkit.getDefaultToolkit().sync(); 568 sleep(info.flashTime); 569 } 570 graphics.setColor(oldColor); 571 } 572 graphics.draw3DRect(x, y, width, height, raised); 573 } 574 575 /** 576 * Overrides <code>Graphics.fill3DRect</code>. 577 */ fill3DRect(int x, int y, int width, int height, boolean raised)578 public void fill3DRect(int x, int y, int width, int height, 579 boolean raised) { 580 DebugGraphicsInfo info = info(); 581 582 if (debugLog()) { 583 info().log(toShortString() + 584 " Filling 3D rect: " + 585 new Rectangle(x, y, width, height) + 586 " Raised bezel: " + raised); 587 } 588 if (isDrawingBuffer()) { 589 if (debugBuffered()) { 590 Graphics debugGraphics = debugGraphics(); 591 592 debugGraphics.fill3DRect(x, y, width, height, raised); 593 debugGraphics.dispose(); 594 } 595 } else if (debugFlash()) { 596 Color oldColor = getColor(); 597 int i, count = (info.flashCount * 2) - 1; 598 599 for (i = 0; i < count; i++) { 600 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 601 graphics.fill3DRect(x, y, width, height, raised); 602 Toolkit.getDefaultToolkit().sync(); 603 sleep(info.flashTime); 604 } 605 graphics.setColor(oldColor); 606 } 607 graphics.fill3DRect(x, y, width, height, raised); 608 } 609 610 /** 611 * Overrides <code>Graphics.drawOval</code>. 612 */ drawOval(int x, int y, int width, int height)613 public void drawOval(int x, int y, int width, int height) { 614 DebugGraphicsInfo info = info(); 615 616 if (debugLog()) { 617 info().log(toShortString() + 618 " Drawing oval: " + 619 new Rectangle(x, y, width, height)); 620 } 621 if (isDrawingBuffer()) { 622 if (debugBuffered()) { 623 Graphics debugGraphics = debugGraphics(); 624 625 debugGraphics.drawOval(x, y, width, height); 626 debugGraphics.dispose(); 627 } 628 } else if (debugFlash()) { 629 Color oldColor = getColor(); 630 int i, count = (info.flashCount * 2) - 1; 631 632 for (i = 0; i < count; i++) { 633 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 634 graphics.drawOval(x, y, width, height); 635 Toolkit.getDefaultToolkit().sync(); 636 sleep(info.flashTime); 637 } 638 graphics.setColor(oldColor); 639 } 640 graphics.drawOval(x, y, width, height); 641 } 642 643 /** 644 * Overrides <code>Graphics.fillOval</code>. 645 */ fillOval(int x, int y, int width, int height)646 public void fillOval(int x, int y, int width, int height) { 647 DebugGraphicsInfo info = info(); 648 649 if (debugLog()) { 650 info().log(toShortString() + 651 " Filling oval: " + 652 new Rectangle(x, y, width, height)); 653 } 654 if (isDrawingBuffer()) { 655 if (debugBuffered()) { 656 Graphics debugGraphics = debugGraphics(); 657 658 debugGraphics.fillOval(x, y, width, height); 659 debugGraphics.dispose(); 660 } 661 } else if (debugFlash()) { 662 Color oldColor = getColor(); 663 int i, count = (info.flashCount * 2) - 1; 664 665 for (i = 0; i < count; i++) { 666 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 667 graphics.fillOval(x, y, width, height); 668 Toolkit.getDefaultToolkit().sync(); 669 sleep(info.flashTime); 670 } 671 graphics.setColor(oldColor); 672 } 673 graphics.fillOval(x, y, width, height); 674 } 675 676 /** 677 * Overrides <code>Graphics.drawArc</code>. 678 */ drawArc(int x, int y, int width, int height, int startAngle, int arcAngle)679 public void drawArc(int x, int y, int width, int height, 680 int startAngle, int arcAngle) { 681 DebugGraphicsInfo info = info(); 682 683 if (debugLog()) { 684 info().log(toShortString() + 685 " Drawing arc: " + 686 new Rectangle(x, y, width, height) + 687 " startAngle: " + startAngle + 688 " arcAngle: " + arcAngle); 689 } 690 if (isDrawingBuffer()) { 691 if (debugBuffered()) { 692 Graphics debugGraphics = debugGraphics(); 693 694 debugGraphics.drawArc(x, y, width, height, 695 startAngle, arcAngle); 696 debugGraphics.dispose(); 697 } 698 } else if (debugFlash()) { 699 Color oldColor = getColor(); 700 int i, count = (info.flashCount * 2) - 1; 701 702 for (i = 0; i < count; i++) { 703 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 704 graphics.drawArc(x, y, width, height, startAngle, arcAngle); 705 Toolkit.getDefaultToolkit().sync(); 706 sleep(info.flashTime); 707 } 708 graphics.setColor(oldColor); 709 } 710 graphics.drawArc(x, y, width, height, startAngle, arcAngle); 711 } 712 713 /** 714 * Overrides <code>Graphics.fillArc</code>. 715 */ fillArc(int x, int y, int width, int height, int startAngle, int arcAngle)716 public void fillArc(int x, int y, int width, int height, 717 int startAngle, int arcAngle) { 718 DebugGraphicsInfo info = info(); 719 720 if (debugLog()) { 721 info().log(toShortString() + 722 " Filling arc: " + 723 new Rectangle(x, y, width, height) + 724 " startAngle: " + startAngle + 725 " arcAngle: " + arcAngle); 726 } 727 if (isDrawingBuffer()) { 728 if (debugBuffered()) { 729 Graphics debugGraphics = debugGraphics(); 730 731 debugGraphics.fillArc(x, y, width, height, 732 startAngle, arcAngle); 733 debugGraphics.dispose(); 734 } 735 } else if (debugFlash()) { 736 Color oldColor = getColor(); 737 int i, count = (info.flashCount * 2) - 1; 738 739 for (i = 0; i < count; i++) { 740 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 741 graphics.fillArc(x, y, width, height, startAngle, arcAngle); 742 Toolkit.getDefaultToolkit().sync(); 743 sleep(info.flashTime); 744 } 745 graphics.setColor(oldColor); 746 } 747 graphics.fillArc(x, y, width, height, startAngle, arcAngle); 748 } 749 750 /** 751 * Overrides <code>Graphics.drawPolyline</code>. 752 */ drawPolyline(int xPoints[], int yPoints[], int nPoints)753 public void drawPolyline(int xPoints[], int yPoints[], int nPoints) { 754 DebugGraphicsInfo info = info(); 755 756 if (debugLog()) { 757 info().log(toShortString() + 758 " Drawing polyline: " + 759 " nPoints: " + nPoints + 760 " X's: " + xPoints + 761 " Y's: " + yPoints); 762 } 763 if (isDrawingBuffer()) { 764 if (debugBuffered()) { 765 Graphics debugGraphics = debugGraphics(); 766 767 debugGraphics.drawPolyline(xPoints, yPoints, nPoints); 768 debugGraphics.dispose(); 769 } 770 } else if (debugFlash()) { 771 Color oldColor = getColor(); 772 int i, count = (info.flashCount * 2) - 1; 773 774 for (i = 0; i < count; i++) { 775 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 776 graphics.drawPolyline(xPoints, yPoints, nPoints); 777 Toolkit.getDefaultToolkit().sync(); 778 sleep(info.flashTime); 779 } 780 graphics.setColor(oldColor); 781 } 782 graphics.drawPolyline(xPoints, yPoints, nPoints); 783 } 784 785 /** 786 * Overrides <code>Graphics.drawPolygon</code>. 787 */ drawPolygon(int xPoints[], int yPoints[], int nPoints)788 public void drawPolygon(int xPoints[], int yPoints[], int nPoints) { 789 DebugGraphicsInfo info = info(); 790 791 if (debugLog()) { 792 info().log(toShortString() + 793 " Drawing polygon: " + 794 " nPoints: " + nPoints + 795 " X's: " + xPoints + 796 " Y's: " + yPoints); 797 } 798 if (isDrawingBuffer()) { 799 if (debugBuffered()) { 800 Graphics debugGraphics = debugGraphics(); 801 802 debugGraphics.drawPolygon(xPoints, yPoints, nPoints); 803 debugGraphics.dispose(); 804 } 805 } else if (debugFlash()) { 806 Color oldColor = getColor(); 807 int i, count = (info.flashCount * 2) - 1; 808 809 for (i = 0; i < count; i++) { 810 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 811 graphics.drawPolygon(xPoints, yPoints, nPoints); 812 Toolkit.getDefaultToolkit().sync(); 813 sleep(info.flashTime); 814 } 815 graphics.setColor(oldColor); 816 } 817 graphics.drawPolygon(xPoints, yPoints, nPoints); 818 } 819 820 /** 821 * Overrides <code>Graphics.fillPolygon</code>. 822 */ fillPolygon(int xPoints[], int yPoints[], int nPoints)823 public void fillPolygon(int xPoints[], int yPoints[], int nPoints) { 824 DebugGraphicsInfo info = info(); 825 826 if (debugLog()) { 827 info().log(toShortString() + 828 " Filling polygon: " + 829 " nPoints: " + nPoints + 830 " X's: " + xPoints + 831 " Y's: " + yPoints); 832 } 833 if (isDrawingBuffer()) { 834 if (debugBuffered()) { 835 Graphics debugGraphics = debugGraphics(); 836 837 debugGraphics.fillPolygon(xPoints, yPoints, nPoints); 838 debugGraphics.dispose(); 839 } 840 } else if (debugFlash()) { 841 Color oldColor = getColor(); 842 int i, count = (info.flashCount * 2) - 1; 843 844 for (i = 0; i < count; i++) { 845 graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor); 846 graphics.fillPolygon(xPoints, yPoints, nPoints); 847 Toolkit.getDefaultToolkit().sync(); 848 sleep(info.flashTime); 849 } 850 graphics.setColor(oldColor); 851 } 852 graphics.fillPolygon(xPoints, yPoints, nPoints); 853 } 854 855 /** 856 * Overrides <code>Graphics.drawString</code>. 857 */ drawString(String aString, int x, int y)858 public void drawString(String aString, int x, int y) { 859 DebugGraphicsInfo info = info(); 860 861 if (debugLog()) { 862 info().log(toShortString() + 863 " Drawing string: \"" + aString + 864 "\" at: " + new Point(x, y)); 865 } 866 867 if (isDrawingBuffer()) { 868 if (debugBuffered()) { 869 Graphics debugGraphics = debugGraphics(); 870 871 debugGraphics.drawString(aString, x, y); 872 debugGraphics.dispose(); 873 } 874 } else if (debugFlash()) { 875 Color oldColor = getColor(); 876 int i, count = (info.flashCount * 2) - 1; 877 878 for (i = 0; i < count; i++) { 879 graphics.setColor((i % 2) == 0 ? info.flashColor 880 : oldColor); 881 graphics.drawString(aString, x, y); 882 Toolkit.getDefaultToolkit().sync(); 883 sleep(info.flashTime); 884 } 885 graphics.setColor(oldColor); 886 } 887 graphics.drawString(aString, x, y); 888 } 889 890 /** 891 * Overrides <code>Graphics.drawString</code>. 892 */ drawString(AttributedCharacterIterator iterator, int x, int y)893 public void drawString(AttributedCharacterIterator iterator, int x, int y) { 894 DebugGraphicsInfo info = info(); 895 896 if (debugLog()) { 897 info().log(toShortString() + 898 " Drawing text: \"" + iterator + 899 "\" at: " + new Point(x, y)); 900 } 901 902 if (isDrawingBuffer()) { 903 if (debugBuffered()) { 904 Graphics debugGraphics = debugGraphics(); 905 906 debugGraphics.drawString(iterator, x, y); 907 debugGraphics.dispose(); 908 } 909 } else if (debugFlash()) { 910 Color oldColor = getColor(); 911 int i, count = (info.flashCount * 2) - 1; 912 913 for (i = 0; i < count; i++) { 914 graphics.setColor((i % 2) == 0 ? info.flashColor 915 : oldColor); 916 graphics.drawString(iterator, x, y); 917 Toolkit.getDefaultToolkit().sync(); 918 sleep(info.flashTime); 919 } 920 graphics.setColor(oldColor); 921 } 922 graphics.drawString(iterator, x, y); 923 } 924 925 /** 926 * Overrides <code>Graphics.drawBytes</code>. 927 */ drawBytes(byte data[], int offset, int length, int x, int y)928 public void drawBytes(byte data[], int offset, int length, int x, int y) { 929 DebugGraphicsInfo info = info(); 930 931 Font font = graphics.getFont(); 932 933 if (debugLog()) { 934 info().log(toShortString() + 935 " Drawing bytes at: " + new Point(x, y)); 936 } 937 938 if (isDrawingBuffer()) { 939 if (debugBuffered()) { 940 Graphics debugGraphics = debugGraphics(); 941 942 debugGraphics.drawBytes(data, offset, length, x, y); 943 debugGraphics.dispose(); 944 } 945 } else if (debugFlash()) { 946 Color oldColor = getColor(); 947 int i, count = (info.flashCount * 2) - 1; 948 949 for (i = 0; i < count; i++) { 950 graphics.setColor((i % 2) == 0 ? info.flashColor 951 : oldColor); 952 graphics.drawBytes(data, offset, length, x, y); 953 Toolkit.getDefaultToolkit().sync(); 954 sleep(info.flashTime); 955 } 956 graphics.setColor(oldColor); 957 } 958 graphics.drawBytes(data, offset, length, x, y); 959 } 960 961 /** 962 * Overrides <code>Graphics.drawChars</code>. 963 */ drawChars(char data[], int offset, int length, int x, int y)964 public void drawChars(char data[], int offset, int length, int x, int y) { 965 DebugGraphicsInfo info = info(); 966 967 Font font = graphics.getFont(); 968 969 if (debugLog()) { 970 info().log(toShortString() + 971 " Drawing chars at " + new Point(x, y)); 972 } 973 974 if (isDrawingBuffer()) { 975 if (debugBuffered()) { 976 Graphics debugGraphics = debugGraphics(); 977 978 debugGraphics.drawChars(data, offset, length, x, y); 979 debugGraphics.dispose(); 980 } 981 } else if (debugFlash()) { 982 Color oldColor = getColor(); 983 int i, count = (info.flashCount * 2) - 1; 984 985 for (i = 0; i < count; i++) { 986 graphics.setColor((i % 2) == 0 ? info.flashColor 987 : oldColor); 988 graphics.drawChars(data, offset, length, x, y); 989 Toolkit.getDefaultToolkit().sync(); 990 sleep(info.flashTime); 991 } 992 graphics.setColor(oldColor); 993 } 994 graphics.drawChars(data, offset, length, x, y); 995 } 996 997 /** 998 * Overrides <code>Graphics.drawImage</code>. 999 */ drawImage(Image img, int x, int y, ImageObserver observer)1000 public boolean drawImage(Image img, int x, int y, 1001 ImageObserver observer) { 1002 DebugGraphicsInfo info = info(); 1003 1004 if (debugLog()) { 1005 info.log(toShortString() + 1006 " Drawing image: " + img + 1007 " at: " + new Point(x, y)); 1008 } 1009 1010 if (isDrawingBuffer()) { 1011 if (debugBuffered()) { 1012 Graphics debugGraphics = debugGraphics(); 1013 1014 debugGraphics.drawImage(img, x, y, observer); 1015 debugGraphics.dispose(); 1016 } 1017 } else if (debugFlash()) { 1018 int i, count = (info.flashCount * 2) - 1; 1019 ImageProducer oldProducer = img.getSource(); 1020 ImageProducer newProducer 1021 = new FilteredImageSource(oldProducer, 1022 new DebugGraphicsFilter(info.flashColor)); 1023 Image newImage 1024 = Toolkit.getDefaultToolkit().createImage(newProducer); 1025 DebugGraphicsObserver imageObserver 1026 = new DebugGraphicsObserver(); 1027 1028 Image imageToDraw; 1029 for (i = 0; i < count; i++) { 1030 imageToDraw = (i % 2) == 0 ? newImage : img; 1031 loadImage(imageToDraw); 1032 graphics.drawImage(imageToDraw, x, y, 1033 imageObserver); 1034 Toolkit.getDefaultToolkit().sync(); 1035 sleep(info.flashTime); 1036 } 1037 } 1038 return graphics.drawImage(img, x, y, observer); 1039 } 1040 1041 /** 1042 * Overrides <code>Graphics.drawImage</code>. 1043 */ drawImage(Image img, int x, int y, int width, int height, ImageObserver observer)1044 public boolean drawImage(Image img, int x, int y, int width, int height, 1045 ImageObserver observer) { 1046 DebugGraphicsInfo info = info(); 1047 1048 if (debugLog()) { 1049 info.log(toShortString() + 1050 " Drawing image: " + img + 1051 " at: " + new Rectangle(x, y, width, height)); 1052 } 1053 1054 if (isDrawingBuffer()) { 1055 if (debugBuffered()) { 1056 Graphics debugGraphics = debugGraphics(); 1057 1058 debugGraphics.drawImage(img, x, y, width, height, observer); 1059 debugGraphics.dispose(); 1060 } 1061 } else if (debugFlash()) { 1062 int i, count = (info.flashCount * 2) - 1; 1063 ImageProducer oldProducer = img.getSource(); 1064 ImageProducer newProducer 1065 = new FilteredImageSource(oldProducer, 1066 new DebugGraphicsFilter(info.flashColor)); 1067 Image newImage 1068 = Toolkit.getDefaultToolkit().createImage(newProducer); 1069 DebugGraphicsObserver imageObserver 1070 = new DebugGraphicsObserver(); 1071 1072 Image imageToDraw; 1073 for (i = 0; i < count; i++) { 1074 imageToDraw = (i % 2) == 0 ? newImage : img; 1075 loadImage(imageToDraw); 1076 graphics.drawImage(imageToDraw, x, y, 1077 width, height, imageObserver); 1078 Toolkit.getDefaultToolkit().sync(); 1079 sleep(info.flashTime); 1080 } 1081 } 1082 return graphics.drawImage(img, x, y, width, height, observer); 1083 } 1084 1085 /** 1086 * Overrides <code>Graphics.drawImage</code>. 1087 */ drawImage(Image img, int x, int y, Color bgcolor, ImageObserver observer)1088 public boolean drawImage(Image img, int x, int y, 1089 Color bgcolor, 1090 ImageObserver observer) { 1091 DebugGraphicsInfo info = info(); 1092 1093 if (debugLog()) { 1094 info.log(toShortString() + 1095 " Drawing image: " + img + 1096 " at: " + new Point(x, y) + 1097 ", bgcolor: " + bgcolor); 1098 } 1099 1100 if (isDrawingBuffer()) { 1101 if (debugBuffered()) { 1102 Graphics debugGraphics = debugGraphics(); 1103 1104 debugGraphics.drawImage(img, x, y, bgcolor, observer); 1105 debugGraphics.dispose(); 1106 } 1107 } else if (debugFlash()) { 1108 int i, count = (info.flashCount * 2) - 1; 1109 ImageProducer oldProducer = img.getSource(); 1110 ImageProducer newProducer 1111 = new FilteredImageSource(oldProducer, 1112 new DebugGraphicsFilter(info.flashColor)); 1113 Image newImage 1114 = Toolkit.getDefaultToolkit().createImage(newProducer); 1115 DebugGraphicsObserver imageObserver 1116 = new DebugGraphicsObserver(); 1117 1118 Image imageToDraw; 1119 for (i = 0; i < count; i++) { 1120 imageToDraw = (i % 2) == 0 ? newImage : img; 1121 loadImage(imageToDraw); 1122 graphics.drawImage(imageToDraw, x, y, 1123 bgcolor, imageObserver); 1124 Toolkit.getDefaultToolkit().sync(); 1125 sleep(info.flashTime); 1126 } 1127 } 1128 return graphics.drawImage(img, x, y, bgcolor, observer); 1129 } 1130 1131 /** 1132 * Overrides <code>Graphics.drawImage</code>. 1133 */ drawImage(Image img, int x, int y,int width, int height, Color bgcolor, ImageObserver observer)1134 public boolean drawImage(Image img, int x, int y,int width, int height, 1135 Color bgcolor, 1136 ImageObserver observer) { 1137 DebugGraphicsInfo info = info(); 1138 1139 if (debugLog()) { 1140 info.log(toShortString() + 1141 " Drawing image: " + img + 1142 " at: " + new Rectangle(x, y, width, height) + 1143 ", bgcolor: " + bgcolor); 1144 } 1145 1146 if (isDrawingBuffer()) { 1147 if (debugBuffered()) { 1148 Graphics debugGraphics = debugGraphics(); 1149 1150 debugGraphics.drawImage(img, x, y, width, height, 1151 bgcolor, observer); 1152 debugGraphics.dispose(); 1153 } 1154 } else if (debugFlash()) { 1155 int i, count = (info.flashCount * 2) - 1; 1156 ImageProducer oldProducer = img.getSource(); 1157 ImageProducer newProducer 1158 = new FilteredImageSource(oldProducer, 1159 new DebugGraphicsFilter(info.flashColor)); 1160 Image newImage 1161 = Toolkit.getDefaultToolkit().createImage(newProducer); 1162 DebugGraphicsObserver imageObserver 1163 = new DebugGraphicsObserver(); 1164 1165 Image imageToDraw; 1166 for (i = 0; i < count; i++) { 1167 imageToDraw = (i % 2) == 0 ? newImage : img; 1168 loadImage(imageToDraw); 1169 graphics.drawImage(imageToDraw, x, y, 1170 width, height, bgcolor, imageObserver); 1171 Toolkit.getDefaultToolkit().sync(); 1172 sleep(info.flashTime); 1173 } 1174 } 1175 return graphics.drawImage(img, x, y, width, height, bgcolor, observer); 1176 } 1177 1178 /** 1179 * Overrides <code>Graphics.drawImage</code>. 1180 */ drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, ImageObserver observer)1181 public boolean drawImage(Image img, 1182 int dx1, int dy1, int dx2, int dy2, 1183 int sx1, int sy1, int sx2, int sy2, 1184 ImageObserver observer) { 1185 DebugGraphicsInfo info = info(); 1186 1187 if (debugLog()) { 1188 info.log(toShortString() + 1189 " Drawing image: " + img + 1190 " destination: " + new Rectangle(dx1, dy1, dx2, dy2) + 1191 " source: " + new Rectangle(sx1, sy1, sx2, sy2)); 1192 } 1193 1194 if (isDrawingBuffer()) { 1195 if (debugBuffered()) { 1196 Graphics debugGraphics = debugGraphics(); 1197 1198 debugGraphics.drawImage(img, dx1, dy1, dx2, dy2, 1199 sx1, sy1, sx2, sy2, observer); 1200 debugGraphics.dispose(); 1201 } 1202 } else if (debugFlash()) { 1203 int i, count = (info.flashCount * 2) - 1; 1204 ImageProducer oldProducer = img.getSource(); 1205 ImageProducer newProducer 1206 = new FilteredImageSource(oldProducer, 1207 new DebugGraphicsFilter(info.flashColor)); 1208 Image newImage 1209 = Toolkit.getDefaultToolkit().createImage(newProducer); 1210 DebugGraphicsObserver imageObserver 1211 = new DebugGraphicsObserver(); 1212 1213 Image imageToDraw; 1214 for (i = 0; i < count; i++) { 1215 imageToDraw = (i % 2) == 0 ? newImage : img; 1216 loadImage(imageToDraw); 1217 graphics.drawImage(imageToDraw, 1218 dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, 1219 imageObserver); 1220 Toolkit.getDefaultToolkit().sync(); 1221 sleep(info.flashTime); 1222 } 1223 } 1224 return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, 1225 observer); 1226 } 1227 1228 /** 1229 * Overrides <code>Graphics.drawImage</code>. 1230 */ drawImage(Image img, int dx1, int dy1, int dx2, int dy2, int sx1, int sy1, int sx2, int sy2, Color bgcolor, ImageObserver observer)1231 public boolean drawImage(Image img, 1232 int dx1, int dy1, int dx2, int dy2, 1233 int sx1, int sy1, int sx2, int sy2, 1234 Color bgcolor, 1235 ImageObserver observer) { 1236 DebugGraphicsInfo info = info(); 1237 1238 if (debugLog()) { 1239 info.log(toShortString() + 1240 " Drawing image: " + img + 1241 " destination: " + new Rectangle(dx1, dy1, dx2, dy2) + 1242 " source: " + new Rectangle(sx1, sy1, sx2, sy2) + 1243 ", bgcolor: " + bgcolor); 1244 } 1245 1246 if (isDrawingBuffer()) { 1247 if (debugBuffered()) { 1248 Graphics debugGraphics = debugGraphics(); 1249 1250 debugGraphics.drawImage(img, dx1, dy1, dx2, dy2, 1251 sx1, sy1, sx2, sy2, bgcolor, observer); 1252 debugGraphics.dispose(); 1253 } 1254 } else if (debugFlash()) { 1255 int i, count = (info.flashCount * 2) - 1; 1256 ImageProducer oldProducer = img.getSource(); 1257 ImageProducer newProducer 1258 = new FilteredImageSource(oldProducer, 1259 new DebugGraphicsFilter(info.flashColor)); 1260 Image newImage 1261 = Toolkit.getDefaultToolkit().createImage(newProducer); 1262 DebugGraphicsObserver imageObserver 1263 = new DebugGraphicsObserver(); 1264 1265 Image imageToDraw; 1266 for (i = 0; i < count; i++) { 1267 imageToDraw = (i % 2) == 0 ? newImage : img; 1268 loadImage(imageToDraw); 1269 graphics.drawImage(imageToDraw, 1270 dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, 1271 bgcolor, imageObserver); 1272 Toolkit.getDefaultToolkit().sync(); 1273 sleep(info.flashTime); 1274 } 1275 } 1276 return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, 1277 bgcolor, observer); 1278 } 1279 loadImage(Image img)1280 static void loadImage(Image img) { 1281 imageLoadingIcon.loadImage(img); 1282 } 1283 1284 1285 /** 1286 * Overrides <code>Graphics.copyArea</code>. 1287 */ copyArea(int x, int y, int width, int height, int destX, int destY)1288 public void copyArea(int x, int y, int width, int height, 1289 int destX, int destY) { 1290 if (debugLog()) { 1291 info().log(toShortString() + 1292 " Copying area from: " + 1293 new Rectangle(x, y, width, height) + 1294 " to: " + new Point(destX, destY)); 1295 } 1296 graphics.copyArea(x, y, width, height, destX, destY); 1297 } 1298 sleep(int mSecs)1299 final void sleep(int mSecs) { 1300 try { 1301 Thread.sleep(mSecs); 1302 } catch (Exception e) { 1303 } 1304 } 1305 1306 /** 1307 * Overrides <code>Graphics.dispose</code>. 1308 */ dispose()1309 public void dispose() { 1310 graphics.dispose(); 1311 graphics = null; 1312 } 1313 1314 // ALERT! 1315 /** 1316 * Returns the drawingBuffer value. 1317 * 1318 * @return true if this object is drawing from a Buffer 1319 */ isDrawingBuffer()1320 public boolean isDrawingBuffer() { 1321 return buffer != null; 1322 } 1323 toShortString()1324 String toShortString() { 1325 return "Graphics" + (isDrawingBuffer() ? "<B>" : "") + "(" + graphicsID + "-" + debugOptions + ")"; 1326 } 1327 pointToString(int x, int y)1328 String pointToString(int x, int y) { 1329 return "(" + x + ", " + y + ")"; 1330 } 1331 1332 /** Enables/disables diagnostic information about every graphics 1333 * operation. The value of <b>options</b> indicates how this information 1334 * should be displayed. LOG_OPTION causes a text message to be printed. 1335 * FLASH_OPTION causes the drawing to flash several times. BUFFERED_OPTION 1336 * creates a new Frame that shows each operation on an 1337 * offscreen buffer. The value of <b>options</b> is bitwise OR'd into 1338 * the current value. To disable debugging use NONE_OPTION. 1339 */ setDebugOptions(int options)1340 public void setDebugOptions(int options) { 1341 if (options != 0) { 1342 if (options == NONE_OPTION) { 1343 if (debugOptions != 0) { 1344 System.err.println(toShortString() + " Disabling debug"); 1345 debugOptions = 0; 1346 } 1347 } else { 1348 if (debugOptions != options) { 1349 debugOptions |= options; 1350 if (debugLog()) { 1351 System.err.println(toShortString() + " Enabling debug"); 1352 } 1353 } 1354 } 1355 } 1356 } 1357 1358 /** Returns the current debugging options for this DebugGraphics. 1359 * @see #setDebugOptions 1360 */ getDebugOptions()1361 public int getDebugOptions() { 1362 return debugOptions; 1363 } 1364 1365 /** Static wrapper method for DebugGraphicsInfo.setDebugOptions(). Stores 1366 * options on a per component basis. 1367 */ setDebugOptions(JComponent component, int options)1368 static void setDebugOptions(JComponent component, int options) { 1369 info().setDebugOptions(component, options); 1370 } 1371 1372 /** Static wrapper method for DebugGraphicsInfo.getDebugOptions(). 1373 */ getDebugOptions(JComponent component)1374 static int getDebugOptions(JComponent component) { 1375 DebugGraphicsInfo debugGraphicsInfo = info(); 1376 if (debugGraphicsInfo == null) { 1377 return 0; 1378 } else { 1379 return debugGraphicsInfo.getDebugOptions(component); 1380 } 1381 } 1382 1383 /** Returns non-zero if <b>component</b> should display with DebugGraphics, 1384 * zero otherwise. Walks the JComponent's parent tree to determine if 1385 * any debugging options have been set. 1386 */ shouldComponentDebug(JComponent component)1387 static int shouldComponentDebug(JComponent component) { 1388 DebugGraphicsInfo info = info(); 1389 if (info == null) { 1390 return 0; 1391 } else { 1392 Container container = (Container)component; 1393 int debugOptions = 0; 1394 1395 while (container != null && (container instanceof JComponent)) { 1396 debugOptions |= info.getDebugOptions((JComponent)container); 1397 container = container.getParent(); 1398 } 1399 1400 return debugOptions; 1401 } 1402 } 1403 1404 /** Returns the number of JComponents that have debugging options turned 1405 * on. 1406 */ debugComponentCount()1407 static int debugComponentCount() { 1408 DebugGraphicsInfo debugGraphicsInfo = info(); 1409 if (debugGraphicsInfo != null && 1410 debugGraphicsInfo.componentToDebug != null) { 1411 return debugGraphicsInfo.componentToDebug.size(); 1412 } else { 1413 return 0; 1414 } 1415 } 1416 debugLog()1417 boolean debugLog() { 1418 return (debugOptions & LOG_OPTION) == LOG_OPTION; 1419 } 1420 debugFlash()1421 boolean debugFlash() { 1422 return (debugOptions & FLASH_OPTION) == FLASH_OPTION; 1423 } 1424 debugBuffered()1425 boolean debugBuffered() { 1426 return (debugOptions & BUFFERED_OPTION) == BUFFERED_OPTION; 1427 } 1428 1429 /** Returns a DebugGraphics for use in buffering window. 1430 */ debugGraphics()1431 private Graphics debugGraphics() { 1432 DebugGraphics debugGraphics; 1433 DebugGraphicsInfo info = info(); 1434 JFrame debugFrame; 1435 1436 if (info.debugFrame == null) { 1437 info.debugFrame = new JFrame(); 1438 info.debugFrame.setSize(500, 500); 1439 } 1440 debugFrame = info.debugFrame; 1441 debugFrame.show(); 1442 debugGraphics = new DebugGraphics(debugFrame.getGraphics()); 1443 debugGraphics.setFont(getFont()); 1444 debugGraphics.setColor(getColor()); 1445 debugGraphics.translate(xOffset, yOffset); 1446 debugGraphics.setClip(getClipBounds()); 1447 if (debugFlash()) { 1448 debugGraphics.setDebugOptions(FLASH_OPTION); 1449 } 1450 return debugGraphics; 1451 } 1452 1453 /** Returns DebugGraphicsInfo, or creates one if none exists. 1454 */ info()1455 static DebugGraphicsInfo info() { 1456 DebugGraphicsInfo debugGraphicsInfo = (DebugGraphicsInfo) 1457 SwingUtilities.appContextGet(debugGraphicsInfoKey); 1458 if (debugGraphicsInfo == null) { 1459 debugGraphicsInfo = new DebugGraphicsInfo(); 1460 SwingUtilities.appContextPut(debugGraphicsInfoKey, 1461 debugGraphicsInfo); 1462 } 1463 return debugGraphicsInfo; 1464 } 1465 private static final Class debugGraphicsInfoKey = DebugGraphicsInfo.class; 1466 1467 1468 } 1469