You can, of course, do your own graphics within the AWT and Swing.
In the basic AWT you draw on a Panel
or a Canvas
component by overriding their paint(Graphics)
method (see the Chapter
6: Basics: Drawing section).
In Swing the JPanel
class usually serves as the drawing board. You override its PaintComponent(Graphcs)
method with code for your drawing instructions.
Note that since all the Swing components
are lightweight, you can override
their painting methods and add new features to their display. For
example, you could make a custom button with a custom appearance
in the pressed and unpressed states.
Graphics
Context
The
paintComponent(Graphics g)method includes an instance of
the Graphics
class as an argument . The graphics context represents a
drawing surface and all of its graphics settings such as the current
foreground and background colors, the fonts to be used for strings,
etc.. The class is referred to as the graphics context class since
it provides the context under which the graphics commands operate
for a component.
The graphics context does not need to represent a
visible component but can be an off-screen image.
After version 1.2, the core language included a subclass
of Graphics
called Graphics2D.
In provides a far more extensive and sophisticated set of drawing
capabilities. An introduction to Java2D is given in the Chapter
6: Java : Supplements section. An instance of the Graphics2D
class can be cast from the Graphics
instance passed in the paint(Graphics
g) method in Component
and the paintComponent(Graphics
g) method from JComponent.
Coordinate
System
Note that the basci AWT coordinate system for the Graphics
context methods goes as follows:
- Origin (0,0)- top left hand corner
- x (in pixels) - increases towards the right
- y (in pixels) - increases towards the bottom
We can obtain the dimensions of a component in two ways. The
getSize() method returns an instance
of the Dimension
class, which provides direct access to its height
and width
variables. As of Java 1.2, the component
class includes the methods getHeight()
and getWidth()
so you can obtain each of these dimensions separately.
Negative values and positive values beyond the width and height
of the drawing area do not cause errors but are treated as valid
coordinates (though, any drawing in those areas will be unseen,
of course.)
Basic
Graphics Commands
Here are some of the drawing methods in the Graphics
class :
- setColor(Color
c)
Set the current pen color, where c has several standard choices
such as
Color.black, Color.blue, Color.red, etc.
- drawLine(int
x1, int y1, int x2, int y2)
Draw a line between points (x1,y1) and (x2,y2)
- drawRect (int
x, int y, int width, int height) and
fillRect (int x, int y, int width, int height)
Draws (fills) a rectangle, (x,y) are the coordinates of the top
left corner, the bottom right corner will be at (x+width,y+height).
- drawOval (int
x, int y, int width, int height) and
fillOval (intx, int y, int width, int height)
Draws (fills) an oval bounded by the rectangle specified by these
parameters.
- draw3DRect
(int x, int y, int width, int height, int arcWidth, boolean raised)
and
fill3DRect (int
x, int y, int width, int height, boolean raised)
Draws (fills) a rectangle with shaded sides that provide a 3-D
appearance.
- drawRoundRect
(int x, int y, int width, int height, int arcWidth, int arcHeight)
and fill3DRect
(int x, int y, int width, int height, int arcWidth, int arcHeight)
Draws (fills) a rectangle with rounded corners.
- drawArc(int
x,int y,int width, int height, int startAngle, int arcAngle)
- drawPolyline
(int[] x, int[] y, int N)
Draws lines connecting the N points given by the x and y arrays.
- drawPolygon
(int[] x, int[] y, int N)
Draws lines connecting the points given by the x and y arrays.
Connects the last point to the first if they are not already the
same point.
So for the instruction
drawRect(x,y,width,height)
(x,y) are
the coordinates of the top left corner and the bottom right corner
will be at (x+width,y+height).
Note that Graphics
does not provide a method to set the width of a line. The line is
always one pixel wide and continuous (i.e., no dot-dash options).
Nevertheless, these methods are simple and often convenient to use
and can be used along with the Graphics2D
methods.
See the API
Specifications for other methods in the Graphics
class.
Drawing Demo Applet
This applet illustrates more of the drawing methods in the Graphics
class:
|
import
java.swing.*;
import java.awt.*;
/** Illustrate basic drawing in a Swing applet. **/
public class DrawApplet
extends JApplet
{
public void init
() {
Container
content_pane = getContentPane();
// Create an instance of DrawingPanel
DrawingPanel drawing_panel = new
DrawingPanel ();
// Add the button to the content pane.
content_pane.add
(drawing_panel);
}
}
// class DrawApplet
|
/** Draw
on this JPanel rather than on the JApplet. **/
public
class DrawingPanel extends
JPanel {
DrawingPanel () {
// Set background color for the applet's
panel.
setBackground (Color.WHITE);
} // ctor
public void paintComponent(Graphics
g) {
// Paint background
super.paintComponent(g);
// Get the
drawing area
int
dy = getSize ().height;
int
dx = getSize ().width;
int
mid_y = dy/2;
int
mid_x = dx/2;
int
rect_x = 3 * dx/4;
int
rect_y = 3 * dy/4;
//
Set current drawing color
g.setColor
(Color.BLACK);
//
Draw a rectangle centered at the mid-point
g.drawRect
(mid_x-rect_x/2, mid_y-rect_y/2
rect_x, rect_y );
//
Set a new drawing color
g.setColor
(Color.LIGHT_GRAY);
//
Fill a rectangle centered at the mid-point. Put
it
//
within the previous rectangle so that border shows.
g.fillRect
(mid_x-rect_x/2 + 10, mid_y-rect_y/2+10,
rect_x-20,
rect_y-20);
//
Set a new drawing color
g.setColor
(Color.DARK_GRAY);
//
Draw a circle around the mid-point
g.drawOval
(mid_x-rect_x/6, mid_y-rect_y/6,
rect_x/3, rect_y/3);
//
Fill an oval inside the circle
g.fillOval
(mid_x-rect_x/6+10, mid_y-rect_y/6+10,
rect_x/3-20, rect_y/3-20);
} //
paintComponent
} // class DrawingPanel |
We will discuss more about Java graphics in this and
following chapters. However, the capabilities, and subtleties, of
Java graphics are now quite extensive and cannot be fully covered
here.
See the following pages for supplementary information
about Java graphics and the classes involved.:
References & Web Resources
Latest update: Nov. 3, 2006
|