Learning Java - Chapter 6 : Java

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.

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.

Note that the basci AWT coordinate system for the Graphics context methods goes as follows:

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.)

(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.

DrawApplet.java +
DrawingPanel.java

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.: