Function about the class

[sheng zhong]

Hi all

What is this base class use for? It seems use for some graph buffer for the applet. I am not sure......

  
Base class:
 

import java.awt.*;
 
public abstract class BufferedApplet extends java.applet.Applet implements Runnable
{
   public boolean damage = true; //<b>Flag advising app. program to rerender</b>
   public boolean animating = false;
   public abstract void render(Graphics g); //<b>App. defines render method</b>
 
   Image bufferImage = null;            //<b>Image for the double buffer</b>
   private Graphics bufferGraphics = null;  //<b>Canvas for double buffer</b>
   private Thread t;                    //<b>Background thread for rendering</b>
   private Rectangle r = new Rectangle(0,0,0,0); //<b>Double buffer bounds</b>
 
   //<b>Extend the start,stop,run methods to implement double buffering.</b>
 
   public void start() { if (t == null) { t = new Thread(this); t.start(); } }
   public void stop()  { if (t != null) { t.stop(); t = null; } }
   public void run() {
      try {
         while (true) { repaint(); t.sleep(30); } //<b>Repaint each 30 msecs</b>
      }
      catch(InterruptedException e){}; //<b>Catch interruptions of sleep().</b>
   }
 
   //<b>Update(Graphics) is called by repaint() - the system adds canvas.</b>
   //<b>Extend update method to create a double buffer whenever necessary.</b>
 
   public void update(Graphics g) {
      if (r.width != bounds().width || r.height != bounds().height) {
         bufferImage    = createImage(bounds().width, bounds().height);
         bufferGraphics = bufferImage.getGraphics(); //<b>Applet size change</b>
         r = bounds();                               //<b>Make double buffer</b>
         damage = true;                              //<b>Tell application.</b>
      }
      if (damage)
         render(bufferGraphics); //<b>Ask application to render to buffer,</b>
      damage = animating;        //
      paint(g);                  //<b>paste buffered image onto the applet.</b>
   }
 
   //<b>Separate paint method for application to extend if needed.</b>
 
   public void paint(Graphics g) {
      if (bufferImage != null)              //
         g.drawImage(bufferImage,0,0,this); //<b>Paste result of render().</b>
   }
}
  

[Ulf Dittmer]

It helps with implementing double buffering, which is a technique used to avoid the screen flicker you get if you repeatedly update graphics on the screen: Wikipedia: Double Buffering.

This is needed only for AWT graphics - Swing does double buffering internally.

[sheng zhong]

Thanks for the reply. Then use the code below, we can draw line on a applet.
I wonder what's the difference between class Draw and class Item?

import java.awt.*;
 
public class Draw extends BufferedApplet
{
   int w = 0, h = 0;
   Graphics g;
 
   int nItems = 0;
   Item item[] = new Item[100];
 
   Item newItem() { return (Item)(new Item()); }
 
   public void render(Graphics g) {
      this.g = g;
      if (w == 0)
         renderInit();
      renderBg();
      renderFg();
   }
 
   public void renderInit() {
      w = bounds().width;
      h = bounds().height;
   }
 
   public void renderBg() {
      g.setColor(bgColor());
      g.fillRect(0, 0, w, h);
   }
 
   public Color bgColor() {
      return bgColorData;
   }
 
   public void renderFg() {
      g.setColor(Color.black);
      for (int i = 0 ; i < nItems ; i++)
         item[i].draw(g);
   }
 
   public boolean mouseDown(Event e, int x, int y) {
      startItem(x, y);
      damage = true;
      return true;
   }
 
   public void startItem(int x, int y) { 
      item[nItems++] = newItem();
      item[nItems-1].add(x, y);
   }
 
   public boolean mouseDrag(Event el, int x, int y) {
      item[nItems-1].add(x, y);
      damage = true;
      return true;
   }
 
   public boolean mouseUp(Event el, int x, int y) {
      damage = true;
      return true;
   }
 
   Color bgColorData = Color.white;
}
 
    

 import java.awt.*;
 
public class Item
{
   static Color faintColor = new Color(10,230,20);
   static int idCount = 0;
 
   int X[] = new int[1000];
   int Y[] = new int[1000];
   int nPts = 0;
   int id = 0;
 
   public Item() {
      id = idCount++;
   }
 
   public void add(int x, int y) {
      X[nPts] = x;
      Y[nPts] = y;
      nPts++;
   }
 
   public void draw(Graphics g) {
      for (int i = 0 ; i < nPts-1 ; i++)
         drawLine(g, i);
   }
 
   public void drawLine(Graphics g, int i) {
      g.drawLine(X[i], Y[i], X[i+1], Y[i+1]);
   }
}
 
   

[Ulf Dittmer]

The two classes do completely different things, so I'm not sure what you mean by "their difference".