Class Graphics

the abstract base class of all drawable regions:
- may be on screen or off screen
contains:
- a translation origin
- a clipping region
- a current co.or
- a current font
- a logical pixel operation (XOR or Paint)
- the XOR alternation color

Drawing strings

void drawString(String str, int x, int y);

Drawing Images

returns false if image isn't fully drawn

notifies ImageObserver when done

import java.awt.awt.image;
boolean drawImage(Image img, int x, int y,
    int width, int height, Color bgcolor,
    ImageObserver observer);

Drawing shapes

void drawLine(int x1, int y1, int x2, int y2);
void draw3DRect(int x, int y, int width,
    int height, boolean raised);
void drawArc(int x, int y, int width,
  int height, int startAngle, int arcAngle);
void drawOval(int x, int y, int width,
    int height);
void drawPolygon(int xPoints[], int yPoints[],
    int nPoints);
void drawRect(int x, int y,
    int width, int height);
void drawRoundRect(int x, int y, int width,
    int height, int arcWidth, int arcHeight);

Filling

void fill3DRect(int x, int y, int width,
             int height, boolean raised);
void fillArc(int x, int y, int width,
    int height, int startAngle, int arcAngle);
void fillOval(int x, int y, int width, int height);
void fillPolygon(int xPoints[], int yPoints[],
    int nPoints);
void fillPolygon(Polygon p);
void fillRect(int x, int y, int width,
    int height);
void fillRoundRect(int x, int y, int width,
    int height, int arcWidth, int arcHeight);

Component related methods

Color getColor();
void setColor(Color c);
Font getFont();
void setFont(Font font);
FontMetrics getFontMetrics();
FontMetrics getFontMetrics(Font f);
Rectangle getClipRect();
void setPaintMode();
void setXORMode(Color c1);

Clipping/clearing/copying/moving

void clipRect(int x, int y, int width, int height);
void clearRect(int x, int y, int width, int height);
void copyArea(int x, int y, int width, int height, int dx, int dy);
void translate(int x, int y);

Creating a new graphics from this graphics

Graphics create();
Graphics create(int x, int y, int width, int height);

Fonts/Colors

Java predefined fonts
- Helvetica, TimesRoman, Courier, Dialog,
- DialogInput, ZapfDingbats, default
Java predefined Colors
- black, blue, cyan, darkGray, gray, green, lightGray,
- magenta, orange, pink, red, white, yellow

Drawing An Image

Graphics.drawImage() displays an image

Images are loaded and drawn asynchronously

import java.applet.Applet;
import java.awt.*;
public class SimpleImage
  ends Applet
{
  Image im;
  public void init()
  {
    im = getImage(getCodeBase(), "MyImage.gif");
  }
  public void paint(Graphics g)
  {
    g.drawImage(im, 0, 0, this);
  }
}

this is passed as the ImageObserver so we will be notified when \ image is loaded/displayed
```
boolean imageUpdate(Image img, int infoflags,
  int x, int y, int width, int height);
```
can use a MediaTracker to wait for a group of images

Computed Animation

Extended example: clipping and double buffering

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
public class Animation
  extends Applet
  implements Runnable
{
  int approach = 0;
  static final String message = "Animation";
  Color c1 = new Color(0x0000ff);
  Color c2 = new Color(0xffffff);
  Font font = new Font("Helvetica", Font.BOLD, 24);
  FontMetrics fm = getFontMetrics(font);
  int msgAscent = fm.getAscent(),
    msgWidth = fm.stringWidth(message),
    msgHeight = fm.getHeight();
  int dx = 4, dy = 2;
  Thread animator;
  Image offscreen;
  Dimension dim;
  int x = 0, y = 0;
  public void init()
  {
    dim = getSize();
    offscreen = createImage(dim.width, dim.height);
    addMouseListener(new MyMouseListener());
  }
  public void start()
  {
    (animator = new Thread(this)).start();
  }
  public void stop()
  {
    animator.stop();
    animator = null;
  }
  void drawBackground(Graphics gr, Color c1, Color c2, int n)
  {
    int dr = (c2.getRed()-c1.getRed())/n;
    int dg = (c2.getGreen()-c1.getGreen())/n;
    int db = (c2.getBlue()-c1.getBlue())/n;
    int h = dim.height, w = dim.width;
    int dw = w/n;
    int dh = h/n;
    gr.setColor(c1);
    gr.fillRect(0, 0, w, h);
    for (int r = c1.getRed(), g=c1.getGreen(), b=c1.getBlue();
         h > 0;
         h -= dh, w -= dw, r += dr, g += dg, b += db)
    {
        gr.setColor(new Color(r,g,b));
        gr.fillArc(-w, -h, 2*w, 2*h, 0, -90);
    }
  }
  public void paint(Graphics g)
  {
    drawBackground(g, c1, c2, 25);
    g.setColor(Color.black);
    g.setFont(font);
    g.drawString(message, x, y);
  }
  public void run()
  {
    while (true)
    {
      repaint();
      try {
        animator.sleep(20);
      } catch (Exception e) {}
    }
  }
  class MyMouseListener
    extends MouseAdapter
  {
    public void MousePressed(MouseEvent e)
    {
      approach = ( approach + 1 ) % 4;
      x = e.getX(); y = e.getY();
    }
  }
  public void plainUpdate(Graphics g)
  {
    x = (x + dx) % dim.width;
    y = (y + dy) % dim.height;
    paint(g);
  }
  public void clippingUpdate(Graphics g)
  {
    Rectangle oldRect =
      new Rectangle(x, y-msgAscent, msgWidth, msgHeight);
    x = (x + dx) % dim.width;
    y = (y + dy) % dim.height;
    Rectangle newRect =
      new Rectangle(x, y-msgAscent, msgWidth, msgHeight);
    Rectangle union = newRect.union(oldRect);
    g.clipRect(union.x, union.y, union.width, union.height);
    paint(g);
  }
  public void bufferedUpdate(Graphics g)
  {
    x = (x + dx) % dim.width;
    y = (y + dy) % dim.height;
    paint(offscreen.getGraphics());
    g.drawImage(offscreen, 0, 0, this);
  }
  public void bufferedClippingUpdate(Graphics g)
  {
    Rectangle oldRect =
      new Rectangle(x, y-msgAscent, msgWidth, msgHeight);
    x = (x + dx) % dim.width;
    y = (y + dy) % dim.height;
    Rectangle newRect =
      new Rectangle(x, y-msgAscent, msgWidth, msgHeight);
    Rectangle union = newRect.union(oldRect);
    Graphics og = offscreen.getGraphics();
    og.clipRect(union.x, union.y, union.width, union.height);
    paint(og);
    g.clipRect(union.x, union.y, union.width, union.height);
    g.drawImage(offscreen, 0, 0, this);
  }
  public void update(Graphics g)
  {
    switch (approach)
    {
      case 0:
        plainUpdate(g);
        break;
      case 1:
        clippingUpdate(g);
        break;
      case 2:
        bufferedUpdate(g);
        break;
      case 3:
        bufferedClippingUpdate(g);
        break;
    }
   }
}