// Leaf.java - fractal animation for arcadia play
//
// adapted from fractal4.p
//
// Daniel Scharstein 9/28/2003

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

public class Leaf3 extends Applet {

    LeafCanvas3 c;
    
    public void init () {
	setLayout(new BorderLayout());
	add("South", new Button("Clear"));
	int psize = 1; // pointsize for drawing (1 or 2)
	c = new LeafCanvas3(psize);
	c.setBackground(new Color(0, 0, 120));
	add("Center", c);
    }

    public boolean action(Event evt, Object arg)  {
	if (evt.target instanceof Button) {
	    if ("Clear".equals(arg)) {
		c.clear();
		return true;
	    }
	}
	// other events should be handled by superclass
	return super.action(evt, arg);
    }
}

class LeafCanvas3 extends Canvas {

    Vector v = new Vector();
    Random rand = new Random(); // new Random(seed)
    int count = 0;
    int rad = 1; // point size (1 or 2)

    public LeafCanvas3(int psize) {
	rad = psize;
    }

    Image offscreen;
    Dimension offscreensize;
    Graphics offgraphics;

    // update() is like paint(), except it doesn't erase the old image first
    public void update(Graphics g) {
        Dimension d = size();

	// initially (or when size changes) create new image
        if ((offscreen == null)
	    || (d.width != offscreensize.width)
	    || (d.height != offscreensize.height)) {
            offscreen = createImage(d.width, d.height);
            offscreensize = d;
            offgraphics = offscreen.getGraphics();
            offgraphics.setFont(getFont());
        }
	
	// erase old contents in first few iterations
	if (count < 30) {
	    offgraphics.setColor(getBackground());
	    offgraphics.fillRect(0, 0, d.width, d.height);
	}
	// now, draw as usual, but use offgraphics instead of g
	
	// draw all circles
	offgraphics.setColor(Color.yellow);
	for (int i=0; i<v.size(); i++) {
	    Mypoint3 p = (Mypoint3)v.elementAt(i);
	    p.draw(offgraphics, offscreensize, rad);
	}

	// finally, draw the image on top of the old one
	
	g.drawImage(offscreen, 0, 0, null);	
    }


    // this is called when window is uncovered or resized
    public void paint(Graphics g) {
	update(g);
    }
    

    // erase all dots
    public void clear() {
	v = new Vector();
	count = 0;
	repaint(); // calls update()
    }

    // add some points
    public boolean mouseDown(Event evt, int mx, int my)  {
	//Point p = new Point(mx, my);
	if (v.isEmpty()) {
	    for (int i=0; i<3000; i++) {
		double x = 10*rand.nextDouble()-5;
		double y = 10*rand.nextDouble();
		Mypoint3 p = new Mypoint3(x, y);
		v.addElement(p);
	    }
	    count = 0;
	} else {
	    for (int i=0; i<v.size(); i++) {
		Mypoint3 p = (Mypoint3)v.elementAt(i);
		p.update(rand.nextDouble());
	    }
	    count++;
	}

	repaint(); // calls update()
	return true;
    }
}

class Mypoint3 {
    double px, py;

    public Mypoint3(double x, double y) {
	px = x;
	py = y;
    }

    public Mypoint3() {
	this(0, 0);
    }
    
    public void t1() {
	px = 0;
	py *= 0.16;
    }

    public void t2() {
	double x = px, y = py;
	px = 0.85 * x + 0.04 * y;
	py = -0.04 * x + 0.85 * y + 1.6;
    }

    public void t3() {
	double x = px, y = py;
	px = 0.2 * x - 0.26 * y;
	py = 0.23 * x + 0.22 * y + 1.6;
    }

    public void t4() {
	double x = px, y = py;
	px = -0.15 * x + 0.28 * y;
	py = 0.26 * x + 0.24 * y + 0.44;
    }

    public void update(double r) { // r should be a random number in 0..1
	double p1 = .01;
	double p2 = .81;
	double p3 = .00;   // changed from .09
	double p4 = .18;   // changed from .09
	if (r < p1) 
	    t1();
	else if (r < p1 + p2)
	    t2();
	else if (r < p1 + p2 + p3)
	    t3();
	else
	    t4();
    }
    public void draw(Graphics g, Dimension d, int rad) {
	int x, y;
	if (false) { // portrait
	    int sy = (d.height-20)/10;
	    int sx = (int)(d.width/5.5);
	    x = d.width/2+(int)(sx*px);
	    y = d.height-10-(int)(sy*py);
	} else { // landscape
	    int sy = (d.width-20)/10;
	    int sx = (int)(d.height/5.5);
	    y = d.height/2+(int)(sx*px);
	    x = 10 + (int)(sy*py);
	}
	g.fillRect(x, y, rad, rad);
    }
}