import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class RippleApplet extends Applet {

    public static final Color FG_DEFAULT = Color.black;
    public static final Color BG_DEFAULT = Color.white;
    
    private RippleCanvas rc;

    public String getAppletInfo() {
	return "RippleApplet v.0.1, by Keunwoo Lee; copy and share at will.";
    }
    
    public void init() {
	// Set fg & bg colors.  Note that we use the getParameter
	// method inherited from java.awt.Applet.
	Color fg, bg;
	String fgParam = getParameter("FGCOLOR");
	String bgParam = getParameter("BGCOLOR");
        if (fgParam == null) {
	    fg = FG_DEFAULT;
	} else {
	    char[] fgArray = fgParam.toCharArray();
	    int fgRed = Integer.parseInt(new String(fgArray,0,2), 16);
	    int fgBlue = Integer.parseInt(new String(fgArray,2,2), 16);
	    int fgGreen = Integer.parseInt(new String(fgArray,4,2), 16);
	    fg = new Color(fgRed, fgBlue, fgGreen);
	}
	if (bgParam == null) {
	    bg = BG_DEFAULT;
	} else {
	    char[] bgArray = bgParam.toCharArray();
	    int bgRed = Integer.parseInt(new String(bgArray,0,2), 16);
	    int bgBlue = Integer.parseInt(new String(bgArray,2,2), 16);
	    int bgGreen = Integer.parseInt(new String(bgArray,4,2), 16);
	    bg = new Color(bgRed, bgBlue, bgGreen);
	}

        // create a RippleCanvas, then load (we don't, strictly
        // speaking, have to set BorderLayout, since there's only one
        // object, but this demonstrates how to use it), and go.
	rc = new RippleCanvas(fg, bg);
	setLayout(new BorderLayout());
	add(rc, BorderLayout.CENTER);
    }

    public void start() { rc.start(); }
    public void stop()  { rc.stop(); }

    /** Inner class no. 1: this is the actual component that does the
        animation work.  It would be reasonable to make this a
        non-inner class, actually, and probably better style. */
    public static class RippleCanvas extends BufferedCanvas {
	public static final int INIT_RADIUS = 4;
	public static final int EXPAND_INTERVAL_MILLIS = 8;
	public static final int MIN_NEWCIRCLE_INTERVAL = 80;
	public static final long AGE_OF_DEATH = 1000;

	private Vector c = new Vector();
	private Color fgColor, bgColor;

	public RippleCanvas(Color foreground, Color background) {
	    super();
	    this.fgColor = foreground;
	    this.bgColor = background;
	    MouseHandler m = new MouseHandler(this);
	    addMouseListener(m);
	    addMouseMotionListener(m);
	}

	public void render(Graphics g) {
	    g.setColor(bgColor);
	    g.fillRect(0, 0, getBounds().width, getBounds().height);
	    g.setColor(fgColor);
	    Circle current = null;
	    long now = System.currentTimeMillis();
	    for (int i=0; i<c.size(); /* INDEX UPDATE BELOW */ ) { 
		current = (Circle)c.elementAt(i);
		current.drawTo(g, now);
		if (current.isDead()) {
		    c.removeElementAt(i);
		} else {
		    i++;
		}
	    }
	}

        // The following methods allow you some control over how the
        // container's LayoutManager will manage your sizing.
	private final Dimension minimumSize = new Dimension(200,100);
	public Dimension getMinimumSize() {return minimumSize;}

	private final Dimension preferredSize = new Dimension(400,200);
	public Dimension getPreferredSize() {return preferredSize;}

	private final Dimension maximumSize = new Dimension(800,600);
	public Dimension getMaximumSize() {return maximumSize;}

        /** Inner class no. 2: It's actually semi-bad style to nest
            inner classes within inner classes, but there's also just
            no reason to let this class be visible outside of
            RippleCanvas. */
	private class Circle {
	    private int x=0, y=0;
	    private long birth=0;
	    private boolean dead=false;

	    public Circle(int x, int y) {
		this.x = x;
		this.y = y;
		birth = System.currentTimeMillis();
	    }
	    
	    public void drawTo(Graphics g, long now) {
		long age = now - birth;
		if (age < AGE_OF_DEATH) {
		    int radius = (int)(INIT_RADIUS + (age/EXPAND_INTERVAL_MILLIS));
		    g.drawOval(x-radius/2,y-radius/2,radius,radius);
		} else {
		    dead = true;
		}
	    }

	    public boolean isDead() {return dead;}
	    public long getAge() {return System.currentTimeMillis()-birth;}
	}

        /** Inner class no. 3: Handles all the mouse events.  Notice
            that we want to capture *all* events, including drags, so
            we implement MouseMotionListener as well. */
	private class MouseHandler
	    extends MouseAdapter implements MouseMotionListener
	{
	    Component master;
	    public MouseHandler(Component master) {
		this.master = master;
	    }
	    
	    public void mouseMoved(MouseEvent e) {}
	    public void mouseDragged(MouseEvent e) {mousePressed(e);}
	    public void mousePressed(MouseEvent e) {
                // See docs for java.awt.event.MouseEvent for details
                // on all these little flags.
		if ((e.getModifiers() & MouseEvent.BUTTON3_MASK) != 0) {
		    c.removeAllElements();

		} else if ((c.size() == 0)
			   || (((Circle)c.elementAt(c.size()-1)).getAge()
			       > MIN_NEWCIRCLE_INTERVAL)) {
                    // Basically, all the fanciness above just makes
                    // sure we don't add more than a certain number of
                    // circles per time increment.
		    c.addElement(new Circle(e.getX(), e.getY()));

		}
		master.repaint();
	    }
	}
    }
    
}