1 /*

     2  * Copyright 1997-2004 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package 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      */

    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      */

    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      */

    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      */

   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      */

   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      */

   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      */

   150     public static Color flashColor() {

   151         return info().flashColor;

   152     }

   153 

   154     /**

   155      * Sets the time delay of drawing operation flashing.

   156      */

   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      */

   165     public static int flashTime() {

   166         return info().flashTime;

   167     }

   168 

   169     /**

   170      * Sets the number of times that drawing operations will flash.

   171      */

   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       */

   179     public static int flashCount() {

   180         return info().flashCount;

   181     }

   182 

   183     /** Sets the stream to which the DebugGraphics logs drawing operations.

   184       */

   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       */

   192     public static java.io.PrintStream logStream() {

   193         return info().stream;

   194     }

   195 

   196     /** Sets the Font used for text drawing operations.

   197       */

   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       */

   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       */

   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       */

   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      */

   236     public FontMetrics getFontMetrics() {

   237         return graphics.getFontMetrics();

   238     }

   239 

   240     /**

   241      * Overrides <code>Graphics.getFontMetrics</code>.

   242      */

   243     public FontMetrics getFontMetrics(Font f) {

   244         return graphics.getFontMetrics(f);

   245     }

   246 

   247     /**

   248      * Overrides <code>Graphics.translate</code>.

   249      */

   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      */

   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      */

   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      */

   283     public Rectangle getClipBounds() {

   284         return graphics.getClipBounds();

   285     }

   286 

   287     /**

   288      * Overrides <code>Graphics.clipRect</code>.

   289      */

   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      */

   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      */

   313     public Shape getClip() {

   314         return graphics.getClip();

   315     }

   316 

   317     /**

   318      * Overrides <code>Graphics.setClip</code>.

   319      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

   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      */

  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      */

  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      */

  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      */

  1134     public boolean drawImage(Image img, int x, int y,int width, int height,

  1135                              Color bgcolor,