JDK8/Java8源码在线阅读
/*
* Copyright (c) 1997, 2010, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
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;
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java