8f523f3a10
* sources.am: Regenerated.
* Makefile.in: Likewise.
* scripts/makemake.tcl: Use glob -nocomplain.
From-SVN: r107049
1126 lines
28 KiB
Java
1126 lines
28 KiB
Java
/* DebugGraphics.java --
|
|
Copyright (C) 2002, 2004, 2005 Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath 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 for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package javax.swing;
|
|
|
|
import java.awt.Color;
|
|
import java.awt.Font;
|
|
import java.awt.FontMetrics;
|
|
import java.awt.Graphics;
|
|
import java.awt.Image;
|
|
import java.awt.Point;
|
|
import java.awt.Rectangle;
|
|
import java.awt.Shape;
|
|
import java.awt.image.ImageObserver;
|
|
import java.io.PrintStream;
|
|
import java.text.AttributedCharacterIterator;
|
|
|
|
|
|
/**
|
|
* An extension of {@link Graphics} that can be used for debugging
|
|
* custom Swing widgets. <code>DebugGraphics</code> has the ability to
|
|
* draw slowly and can log drawing actions.
|
|
*
|
|
* @author Andrew Selkirk
|
|
*/
|
|
public class DebugGraphics extends Graphics
|
|
{
|
|
/**
|
|
* LOG_OPTION
|
|
*/
|
|
public static final int LOG_OPTION = 1;
|
|
|
|
/**
|
|
* FLASH_OPTION
|
|
*/
|
|
public static final int FLASH_OPTION = 2;
|
|
|
|
/**
|
|
* BUFFERED_OPTION
|
|
*/
|
|
public static final int BUFFERED_OPTION = 4;
|
|
|
|
/**
|
|
* NONE_OPTION
|
|
*/
|
|
public static final int NONE_OPTION = -1;
|
|
|
|
static Color debugFlashColor = Color.RED;
|
|
static int debugFlashCount = 10;
|
|
static int debugFlashTime = 1000;
|
|
static PrintStream debugLogStream = System.out;
|
|
|
|
/**
|
|
* Counts the created DebugGraphics objects. This is used by the
|
|
* logging facility.
|
|
*/
|
|
static int counter = 0;
|
|
|
|
/**
|
|
* graphics
|
|
*/
|
|
Graphics graphics;
|
|
|
|
/**
|
|
* buffer
|
|
*/
|
|
Image buffer;
|
|
|
|
/**
|
|
* debugOptions
|
|
*/
|
|
int debugOptions;
|
|
|
|
/**
|
|
* graphicsID
|
|
*/
|
|
int graphicsID;
|
|
|
|
/**
|
|
* xOffset
|
|
*/
|
|
int xOffset;
|
|
|
|
/**
|
|
* yOffset
|
|
*/
|
|
int yOffset;
|
|
|
|
/**
|
|
* Creates a <code>DebugGraphics</code> object.
|
|
*/
|
|
public DebugGraphics()
|
|
{
|
|
counter++;
|
|
}
|
|
|
|
/**
|
|
* Creates a <code>DebugGraphics</code> object.
|
|
*
|
|
* @param graphics The <code>Graphics</code> object to wrap
|
|
* @param component TODO
|
|
*/
|
|
public DebugGraphics(Graphics graphics, JComponent component)
|
|
{
|
|
this(graphics);
|
|
// FIXME: What shall we do with component ?
|
|
}
|
|
|
|
/**
|
|
* Creates a <code>DebugGraphics</code> object.
|
|
*
|
|
* @param graphics The <code>Graphics</code> object to wrap
|
|
*/
|
|
public DebugGraphics(Graphics graphics)
|
|
{
|
|
this();
|
|
this.graphics = graphics;
|
|
}
|
|
|
|
/**
|
|
* Sets the color to draw stuff with.
|
|
*
|
|
* @param color The color
|
|
*/
|
|
public void setColor(Color color)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Setting color: " + color);
|
|
|
|
graphics.setColor(color);
|
|
}
|
|
|
|
/**
|
|
* Creates a overrides <code>Graphics.create</code> to create a
|
|
* <code>DebugGraphics</code> object.
|
|
*
|
|
* @return a new <code>DebugGraphics</code> object.
|
|
*/
|
|
public Graphics create()
|
|
{
|
|
DebugGraphics copy = new DebugGraphics(graphics.create());
|
|
copy.debugOptions = debugOptions;
|
|
return copy;
|
|
}
|
|
|
|
/**
|
|
* Creates a overrides <code>Graphics.create</code> to create a
|
|
* <code>DebugGraphics</code> object.
|
|
*
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
* @param width the width
|
|
* @param height the height
|
|
*
|
|
* @return a new <code>DebugGraphics</code> object.
|
|
*/
|
|
public Graphics create(int x, int y, int width, int height)
|
|
{
|
|
DebugGraphics copy = new DebugGraphics(graphics.create(x, y, width,
|
|
height));
|
|
copy.debugOptions = debugOptions;
|
|
return copy;
|
|
}
|
|
|
|
/**
|
|
* flashColor
|
|
*
|
|
* @return Color
|
|
*/
|
|
public static Color flashColor()
|
|
{
|
|
return debugFlashColor;
|
|
}
|
|
|
|
/**
|
|
* setFlashColor
|
|
*
|
|
* @param color the color to use for flashing
|
|
*/
|
|
public static void setFlashColor(Color color)
|
|
{
|
|
debugFlashColor = color;
|
|
}
|
|
|
|
/**
|
|
* flashTime
|
|
*
|
|
* @return The time in milliseconds
|
|
*/
|
|
public static int flashTime()
|
|
{
|
|
return debugFlashTime;
|
|
}
|
|
|
|
/**
|
|
* setFlashTime
|
|
*
|
|
* @param time The time in milliseconds
|
|
*/
|
|
public static void setFlashTime(int time)
|
|
{
|
|
debugFlashTime = time;
|
|
}
|
|
|
|
/**
|
|
* flashCount
|
|
*
|
|
* @return The number of flashes
|
|
*/
|
|
public static int flashCount()
|
|
{
|
|
return debugFlashCount;
|
|
}
|
|
|
|
/**
|
|
* setFlashCount
|
|
*
|
|
* @param count The number of flashes
|
|
*/
|
|
public static void setFlashCount(int count)
|
|
{
|
|
debugFlashCount = count;
|
|
}
|
|
|
|
/**
|
|
* logStream
|
|
*
|
|
* @return The <code>PrintStream</code> to write logging messages to
|
|
*/
|
|
public static PrintStream logStream()
|
|
{
|
|
return debugLogStream;
|
|
}
|
|
|
|
/**
|
|
* setLogStream
|
|
*
|
|
* @param stream The currently set <code>PrintStream</code>.
|
|
*/
|
|
public static void setLogStream(PrintStream stream)
|
|
{
|
|
debugLogStream = stream;
|
|
}
|
|
|
|
/**
|
|
* getFont
|
|
*
|
|
* @return The font
|
|
*/
|
|
public Font getFont()
|
|
{
|
|
return graphics.getFont();
|
|
}
|
|
|
|
/**
|
|
* setFont
|
|
*
|
|
* @param font The font to use for drawing text
|
|
*/
|
|
public void setFont(Font font)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Setting font: " + font);
|
|
|
|
graphics.setFont(font);
|
|
}
|
|
|
|
/**
|
|
* Returns the color used for drawing.
|
|
*
|
|
* @return The color.
|
|
*/
|
|
public Color getColor()
|
|
{
|
|
return graphics.getColor();
|
|
}
|
|
|
|
/**
|
|
* Returns the font metrics of the current font.
|
|
*
|
|
* @return a <code>FontMetrics</code> object
|
|
*/
|
|
public FontMetrics getFontMetrics()
|
|
{
|
|
return graphics.getFontMetrics();
|
|
}
|
|
|
|
/**
|
|
* Returns the font metrics for a given font.
|
|
*
|
|
* @param font the font to get the metrics for
|
|
*
|
|
* @return a <code>FontMetrics</code> object
|
|
*/
|
|
public FontMetrics getFontMetrics(Font font)
|
|
{
|
|
return graphics.getFontMetrics(font);
|
|
}
|
|
|
|
/**
|
|
* translate
|
|
*
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
*/
|
|
public void translate(int x, int y)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Translating by: " + new Point(x, y));
|
|
|
|
graphics.translate(x, y);
|
|
}
|
|
|
|
/**
|
|
* setPaintMode
|
|
*/
|
|
public void setPaintMode()
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Setting paint mode");
|
|
|
|
graphics.setPaintMode();
|
|
}
|
|
|
|
/**
|
|
* setXORMode
|
|
*
|
|
* @param color the color
|
|
*/
|
|
public void setXORMode(Color color)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Setting XOR mode: " + color);
|
|
|
|
graphics.setXORMode(color);
|
|
}
|
|
|
|
/**
|
|
* getClipBounds
|
|
*
|
|
* @return Rectangle
|
|
*/
|
|
public Rectangle getClipBounds()
|
|
{
|
|
return graphics.getClipBounds();
|
|
}
|
|
|
|
/**
|
|
* Intersects the current clip region with the given region.
|
|
*
|
|
* @param x The x-position of the region
|
|
* @param y The y-position of the region
|
|
* @param width The width of the region
|
|
* @param height The height of the region
|
|
*/
|
|
public void clipRect(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().print(prefix() + " Setting clipRect: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
graphics.clipRect(x, y, width, height);
|
|
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(" Netting clipRect: " + graphics.getClipBounds());
|
|
}
|
|
|
|
/**
|
|
* Sets the clipping region.
|
|
*
|
|
* @param x The x-position of the region
|
|
* @param y The y-position of the region
|
|
* @param width The width of the region
|
|
* @param height The height of the region
|
|
*/
|
|
public void setClip(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Setting new clipRect: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
graphics.setClip(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Returns the current clipping region.
|
|
*
|
|
* @return Shape
|
|
*/
|
|
public Shape getClip()
|
|
{
|
|
return graphics.getClip();
|
|
}
|
|
|
|
/**
|
|
* Sets the current clipping region
|
|
*
|
|
* @param shape The clippin region
|
|
*/
|
|
public void setClip(Shape shape)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Setting new clipRect: " + shape);
|
|
|
|
graphics.setClip(shape);
|
|
}
|
|
|
|
private void sleep(int milliseconds)
|
|
{
|
|
try
|
|
{
|
|
Thread.sleep(milliseconds);
|
|
}
|
|
catch (InterruptedException e)
|
|
{
|
|
// Ignore this.
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Draws a rectangle.
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
*/
|
|
public void drawRect(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing rect: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if ((debugOptions & FLASH_OPTION) != 0)
|
|
{
|
|
Color color = graphics.getColor();
|
|
for (int index = 0; index < (debugFlashCount - 1); ++index)
|
|
{
|
|
graphics.setColor(color);
|
|
graphics.drawRect(x, y, width, height);
|
|
sleep(debugFlashTime);
|
|
graphics.setColor(debugFlashColor);
|
|
graphics.drawRect(x, y, width, height);
|
|
sleep(debugFlashTime);
|
|
}
|
|
graphics.setColor(color);
|
|
}
|
|
|
|
graphics.drawRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* Draws a filled rectangle.
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
*/
|
|
public void fillRect(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Filling rect: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
if ((debugOptions & FLASH_OPTION) != 0)
|
|
{
|
|
Color color = graphics.getColor();
|
|
for (int index = 0; index < (debugFlashCount - 1); ++index)
|
|
{
|
|
graphics.setColor(color);
|
|
graphics.fillRect(x, y, width, height);
|
|
sleep(debugFlashTime);
|
|
graphics.setColor(debugFlashColor);
|
|
graphics.fillRect(x, y, width, height);
|
|
sleep(debugFlashTime);
|
|
}
|
|
graphics.setColor(color);
|
|
}
|
|
|
|
graphics.fillRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* clearRect
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
*/
|
|
public void clearRect(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Clearing rect: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
graphics.clearRect(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* drawRoundRect
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
* @param arcWidth TODO
|
|
* @param arcHeight TODO
|
|
*/
|
|
public void drawRoundRect(int x, int y, int width, int height,
|
|
int arcWidth, int arcHeight)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing round rect: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ " arcWidth: " + arcWidth
|
|
+ " arcHeight: " + arcHeight);
|
|
}
|
|
|
|
graphics.drawRoundRect(x, y, width, height, arcWidth, arcHeight);
|
|
}
|
|
|
|
/**
|
|
* fillRoundRect
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
* @param arcWidth TODO
|
|
* @param arcHeight TODO
|
|
*/
|
|
public void fillRoundRect(int x, int y, int width, int height,
|
|
int arcWidth, int arcHeight)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Filling round rect: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ " arcWidth: " + arcWidth
|
|
+ " arcHeight: " + arcHeight);
|
|
}
|
|
|
|
graphics.fillRoundRect(x, y, width, height, arcWidth, arcHeight);
|
|
}
|
|
|
|
/**
|
|
* drawLine
|
|
*
|
|
* @param x1 The x-position of the start
|
|
* @param y1 The y-position of the start
|
|
* @param x2 The x-position of the end
|
|
* @param y2 The y-position of the end
|
|
*/
|
|
public void drawLine(int x1, int y1, int x2, int y2)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing line: from (" + x1 + ", "
|
|
+ y1 + ") to (" + x2 + ", " + y2 + ")");
|
|
}
|
|
|
|
graphics.drawLine(x1, y1, x2, y2);
|
|
}
|
|
|
|
/**
|
|
* draw3DRect
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
* @param raised TODO
|
|
*/
|
|
public void draw3DRect(int x, int y, int width, int height, boolean raised)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing 3D rect: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ "Raised bezel: " + raised);
|
|
}
|
|
|
|
graphics.draw3DRect(x, y, width, height, raised);
|
|
}
|
|
|
|
/**
|
|
* fill3DRect
|
|
*
|
|
* @param x The x-position of the rectangle
|
|
* @param y The y-position of the rectangle
|
|
* @param width The width of the rectangle
|
|
* @param height The height of the rectangle
|
|
* @param raised TODO
|
|
*/
|
|
public void fill3DRect(int x, int y, int width, int height, boolean raised)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Filling 3D rect: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ "Raised bezel: " + raised);
|
|
}
|
|
|
|
graphics.fill3DRect(x, y, width, height, raised);
|
|
}
|
|
|
|
/**
|
|
* drawOval
|
|
*
|
|
* @param x the x coordinate
|
|
* @param y the y coordiante
|
|
* @param width the width
|
|
* @param height the height
|
|
*/
|
|
public void drawOval(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing oval: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
graphics.drawOval(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* fillOval
|
|
*
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
* @param width the width
|
|
* @param height the height
|
|
*/
|
|
public void fillOval(int x, int y, int width, int height)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Filling oval: "
|
|
+ new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
graphics.fillOval(x, y, width, height);
|
|
}
|
|
|
|
/**
|
|
* drawArc
|
|
*
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
* @param width the width
|
|
* @param height the height
|
|
* @param startAngle TODO
|
|
* @param arcAngle TODO
|
|
*/
|
|
public void drawArc(int x, int y, int width, int height,
|
|
int startAngle, int arcAngle)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing arc: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ " startAngle: " + startAngle
|
|
+ " arcAngle: " + arcAngle);
|
|
}
|
|
|
|
graphics.drawArc(x, y, width, height, startAngle, arcAngle);
|
|
}
|
|
|
|
/**
|
|
* fillArc
|
|
*
|
|
* @param x the coordinate
|
|
* @param y the y coordinate
|
|
* @param width the width
|
|
* @param height the height
|
|
* @param startAngle TODO
|
|
* @param arcAngle TODO
|
|
*/
|
|
public void fillArc(int x, int y, int width, int height,
|
|
int startAngle, int arcAngle)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Filling arc: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ " startAngle: " + startAngle
|
|
+ " arcAngle: " + arcAngle);
|
|
}
|
|
|
|
graphics.fillArc(x, y, width, height, startAngle, arcAngle);
|
|
}
|
|
|
|
/**
|
|
* drawPolyline
|
|
*
|
|
* @param xpoints TODO
|
|
* @param ypoints TODO
|
|
* @param npoints TODO
|
|
*/
|
|
public void drawPolyline(int[] xpoints, int[] ypoints, int npoints)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing polyline: nPoints: " + npoints
|
|
+ " X's: " + xpoints + " Y's: " + ypoints);
|
|
}
|
|
|
|
graphics.drawPolyline(xpoints, ypoints, npoints);
|
|
}
|
|
|
|
/**
|
|
* drawPolygon
|
|
*
|
|
* @param xpoints TODO
|
|
* @param ypoints TODO
|
|
* @param npoints TODO
|
|
*/
|
|
public void drawPolygon(int[] xpoints, int[] ypoints, int npoints)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing polygon: nPoints: " + npoints
|
|
+ " X's: " + xpoints + " Y's: " + ypoints);
|
|
}
|
|
|
|
graphics.drawPolygon(xpoints, ypoints, npoints);
|
|
}
|
|
|
|
/**
|
|
* fillPolygon
|
|
*
|
|
* @param xpoints TODO
|
|
* @param ypoints TODO
|
|
* @param npoints TODO
|
|
*/
|
|
public void fillPolygon(int[] xpoints, int[] ypoints, int npoints)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing polygon: nPoints: " + npoints
|
|
+ " X's: " + xpoints + " Y's: " + ypoints);
|
|
}
|
|
|
|
graphics.fillPolygon(xpoints, ypoints, npoints);
|
|
}
|
|
|
|
/**
|
|
* drawString
|
|
*
|
|
* @param string the string
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
*/
|
|
public void drawString(String string, int x, int y)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing string: \"" + string
|
|
+ "\" at: " + new Point(x, y));
|
|
}
|
|
|
|
graphics.drawString(string, x, y);
|
|
}
|
|
|
|
/**
|
|
* drawString
|
|
*
|
|
* @param iterator TODO
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
*/
|
|
public void drawString(AttributedCharacterIterator iterator,
|
|
int x, int y)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing string: \"" + iterator
|
|
+ "\" at: " + new Point(x, y));
|
|
}
|
|
|
|
graphics.drawString(iterator, x, y);
|
|
}
|
|
|
|
/**
|
|
* drawBytes
|
|
*
|
|
* @param data TODO
|
|
* @param offset TODO
|
|
* @param length TODO
|
|
* @param x the x coordinate
|
|
* @param y the y coordinate
|
|
*/
|
|
public void drawBytes(byte[] data, int offset, int length,
|
|
int x, int y)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Drawing bytes at: " + new Point(x, y));
|
|
|
|
graphics.drawBytes(data, offset, length, x, y);
|
|
}
|
|
|
|
/**
|
|
* drawChars
|
|
*
|
|
* @param data array of characters to draw
|
|
* @param offset offset in array
|
|
* @param length number of characters in array to draw
|
|
* @param x x-position
|
|
* @param y y-position
|
|
*/
|
|
public void drawChars(char[] data, int offset, int length,
|
|
int x, int y)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
logStream().println(prefix() + " Drawing chars at: " + new Point(x, y));
|
|
|
|
if ((debugOptions & FLASH_OPTION) != 0)
|
|
{
|
|
Color color = graphics.getColor();
|
|
for (int index = 0; index < (debugFlashCount - 1); ++index)
|
|
{
|
|
graphics.setColor(color);
|
|
graphics.drawChars(data, offset, length, x, y);
|
|
sleep(debugFlashTime);
|
|
graphics.setColor(debugFlashColor);
|
|
graphics.drawChars(data, offset, length, x, y);
|
|
sleep(debugFlashTime);
|
|
}
|
|
graphics.setColor(color);
|
|
}
|
|
|
|
graphics.drawChars(data, offset, length, x, y);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param observer The image observer
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int x, int y,
|
|
ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image + " at: "
|
|
+ new Point(x, y));
|
|
}
|
|
|
|
return graphics.drawImage(image, x, y, observer);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param width The width of the area to draw the image
|
|
* @param height The height of the area to draw the image
|
|
* @param observer The image observer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int x, int y, int width,
|
|
int height, ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image
|
|
+ " at: " + new Rectangle(x, y, width, height));
|
|
}
|
|
|
|
return graphics.drawImage(image, x, y, width, height, observer);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param background The color for the background in the opaque regions
|
|
* of the image
|
|
* @param observer The image observer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int x, int y,
|
|
Color background, ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image
|
|
+ " at: " + new Point(x, y)
|
|
+ ", bgcolor: " + background);
|
|
}
|
|
|
|
return graphics.drawImage(image, x, y, background, observer);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param x The x position
|
|
* @param y The y position
|
|
* @param width The width of the area to draw the image
|
|
* @param height The height of the area to draw the image
|
|
* @param background The color for the background in the opaque regions
|
|
* of the image
|
|
* @param observer The image observer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int x, int y, int width, int height,
|
|
Color background, ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image
|
|
+ " at: " + new Rectangle(x, y, width, height)
|
|
+ ", bgcolor: " + background);
|
|
}
|
|
|
|
return graphics.drawImage(image, x, y, width, height, background, observer);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param dx1 TODO
|
|
* @param dy1 TODO
|
|
* @param dx2 TODO
|
|
* @param dy2 TODO
|
|
* @param sx1 TODO
|
|
* @param sy1 TODO
|
|
* @param sx2 TODO
|
|
* @param sy2 TODO
|
|
* @param observer The image observer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int dx1, int dy1,
|
|
int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
|
|
ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image
|
|
+ " destination: " + new Rectangle(dx1, dy1, dx2, dy2)
|
|
+ " source: " + new Rectangle(sx1, sy1, sx2, sy2));
|
|
}
|
|
|
|
return graphics.drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, observer);
|
|
}
|
|
|
|
/**
|
|
* drawImage
|
|
*
|
|
* @param image The image to draw
|
|
* @param dx1 TODO
|
|
* @param dy1 TODO
|
|
* @param dx2 TODO
|
|
* @param dy2 TODO
|
|
* @param sx1 TODO
|
|
* @param sy1 TODO
|
|
* @param sx2 TODO
|
|
* @param sy2 TODO
|
|
* @param background The color for the background in the opaque regions
|
|
* of the image
|
|
* @param observer The image observer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean drawImage(Image image, int dx1, int dy1,
|
|
int dx2, int dy2, int sx1, int sy1, int sx2, int sy2,
|
|
Color background, ImageObserver observer)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Drawing image: " + image
|
|
+ " destination: " + new Rectangle(dx1, dy1, dx2, dy2)
|
|
+ " source: " + new Rectangle(sx1, sy1, sx2, sy2)
|
|
+ ", bgcolor: " + background);
|
|
}
|
|
|
|
return graphics.drawImage(image, dx1, dy1, dx2, dy2, sx1, sy1, sx2, sy2, background, observer);
|
|
}
|
|
|
|
/**
|
|
* copyArea
|
|
*
|
|
* @param x The x position of the source area
|
|
* @param y The y position of the source area
|
|
* @param width The width of the area
|
|
* @param height The height of the area
|
|
* @param destx The x position of the destination area
|
|
* @param desty The y posiiton of the destination area
|
|
*/
|
|
public void copyArea(int x, int y, int width, int height,
|
|
int destx, int desty)
|
|
{
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
{
|
|
logStream().println(prefix() + " Copying area from: "
|
|
+ new Rectangle(x, y, width, height)
|
|
+ " to: " + new Point(destx, desty));
|
|
}
|
|
|
|
graphics.copyArea(x, y, width, height, destx, desty);
|
|
}
|
|
|
|
/**
|
|
* Releases all system resources that this <code>Graphics</code> is using.
|
|
*/
|
|
public void dispose()
|
|
{
|
|
graphics.dispose();
|
|
graphics = null;
|
|
}
|
|
|
|
/**
|
|
* isDrawingBuffer
|
|
*
|
|
* @return boolean
|
|
*/
|
|
public boolean isDrawingBuffer()
|
|
{
|
|
return false; // TODO
|
|
}
|
|
|
|
/**
|
|
* setDebugOptions
|
|
*
|
|
* @param options the debug options
|
|
*/
|
|
public void setDebugOptions(int options)
|
|
{
|
|
debugOptions = options;
|
|
if ((debugOptions & LOG_OPTION) != 0)
|
|
if (options == NONE_OPTION)
|
|
logStream().println(prefix() + "Disabling debug");
|
|
else
|
|
logStream().println(prefix() + "Enabling debug");
|
|
}
|
|
|
|
/**
|
|
* getDebugOptions
|
|
*
|
|
* @return the debug options
|
|
*/
|
|
public int getDebugOptions()
|
|
{
|
|
return debugOptions;
|
|
}
|
|
|
|
/**
|
|
* Creates and returns the prefix that should be prepended to all logging
|
|
* messages. The prefix is made up like this:
|
|
*
|
|
* <code>Graphics(<counter>-1)</code> where counter is an integer number
|
|
* saying how many DebugGraphics objects have been created so far. The second
|
|
* number always seem to be 1 on Sun's JDK, this has to be investigated a
|
|
* little more.
|
|
*
|
|
* @return the prefix that should be prepended to all logging
|
|
* messages
|
|
*/
|
|
private String prefix()
|
|
{
|
|
return "Graphics(" + counter + "-1)";
|
|
}
|
|
}
|