History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

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

Showing the changes to java/pkg/javax/swing/DebugGraphics.java (1 of 18352 files). Show all

Unified · Split

java/pkg/javax/swing/DebugGraphics.java+1468−0
@@ -0,0 +1,1468 @@
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+ */
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,
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+ */
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+ */
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+
1280+ static void loadImage(Image img) {
1281+ imageLoadingIcon.loadImage(img);
1282+ }
1283+
1284+
1285+ /**
1286+ * Overrides <code>Graphics.copyArea</code>.
1287+ */
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+
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+ */
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+ */
1320+ public boolean isDrawingBuffer() {
1321+ return buffer != null;
1322+ }
1323+
1324+ String toShortString() {
1325+ return "Graphics" + (isDrawingBuffer() ? "<B>" : "") + "(" + graphicsID + "-" + debugOptions + ")";
1326+ }
1327+
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+ */
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+ */
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+ */
1368+ static void setDebugOptions(JComponent component, int options) {
1369+ info().setDebugOptions(component, options);
1370+ }
1371+
1372+ /** Static wrapper method for DebugGraphicsInfo.getDebugOptions().
1373+ */
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+ */
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+ */
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+
1417+ boolean debugLog() {
1418+ return (debugOptions & LOG_OPTION) == LOG_OPTION;
1419+ }
1420+
1421+ boolean debugFlash() {
1422+ return (debugOptions & FLASH_OPTION) == FLASH_OPTION;
1423+ }
1424+
1425+ boolean debugBuffered() {
1426+ return (debugOptions & BUFFERED_OPTION) == BUFFERED_OPTION;
1427+ }
1428+
1429+ /** Returns a DebugGraphics for use in buffering window.
1430+ */
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+ */
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+}