Shapes
The Graphics class includes a large number of instance methods for drawing various 
shapes, such as lines, rectangles, and ovals. The shapes are specified using the 
(x,y) coordinate system described above. They are drawn in the current drawing color 
of the graphics context. The current drawing color is set to the foreground color of 
the component when the graphics context is created, but it can be changed at any 
time using the setColor() method.

Here is a list of some of the most important drawing methods. With all these commands, 
any drawing that is done outside the boundaries of the component is ignored. Note that
 all these methods are in the Graphics class, so they all must be called through an 
 object of type Graphics. 

drawString(String str, int x, int y) -- Draws the text given by the string str. 
The string is drawn using the current color and font of the graphics context. 
x specifies the position of the left end of the string. y is the y-coordinate of 
the baseline of the string. The baseline is a horizontal line on which the characters
 rest. Some parts of the characters, such as the tail on a y or g, extend below the
 baseline.

drawLine(int x1, int y1, int x2, int y2) -- Draws a line from the point (x1,y1) to
 the point (x2,y2). The line is drawn as if with a pen that hangs one pixel to the 
 right and one pixel down from the (x,y) point where the pen is located. For example, 
 if g refers to an object of type Graphics, then the command g.drawLine(x,y,x,y),
 which corresponds to putting the pen down at a point, draws the single pixel 
 located at the point (x,y). 

drawRect(int x, int y, int width, int height) -- Draws the outline of a rectangle. 
The upper left corner is at (x,y), and the width and height of the rectangle are as 
specified. If width equals height, then the rectangle is a square. If the width or
 the height is negative, then nothing is drawn. The rectangle is drawn with the 
 same pen that is used for drawLine(). This means that the actual width of the 
 rectangle as drawn is width+1, and similarly for the height. There is an extra 
 pixel along the right edge and the bottom edge. For example, if you want to draw 
 a rectangle around the edges of the component, you can say 
 "g.drawRect(0, 0, getSize().width-1, getSize().height-1);", where g is a 
 graphics context for the component. 

drawOval(int x, int y, int width, int height) -- Draws the outline of an oval. 
The oval is one that just fits inside the rectangle specified by x, y, width, 
and height. If width equals height, the oval is a circle.

drawRoundRect(int x, int y, int width, int height, int xdiam, int ydiam) -- Draws the 
outline of a rectangle with rounded corners. The basic rectangle is specified by x, y, 
width, and height, but the corners are rounded. The degree of rounding is given by 
xdiam and ydiam. The corners are arcs of an ellipse with horizontal diameter xdiam
and vertical diameter ydiam. A typical value for xdiam and ydiam is 16. But the 
value used should really depend on how big the rectangle is. 

draw3DRect(int x, int y, int width, int height, boolean raised) -- Draws the outline
 of a rectangle that is supposed to have a three-dimensional effect, as if it is
 raised from the screen or pushed into the screen. The basic rectangle is specified
 by x, y, width, and height. The raised parameter tells whether the rectangle seems 
 to be raised from the screen or pushed into it. The 3D effect is achieved by using 
 brighter and darker versions of the drawing color for different edges of the rectangle.
 The documentation recommends setting the drawing color equal to the background 
 color before using this method. The effect won't work well for some colors.

drawArc(int x, int y, int width, int height, int startAngle, int arcAngle) -- Draws 
part of the oval that just fits inside the rectangle specified by x, y, width, and 
height. The part drawn is an arc that extends arcAngle degrees from a starting angle 
at startAngle degrees. Angles are measured with 0 degrees at the 3 o'clock position 
(the positive direction of the horizontal axis). Positive angles are measured 
counterclockwise from zero, and negative angles are measured clockwise. To get an 
arc of a circle, make sure that width is equal to height.

fillRect(int x, int y, int width, int height) -- Draws a filled-in rectangle. This 
fills in the interior of the rectangle that would be drawn by drawRect(x,y,width,height).
 The extra pixel along the bottom and right edges is not included. The width and 
 height parameters give the exact width and height of the rectangle. For example, 
 if you wanted to fill in the entire component, you could say
 "g.fillRect(0, 0, getSize().width, getSize().height);" 

fillOval(int x, int y, int width, int height) -- Draws a filled-in oval.

fillRoundRect(int x, int y, int width, int height, int xdiam, int ydiam) -- Draws a 
filled-in rounded rectangle.

fill3DRect(int x, int y, int width, int height, boolean raised) -- Draws a filled-in 
three-dimensional rectangle.

fillArc(int x, int y, int width, int height, int startAngle, int arcAngle) -- Draw a 
filled-in arc. This looks like a wedge of pie, whose crust is the arc that would be 
drawn by the drawArc method.


--------------------------------------------------------------------------------