/***  Advanced Topics:   Double-Buffering. 
      http://www.csie.nctu.edu.tw/~tsaiwn/course/java/examples/doublebuffer/
               from: http://www.realapplets.com/tutorial/DoubleBuffering.html
 Drawing in applets is almost always done with double-buffering. 
 This means that drawing is first done to an offscreen image, and when all 
 is done, the offscreen image is drawn on the screen. This reduces the nasty
 flickering applets otherwise have. Note the update() method in this example */ 

import java.applet.*; 
import java.awt.event.*; 
import java.awt.*; 
public class DBuffer extends Applet implements MouseMotionListener 
{    // The object we will use to write with instead of the standard screen graphics 
     Graphics bufferGraphics;  // ¥Î¨Óµe¦b°O¾ÐÅ骺¹Ï  
     Image offscreen;  // The image that will contain everything that ..
                      /// .. has been drawn on bufferGraphics. 
     Dimension dim;   // To get the width and height of the applet. 
     int curX, curY; 
     public void init( )  {  // ¥ý§â¥t¤@¥÷°O¾ÐÅ餤ªº Image© M Graphics ·Ç³Æ¦n
          dim = getSize();  // obtain the width and height
             // Create an offscreen image to draw on 
             // Make it the size of the applet, this is just perfect.
             // Larger size could slow it down unnecessary. 
          offscreen = createImage(dim.width, dim.height); 
             // by doing this everything that is drawn by bufferGraphics 
             // will be written on the offscreen image. 
          bufferGraphics = offscreen.getGraphics();  // use Graphics methods
           // We'll redraw the applet eacht time the mouse has moved. 
          addMouseMotionListener(this); 
          setBackground(Color.black); 
     }  // init( )
      public void paint(Graphics g)  {  // ¥ýµe¦b°O¾ÐÅ骺 bufferGraphics
           // Wipe off everything that has been drawn before 
           // Otherwise previous drawings would also be displayed. 
          bufferGraphics.clearRect(0,0,dim.width,dim.width); // °O¾ÐÅ騺¥÷ 
          bufferGraphics.setColor(Color.red); 
          bufferGraphics.drawString("Double-buffered", 10, 10); 
           // draw the rect at the current mouse position to the offscreen image
          bufferGraphics.fillRect(curX, curY, 20, 20); 
           // draw the offscreen image to the screen like a normal image. 
           // Since offscreen is the screen width we start at 0,0. 
           // ´N¬O»¡§â¤w°½°½µe¦nªº offscreen ·í¤@¯ë Image¶Çµ¹ g µe¨ì¿Ã¹õ
       // ª`·N§Ú­Ì¬O³z¹L bufferGraphics(¬OGraphics) µe¨ì offscreen (¬OImage)
          g.drawImage(offscreen, 0, 0, this);   // ¦¹®É¤~µe¨ì¿Ã¹õ 
     }  // paint (g)
      // rewrite update( ) : Always required for good double-buffering.
     // ..This will cause the applet not to first wipe off previous drawings
     //..but to immediately repaint. The wiping off also causes flickering. 
      //.. Update is called automatically when repaint() is called. 

     public void update(Graphics g) { paint(g); }   // ª½±µ¥s paint( )

      // Save the current mouse position to paint a rectangle there. 
      // and request a repaint() 
     public void mouseMoved(MouseEvent evt)  
     {    curX = evt.getX(); 
          curY = evt.getY(); 
          repaint(); 
     } 
     public void mouseDragged(MouseEvent evt)  { } // another necessary method.
 } 
/* This is all about double-buffering. It's easy to use and recommended to use always. 
 There is one dangerous pitfall here, when you create an offscreen image that's very large.
 The applet might run slow because it takes a lot of resources and effort. 
 It is not recommended to have offscreen images larger than 500*500 when redrawn at 30FPS.
*/