You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1469 lines
48 KiB
1469 lines
48 KiB
/*
|
|
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
|
|
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*
|
|
*/
|
|
|
|
package javax.swing;
|
|
|
|
import java.awt.*;
|
|
import java.awt.image.*;
|
|
import java.text.AttributedCharacterIterator;
|
|
|
|
/**
|
|
* Graphics subclass supporting graphics debugging. Overrides most methods
|
|
* from Graphics. DebugGraphics objects are rarely created by hand. They
|
|
* are most frequently created automatically when a JComponent's
|
|
* debugGraphicsOptions are changed using the setDebugGraphicsOptions()
|
|
* method.
|
|
* <p>
|
|
* NOTE: You must turn off double buffering to use DebugGraphics:
|
|
* RepaintManager repaintManager = RepaintManager.currentManager(component);
|
|
* repaintManager.setDoubleBufferingEnabled(false);
|
|
*
|
|
* @see JComponent#setDebugGraphicsOptions
|
|
* @see RepaintManager#currentManager
|
|
* @see RepaintManager#setDoubleBufferingEnabled
|
|
*
|
|
* @author Dave Karlton
|
|
*/
|
|
public class DebugGraphics extends Graphics {
|
|
Graphics graphics;
|
|
Image buffer;
|
|
int debugOptions;
|
|
int graphicsID = graphicsCount++;
|
|
int xOffset, yOffset;
|
|
private static int graphicsCount = 0;
|
|
private static ImageIcon imageLoadingIcon = new ImageIcon();
|
|
|
|
/** Log graphics operations. */
|
|
public static final int LOG_OPTION = 1 << 0;
|
|
/** Flash graphics operations. */
|
|
public static final int FLASH_OPTION = 1 << 1;
|
|
/** Show buffered operations in a separate <code>Frame</code>. */
|
|
public static final int BUFFERED_OPTION = 1 << 2;
|
|
/** Don't debug graphics operations. */
|
|
public static final int NONE_OPTION = -1;
|
|
|
|
static {
|
|
JComponent.DEBUG_GRAPHICS_LOADED = true;
|
|
}
|
|
|
|
/**
|
|
* Constructs a new debug graphics context that supports slowed
|
|
* down drawing.
|
|
*/
|
|
public DebugGraphics() {
|
|
super();
|
|
buffer = null;
|
|
xOffset = yOffset = 0;
|
|
}
|
|
|
|
/**
|
|
* Constructs a debug graphics context from an existing graphics
|
|
* context that slows down drawing for the specified component.
|
|
*
|
|
* @param graphics the Graphics context to slow down
|
|
* @param component the JComponent to draw slowly
|
|
*/
|
|
public DebugGraphics(Graphics graphics, JComponent component) {
|
|
this(graphics);
|
|
setDebugOptions(component.shouldDebugGraphics());
|
|
}
|
|
|
|
/**
|
|
* Constructs a debug graphics context from an existing graphics
|
|
* context that supports slowed down drawing.
|
|
*
|
|
* @param graphics the Graphics context to slow down
|
|
*/
|
|
public DebugGraphics(Graphics graphics) {
|
|
this();
|
|
this.graphics = graphics;
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.create</code> to return a DebugGraphics object.
|
|
*/
|
|
public Graphics create() {
|
|
DebugGraphics debugGraphics;
|
|
|
|
debugGraphics = new DebugGraphics();
|
|
debugGraphics.graphics = graphics.create();
|
|
debugGraphics.debugOptions = debugOptions;
|
|
debugGraphics.buffer = buffer;
|
|
|
|
return debugGraphics;
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.create</code> to return a DebugGraphics object.
|
|
*/
|
|
public Graphics create(int x, int y, int width, int height) {
|
|
DebugGraphics debugGraphics;
|
|
|
|
debugGraphics = new DebugGraphics();
|
|
debugGraphics.graphics = graphics.create(x, y, width, height);
|
|
debugGraphics.debugOptions = debugOptions;
|
|
debugGraphics.buffer = buffer;
|
|
debugGraphics.xOffset = xOffset + x;
|
|
debugGraphics.yOffset = yOffset + y;
|
|
|
|
return debugGraphics;
|
|
}
|
|
|
|
|
|
//------------------------------------------------
|
|
// NEW METHODS
|
|
//------------------------------------------------
|
|
|
|
/**
|
|
* Sets the Color used to flash drawing operations.
|
|
*/
|
|
public static void setFlashColor(Color flashColor) {
|
|
info().flashColor = flashColor;
|
|
}
|
|
|
|
/**
|
|
* Returns the Color used to flash drawing operations.
|
|
* @see #setFlashColor
|
|
*/
|
|
public static Color flashColor() {
|
|
return info().flashColor;
|
|
}
|
|
|
|
/**
|
|
* Sets the time delay of drawing operation flashing.
|
|
*/
|
|
public static void setFlashTime(int flashTime) {
|
|
info().flashTime = flashTime;
|
|
}
|
|
|
|
/**
|
|
* Returns the time delay of drawing operation flashing.
|
|
* @see #setFlashTime
|
|
*/
|
|
public static int flashTime() {
|
|
return info().flashTime;
|
|
}
|
|
|
|
/**
|
|
* Sets the number of times that drawing operations will flash.
|
|
*/
|
|
public static void setFlashCount(int flashCount) {
|
|
info().flashCount = flashCount;
|
|
}
|
|
|
|
/** Returns the number of times that drawing operations will flash.
|
|
* @see #setFlashCount
|
|
*/
|
|
public static int flashCount() {
|
|
return info().flashCount;
|
|
}
|
|
|
|
/** Sets the stream to which the DebugGraphics logs drawing operations.
|
|
*/
|
|
public static void setLogStream(java.io.PrintStream stream) {
|
|
info().stream = stream;
|
|
}
|
|
|
|
/** Returns the stream to which the DebugGraphics logs drawing operations.
|
|
* @see #setLogStream
|
|
*/
|
|
public static java.io.PrintStream logStream() {
|
|
return info().stream;
|
|
}
|
|
|
|
/** Sets the Font used for text drawing operations.
|
|
*/
|
|
public void setFont(Font aFont) {
|
|
if (debugLog()) {
|
|
info().log(toShortString() + " Setting font: " + aFont);
|
|
}
|
|
graphics.setFont(aFont);
|
|
}
|
|
|
|
/** Returns the Font used for text drawing operations.
|
|
* @see #setFont
|
|
*/
|
|
public Font getFont() {
|
|
return graphics.getFont();
|
|
}
|
|
|
|
/** Sets the color to be used for drawing and filling lines and shapes.
|
|
*/
|
|
public void setColor(Color aColor) {
|
|
if (debugLog()) {
|
|
info().log(toShortString() + " Setting color: " + aColor);
|
|
}
|
|
graphics.setColor(aColor);
|
|
}
|
|
|
|
/** Returns the Color used for text drawing operations.
|
|
* @see #setColor
|
|
*/
|
|
public Color getColor() {
|
|
return graphics.getColor();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------
|
|
// OVERRIDDEN METHODS
|
|
//------------------------------------------------
|
|
|
|
/**
|
|
* Overrides <code>Graphics.getFontMetrics</code>.
|
|
*/
|
|
public FontMetrics getFontMetrics() {
|
|
return graphics.getFontMetrics();
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.getFontMetrics</code>.
|
|
*/
|
|
public FontMetrics getFontMetrics(Font f) {
|
|
return graphics.getFontMetrics(f);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.translate</code>.
|
|
*/
|
|
public void translate(int x, int y) {
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Translating by: " + new Point(x, y));
|
|
}
|
|
xOffset += x;
|
|
yOffset += y;
|
|
graphics.translate(x, y);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.setPaintMode</code>.
|
|
*/
|
|
public void setPaintMode() {
|
|
if (debugLog()) {
|
|
info().log(toShortString() + " Setting paint mode");
|
|
}
|
|
graphics.setPaintMode();
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.setXORMode</code>.
|
|
*/
|
|
public void setXORMode(Color aColor) {
|
|
if (debugLog()) {
|
|
info().log(toShortString() + " Setting XOR mode: " + aColor);
|
|
}
|
|
graphics.setXORMode(aColor);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.getClipBounds</code>.
|
|
*/
|
|
public Rectangle getClipBounds() {
|
|
return graphics.getClipBounds();
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.clipRect</code>.
|
|
*/
|
|
public void clipRect(int x, int y, int width, int height) {
|
|
graphics.clipRect(x, y, width, height);
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Setting clipRect: " + (new Rectangle(x, y, width, height)) +
|
|
" New clipRect: " + graphics.getClip());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.setClip</code>.
|
|
*/
|
|
public void setClip(int x, int y, int width, int height) {
|
|
graphics.setClip(x, y, width, height);
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Setting new clipRect: " + graphics.getClip());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.getClip</code>.
|
|
*/
|
|
public Shape getClip() {
|
|
return graphics.getClip();
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.setClip</code>.
|
|
*/
|
|
public void setClip(Shape clip) {
|
|
graphics.setClip(clip);
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Setting new clipRect: " + graphics.getClip());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawRect</code>.
|
|
*/
|
|
public void drawRect(int x, int y, int width, int height) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing rect: " +
|
|
new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawRect(x, y, width, height);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawRect(x, y, width, height);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fillRect</code>.
|
|
*/
|
|
public void fillRect(int x, int y, int width, int height) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling rect: " +
|
|
new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fillRect(x, y, width, height);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fillRect(x, y, width, height);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fillRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.clearRect</code>.
|
|
*/
|
|
public void clearRect(int x, int y, int width, int height) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Clearing rect: " +
|
|
new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.clearRect(x, y, width, height);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.clearRect(x, y, width, height);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.clearRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawRoundRect</code>.
|
|
*/
|
|
public void drawRoundRect(int x, int y, int width, int height,
|
|
int arcWidth, int arcHeight) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing round rect: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" arcWidth: " + arcWidth +
|
|
" archHeight: " + arcHeight);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawRoundRect(x, y, width, height,
|
|
arcWidth, arcHeight);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawRoundRect(x, y, width, height,
|
|
arcWidth, arcHeight);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fillRoundRect</code>.
|
|
*/
|
|
public void fillRoundRect(int x, int y, int width, int height,
|
|
int arcWidth, int arcHeight) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling round rect: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" arcWidth: " + arcWidth +
|
|
" archHeight: " + arcHeight);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fillRoundRect(x, y, width, height,
|
|
arcWidth, arcHeight);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fillRoundRect(x, y, width, height,
|
|
arcWidth, arcHeight);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawLine</code>.
|
|
*/
|
|
public void drawLine(int x1, int y1, int x2, int y2) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing line: from " + pointToString(x1, y1) +
|
|
" to " + pointToString(x2, y2));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawLine(x1, y1, x2, y2);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawLine(x1, y1, x2, y2);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawLine(x1, y1, x2, y2);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.draw3DRect</code>.
|
|
*/
|
|
public void draw3DRect(int x, int y, int width, int height,
|
|
boolean raised) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing 3D rect: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" Raised bezel: " + raised);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.draw3DRect(x, y, width, height, raised);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.draw3DRect(x, y, width, height, raised);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.draw3DRect(x, y, width, height, raised);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fill3DRect</code>.
|
|
*/
|
|
public void fill3DRect(int x, int y, int width, int height,
|
|
boolean raised) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling 3D rect: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" Raised bezel: " + raised);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fill3DRect(x, y, width, height, raised);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fill3DRect(x, y, width, height, raised);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fill3DRect(x, y, width, height, raised);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawOval</code>.
|
|
*/
|
|
public void drawOval(int x, int y, int width, int height) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing oval: " +
|
|
new Rectangle(x, y, width, height));
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawOval(x, y, width, height);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawOval(x, y, width, height);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawOval(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fillOval</code>.
|
|
*/
|
|
public void fillOval(int x, int y, int width, int height) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling oval: " +
|
|
new Rectangle(x, y, width, height));
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fillOval(x, y, width, height);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fillOval(x, y, width, height);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fillOval(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawArc</code>.
|
|
*/
|
|
public void drawArc(int x, int y, int width, int height,
|
|
int startAngle, int arcAngle) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing arc: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" startAngle: " + startAngle +
|
|
" arcAngle: " + arcAngle);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawArc(x, y, width, height,
|
|
startAngle, arcAngle);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawArc(x, y, width, height, startAngle, arcAngle);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawArc(x, y, width, height, startAngle, arcAngle);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fillArc</code>.
|
|
*/
|
|
public void fillArc(int x, int y, int width, int height,
|
|
int startAngle, int arcAngle) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling arc: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" startAngle: " + startAngle +
|
|
" arcAngle: " + arcAngle);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fillArc(x, y, width, height,
|
|
startAngle, arcAngle);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fillArc(x, y, width, height, startAngle, arcAngle);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fillArc(x, y, width, height, startAngle, arcAngle);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawPolyline</code>.
|
|
*/
|
|
public void drawPolyline(int xPoints[], int yPoints[], int nPoints) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing polyline: " +
|
|
" nPoints: " + nPoints +
|
|
" X's: " + xPoints +
|
|
" Y's: " + yPoints);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawPolyline(xPoints, yPoints, nPoints);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawPolyline(xPoints, yPoints, nPoints);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawPolyline(xPoints, yPoints, nPoints);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawPolygon</code>.
|
|
*/
|
|
public void drawPolygon(int xPoints[], int yPoints[], int nPoints) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing polygon: " +
|
|
" nPoints: " + nPoints +
|
|
" X's: " + xPoints +
|
|
" Y's: " + yPoints);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawPolygon(xPoints, yPoints, nPoints);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.drawPolygon(xPoints, yPoints, nPoints);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawPolygon(xPoints, yPoints, nPoints);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.fillPolygon</code>.
|
|
*/
|
|
public void fillPolygon(int xPoints[], int yPoints[], int nPoints) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Filling polygon: " +
|
|
" nPoints: " + nPoints +
|
|
" X's: " + xPoints +
|
|
" Y's: " + yPoints);
|
|
}
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.fillPolygon(xPoints, yPoints, nPoints);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor : oldColor);
|
|
graphics.fillPolygon(xPoints, yPoints, nPoints);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.fillPolygon(xPoints, yPoints, nPoints);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawString</code>.
|
|
*/
|
|
public void drawString(String aString, int x, int y) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing string: \"" + aString +
|
|
"\" at: " + new Point(x, y));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawString(aString, x, y);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor
|
|
: oldColor);
|
|
graphics.drawString(aString, x, y);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawString(aString, x, y);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawString</code>.
|
|
*/
|
|
public void drawString(AttributedCharacterIterator iterator, int x, int y) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing text: \"" + iterator +
|
|
"\" at: " + new Point(x, y));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawString(iterator, x, y);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor
|
|
: oldColor);
|
|
graphics.drawString(iterator, x, y);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawString(iterator, x, y);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawBytes</code>.
|
|
*/
|
|
public void drawBytes(byte data[], int offset, int length, int x, int y) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
Font font = graphics.getFont();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing bytes at: " + new Point(x, y));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawBytes(data, offset, length, x, y);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor
|
|
: oldColor);
|
|
graphics.drawBytes(data, offset, length, x, y);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawBytes(data, offset, length, x, y);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawChars</code>.
|
|
*/
|
|
public void drawChars(char data[], int offset, int length, int x, int y) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
Font font = graphics.getFont();
|
|
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Drawing chars at " + new Point(x, y));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawChars(data, offset, length, x, y);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
Color oldColor = getColor();
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
|
|
for (i = 0; i < count; i++) {
|
|
graphics.setColor((i % 2) == 0 ? info.flashColor
|
|
: oldColor);
|
|
graphics.drawChars(data, offset, length, x, y);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
graphics.setColor(oldColor);
|
|
}
|
|
graphics.drawChars(data, offset, length, x, y);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img, int x, int y,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" at: " + new Point(x, y));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, x, y, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw, x, y,
|
|
imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, x, y, observer);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img, int x, int y, int width, int height,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" at: " + new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, x, y, width, height, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw, x, y,
|
|
width, height, imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, x, y, width, height, observer);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img, int x, int y,
|
|
Color bgcolor,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" at: " + new Point(x, y) +
|
|
", bgcolor: " + bgcolor);
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, x, y, bgcolor, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw, x, y,
|
|
bgcolor, imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, x, y, bgcolor, observer);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img, int x, int y,int width, int height,
|
|
Color bgcolor,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" at: " + new Rectangle(x, y, width, height) +
|
|
", bgcolor: " + bgcolor);
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, x, y, width, height,
|
|
bgcolor, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw, x, y,
|
|
width, height, bgcolor, imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, x, y, width, height, bgcolor, observer);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img,
|
|
int dx1, int dy1, int dx2, int dy2,
|
|
int sx1, int sy1, int sx2, int sy2,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" destination: " + new Rectangle(dx1, dy1, dx2, dy2) +
|
|
" source: " + new Rectangle(sx1, sy1, sx2, sy2));
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, dx1, dy1, dx2, dy2,
|
|
sx1, sy1, sx2, sy2, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw,
|
|
dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
|
|
imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
|
|
observer);
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.drawImage</code>.
|
|
*/
|
|
public boolean drawImage(Image img,
|
|
int dx1, int dy1, int dx2, int dy2,
|
|
int sx1, int sy1, int sx2, int sy2,
|
|
Color bgcolor,
|
|
ImageObserver observer) {
|
|
DebugGraphicsInfo info = info();
|
|
|
|
if (debugLog()) {
|
|
info.log(toShortString() +
|
|
" Drawing image: " + img +
|
|
" destination: " + new Rectangle(dx1, dy1, dx2, dy2) +
|
|
" source: " + new Rectangle(sx1, sy1, sx2, sy2) +
|
|
", bgcolor: " + bgcolor);
|
|
}
|
|
|
|
if (isDrawingBuffer()) {
|
|
if (debugBuffered()) {
|
|
Graphics debugGraphics = debugGraphics();
|
|
|
|
debugGraphics.drawImage(img, dx1, dy1, dx2, dy2,
|
|
sx1, sy1, sx2, sy2, bgcolor, observer);
|
|
debugGraphics.dispose();
|
|
}
|
|
} else if (debugFlash()) {
|
|
int i, count = (info.flashCount * 2) - 1;
|
|
ImageProducer oldProducer = img.getSource();
|
|
ImageProducer newProducer
|
|
= new FilteredImageSource(oldProducer,
|
|
new DebugGraphicsFilter(info.flashColor));
|
|
Image newImage
|
|
= Toolkit.getDefaultToolkit().createImage(newProducer);
|
|
DebugGraphicsObserver imageObserver
|
|
= new DebugGraphicsObserver();
|
|
|
|
Image imageToDraw;
|
|
for (i = 0; i < count; i++) {
|
|
imageToDraw = (i % 2) == 0 ? newImage : img;
|
|
loadImage(imageToDraw);
|
|
graphics.drawImage(imageToDraw,
|
|
dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
|
|
bgcolor, imageObserver);
|
|
Toolkit.getDefaultToolkit().sync();
|
|
sleep(info.flashTime);
|
|
}
|
|
}
|
|
return graphics.drawImage(img, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2,
|
|
bgcolor, observer);
|
|
}
|
|
|
|
static void loadImage(Image img) {
|
|
imageLoadingIcon.loadImage(img);
|
|
}
|
|
|
|
|
|
/**
|
|
* Overrides <code>Graphics.copyArea</code>.
|
|
*/
|
|
public void copyArea(int x, int y, int width, int height,
|
|
int destX, int destY) {
|
|
if (debugLog()) {
|
|
info().log(toShortString() +
|
|
" Copying area from: " +
|
|
new Rectangle(x, y, width, height) +
|
|
" to: " + new Point(destX, destY));
|
|
}
|
|
graphics.copyArea(x, y, width, height, destX, destY);
|
|
}
|
|
|
|
final void sleep(int mSecs) {
|
|
try {
|
|
Thread.sleep(mSecs);
|
|
} catch (Exception e) {
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Overrides <code>Graphics.dispose</code>.
|
|
*/
|
|
public void dispose() {
|
|
graphics.dispose();
|
|
graphics = null;
|
|
}
|
|
|
|
// ALERT!
|
|
/**
|
|
* Returns the drawingBuffer value.
|
|
*
|
|
* @return true if this object is drawing from a Buffer
|
|
*/
|
|
public boolean isDrawingBuffer() {
|
|
return buffer != null;
|
|
}
|
|
|
|
String toShortString() {
|
|
return "Graphics" + (isDrawingBuffer() ? "<B>" : "") + "(" + graphicsID + "-" + debugOptions + ")";
|
|
}
|
|
|
|
String pointToString(int x, int y) {
|
|
return "(" + x + ", " + y + ")";
|
|
}
|
|
|
|
/** Enables/disables diagnostic information about every graphics
|
|
* operation. The value of <b>options</b> indicates how this information
|
|
* should be displayed. LOG_OPTION causes a text message to be printed.
|
|
* FLASH_OPTION causes the drawing to flash several times. BUFFERED_OPTION
|
|
* creates a new Frame that shows each operation on an
|
|
* offscreen buffer. The value of <b>options</b> is bitwise OR'd into
|
|
* the current value. To disable debugging use NONE_OPTION.
|
|
*/
|
|
public void setDebugOptions(int options) {
|
|
if (options != 0) {
|
|
if (options == NONE_OPTION) {
|
|
if (debugOptions != 0) {
|
|
System.err.println(toShortString() + " Disabling debug");
|
|
debugOptions = 0;
|
|
}
|
|
} else {
|
|
if (debugOptions != options) {
|
|
debugOptions |= options;
|
|
if (debugLog()) {
|
|
System.err.println(toShortString() + " Enabling debug");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Returns the current debugging options for this DebugGraphics.
|
|
* @see #setDebugOptions
|
|
*/
|
|
public int getDebugOptions() {
|
|
return debugOptions;
|
|
}
|
|
|
|
/** Static wrapper method for DebugGraphicsInfo.setDebugOptions(). Stores
|
|
* options on a per component basis.
|
|
*/
|
|
static void setDebugOptions(JComponent component, int options) {
|
|
info().setDebugOptions(component, options);
|
|
}
|
|
|
|
/** Static wrapper method for DebugGraphicsInfo.getDebugOptions().
|
|
*/
|
|
static int getDebugOptions(JComponent component) {
|
|
DebugGraphicsInfo debugGraphicsInfo = info();
|
|
if (debugGraphicsInfo == null) {
|
|
return 0;
|
|
} else {
|
|
return debugGraphicsInfo.getDebugOptions(component);
|
|
}
|
|
}
|
|
|
|
/** Returns non-zero if <b>component</b> should display with DebugGraphics,
|
|
* zero otherwise. Walks the JComponent's parent tree to determine if
|
|
* any debugging options have been set.
|
|
*/
|
|
static int shouldComponentDebug(JComponent component) {
|
|
DebugGraphicsInfo info = info();
|
|
if (info == null) {
|
|
return 0;
|
|
} else {
|
|
Container container = (Container)component;
|
|
int debugOptions = 0;
|
|
|
|
while (container != null && (container instanceof JComponent)) {
|
|
debugOptions |= info.getDebugOptions((JComponent)container);
|
|
container = container.getParent();
|
|
}
|
|
|
|
return debugOptions;
|
|
}
|
|
}
|
|
|
|
/** Returns the number of JComponents that have debugging options turned
|
|
* on.
|
|
*/
|
|
static int debugComponentCount() {
|
|
DebugGraphicsInfo debugGraphicsInfo = info();
|
|
if (debugGraphicsInfo != null &&
|
|
debugGraphicsInfo.componentToDebug != null) {
|
|
return debugGraphicsInfo.componentToDebug.size();
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
boolean debugLog() {
|
|
return (debugOptions & LOG_OPTION) == LOG_OPTION;
|
|
}
|
|
|
|
boolean debugFlash() {
|
|
return (debugOptions & FLASH_OPTION) == FLASH_OPTION;
|
|
}
|
|
|
|
boolean debugBuffered() {
|
|
return (debugOptions & BUFFERED_OPTION) == BUFFERED_OPTION;
|
|
}
|
|
|
|
/** Returns a DebugGraphics for use in buffering window.
|
|
*/
|
|
private Graphics debugGraphics() {
|
|
DebugGraphics debugGraphics;
|
|
DebugGraphicsInfo info = info();
|
|
JFrame debugFrame;
|
|
|
|
if (info.debugFrame == null) {
|
|
info.debugFrame = new JFrame();
|
|
info.debugFrame.setSize(500, 500);
|
|
}
|
|
debugFrame = info.debugFrame;
|
|
debugFrame.show();
|
|
debugGraphics = new DebugGraphics(debugFrame.getGraphics());
|
|
debugGraphics.setFont(getFont());
|
|
debugGraphics.setColor(getColor());
|
|
debugGraphics.translate(xOffset, yOffset);
|
|
debugGraphics.setClip(getClipBounds());
|
|
if (debugFlash()) {
|
|
debugGraphics.setDebugOptions(FLASH_OPTION);
|
|
}
|
|
return debugGraphics;
|
|
}
|
|
|
|
/** Returns DebugGraphicsInfo, or creates one if none exists.
|
|
*/
|
|
static DebugGraphicsInfo info() {
|
|
DebugGraphicsInfo debugGraphicsInfo = (DebugGraphicsInfo)
|
|
SwingUtilities.appContextGet(debugGraphicsInfoKey);
|
|
if (debugGraphicsInfo == null) {
|
|
debugGraphicsInfo = new DebugGraphicsInfo();
|
|
SwingUtilities.appContextPut(debugGraphicsInfoKey,
|
|
debugGraphicsInfo);
|
|
}
|
|
return debugGraphicsInfo;
|
|
}
|
|
private static final Class debugGraphicsInfoKey = DebugGraphicsInfo.class;
|
|
|
|
|
|
}
|