import java.awt.*;
import java.applet.Applet;

public class SnowflakeApplet extends Applet implements Runnable
{
	GraphCanvas3	tafel;
	ButtonControl3	buttonPanel;
	Thread			runner;
	
	public void init() {
		setBackground(Color.white);
		GridBagLayout gridbag = new GridBagLayout();
		setLayout(gridbag);
		GridBagConstraints c = new GridBagConstraints();
		c.fill = GridBagConstraints.BOTH;
		c.gridwidth = GridBagConstraints.REMAINDER;
		c.weightx = 1.0;
		c.weighty = 0.0;
		LabelPanel l = new LabelPanel(" Click on the part of the curve you want to zoom in on:");
		gridbag.setConstraints(l,c);
		add(l);
		c.fill = GridBagConstraints.BOTH;
		c.gridwidth = GridBagConstraints.REMAINDER;
		c.weightx = 1.0;
		c.weighty = 20.0;
		c.anchor = GridBagConstraints.WEST;
		tafel = new GraphCanvas3();
		gridbag.setConstraints(tafel,c);
		add(tafel);
		c.gridheight = GridBagConstraints.REMAINDER;
		c.weightx = 0.0;
		c.weighty = 0.0;
		buttonPanel = new ButtonControl3();
		gridbag.setConstraints(buttonPanel,c);
		add(buttonPanel);
		buttonPanel.setCanvas(tafel);
		tafel.setButtonPanel(buttonPanel);
	}
	
	public void start() {
		if (runner == null) {
			runner = new Thread(this);
			runner.start();
		}
	}
	
	public void stop() {
		if (runner != null) {
			runner.stop();
			runner = null;
		}
	}
	
	public void run() {
		while (true) {
			repaint();
			try {Thread.sleep(1000);}
			catch (InterruptedException e) {}
		}
	}
	
}

class stackFrame3 {
	double x0, y0, x1, y1, x2, y2, x3, y3, x4, y4, xc, yc, vsc, hsc;
	int seg10, seg11, seg20, seg21, seg30, seg31, cen, cbranch;
	boolean tripartite;
}

class LabelPanel extends Panel {
	LabelPanel(String s) {
		setLayout(new BorderLayout());
		Label l = new Label(s, Label.LEFT);
	    add("Center", l);
   }
}

class GraphCanvas3 extends Canvas {
	private final int arraysize = 1024;
	private final int maxStackFrames = 10;
	private final double vhratio = 1;
	private double sqrt32 = 0;
	private double[] x,y;
	private double vscale, hscale;
	private int h_prev=0,v_prev=0;
	private double x_cent, y_cent;
	private boolean tripartite = false;
	private ButtonControl3 gbuttonPanel;
	private stackFrame3[] stackFrames;
	private int stackFrameIndex;
	private int center, cen_branch;
	private int[] segStart, segEnd;
	
	GraphCanvas3() {
		x = new double[arraysize+1];
		y = new double[arraysize+1];
		segStart = new int[3];
		segEnd = new int[3];
		stackFrames = new stackFrame3[maxStackFrames];
		for (int i=0; i<maxStackFrames; i++)
			stackFrames[i] = new stackFrame3();
		sqrt32 = Math.sqrt(3)/2;
		setBackground(new Color(255,255,192));
		setForeground(Color.red);
	}
		
	public void setButtonPanel(ButtonControl3 theButtonPanel) {
		gbuttonPanel = theButtonPanel;
		reinit();
	}

	private boolean pushStackFrame() {
		stackFrame3 p;
		if (stackFrameIndex == maxStackFrames-1)
			return false;
		stackFrameIndex++;
		p = stackFrames[stackFrameIndex];
		p.x0 = x[0];
		p.y0 = y[0];
		p.x1 = x[arraysize/4];
		p.y1 = y[arraysize/4];
		p.x2 = x[arraysize/2];
		p.y2 = y[arraysize/2];
		p.x3 = x[3*arraysize/4];
		p.y3 = y[3*arraysize/4];
		p.x4 = x[arraysize];
		p.y4 = y[arraysize];
		p.xc = x_cent;
		p.yc = y_cent;
		p.vsc = hscale;
		p.hsc = vscale;
		p.seg10 = segStart[0];
		p.seg11 = segEnd[0];
		p.seg20 = segStart[1];
		p.seg21 = segEnd[1];
		p.seg30 = segStart[2];
		p.seg31 = segEnd[2];
		p.cen = center;
		p.cbranch = cen_branch;
		p.tripartite = tripartite;
		return true;
	}

	private boolean popStackFrame() {
		stackFrame3 p;
		if (stackFrameIndex == -1)
			return false;
		p = stackFrames[stackFrameIndex];
		x[0] = p.x0;
		y[0] = p.y0;
		x[arraysize/4] = p.x1;
		y[arraysize/4] = p.y1;
		x[arraysize/2] = p.x2;
		y[arraysize/2] = p.y2;
		x[3*arraysize/4] = p.x3;
		y[3*arraysize/4] = p.y3;
		x[arraysize] = p.x4;
		y[arraysize] = p.y4;
		x_cent = p.xc;
		y_cent = p.yc;
		hscale = p.vsc;
		vscale = p.hsc;
		segStart[0] = p.seg10;
		segEnd[0] = p.seg11;
		segStart[1] = p.seg20;
		segEnd[1] = p.seg21;
		segStart[2] = p.seg30;
		segEnd[2] = p.seg31;
		center = p.cen;
		cen_branch = p.cbranch;
		tripartite = p.tripartite;
		stackFrameIndex--;
		return true;
	}

	private void InitArray(double initial_x, double initial_y, double final_x, double final_y) {
		double xt, yt, xtt, ytt;
		x[0] = initial_x;
		y[0] = initial_y;
		x[arraysize] = final_x;
		y[arraysize] = final_y;
		for (int q=arraysize/4; q>=1; q/=4) {
			for (int p=1; p<arraysize/q; p+=4) {
				xt=(x[p*q] = 2*x[(p-1)*q]/3 + x[(p+3)*q]/3);
				yt=(y[p*q] = 2*y[(p-1)*q]/3 + y[(p+3)*q]/3);
				xtt=(x[(p+2)*q] = x[(p-1)*q]/3 + 2*x[(p+3)*q]/3);
				ytt=(y[(p+2)*q] = y[(p-1)*q]/3 + 2*y[(p+3)*q]/3);
				x[(p+1)*q] = (x[(p-1)*q] + x[(p+3)*q])/2 - sqrt32*(ytt-yt);
				y[(p+1)*q] = (y[(p-1)*q] + y[(p+3)*q])/2 - sqrt32*(xt-xtt);
			}
		}
	}
	
	private void InitArray(double x0, double y0, double x1, double y1, double x2,
				double y2, double x3, double y3, double x4, double y4) {
		double xt, yt, xtt, ytt;
		x[0] = x0;
		y[0] = y0;
		x[arraysize/4] = x1;
		y[arraysize/4] = y1;
		x[arraysize/2] = x2;
		y[arraysize/2] = y2;
		x[3*(arraysize/4)] = x3;
		y[3*(arraysize/4)] = y3;
		x[arraysize] = x4;
		y[arraysize] = y4;
		for (int q=arraysize/16; q>=1; q/=4) {
			for (int p=1; p<arraysize/q; p+=4) {
				xt=(x[p*q] = 2*x[(p-1)*q]/3 + x[(p+3)*q]/3);
				yt=(y[p*q] = 2*y[(p-1)*q]/3 + y[(p+3)*q]/3);
				xtt=(x[(p+2)*q] = x[(p-1)*q]/3 + 2*x[(p+3)*q]/3);
				ytt=(y[(p+2)*q] = y[(p-1)*q]/3 + 2*y[(p+3)*q]/3);
				x[(p+1)*q] = (x[(p-1)*q] + x[(p+3)*q])/2 - sqrt32*(ytt-yt);
				y[(p+1)*q] = (y[(p-1)*q] + y[(p+3)*q])/2 - sqrt32*(xt-xtt);
			}
		}
	}

	public void reinit() {
		InitArray(0.0,1.0,sqrt32,-1.0/2.0);
		for (int i=0; i<3; i++) {
			segStart[i] = -1;
			segEnd[i] = -1;
		}
		center = -1;
		cen_branch = -1;
		stackFrameIndex = -1;
		x_cent = 0.0;
		y_cent = 0.0;
		tripartite = true;
		gbuttonPanel.grayoutZoom(true);
		repaint();
	}
	
	
	private void ConvertCoordinates(double x, double y, Point p, int rotation) {
		double xt, yt;
		if (rotation == 1) {
			xt = -x/2.0 - sqrt32*y;
			yt = sqrt32*x - y/2.0;
			x = xt;
			y = yt;
		} else if (rotation == 2) {
			xt = -x/2.0 + sqrt32*y;
			yt = -sqrt32*x - y/2.0;
			x = xt;
			y = yt;
		}
		x -= x_cent;
		y -= y_cent;
		p.move(size().width/2 + (int)(hscale*x+0.5), (int)(size().height/2 - vscale*y + 0.5));
	}
	
	private void plot(Graphics g, double x, double y, boolean started, int rotation) {
		Point p = new Point(0,0);
		ConvertCoordinates(x, y, p, rotation);
		if (started) {
			h_prev = p.x;
			v_prev = p.y;
		} else {
			if ((p.x == h_prev) && (p.y == v_prev))
				return;
			g.drawLine(h_prev, v_prev, p.x, p.y);
			h_prev = p.x;
			v_prev = p.y;
		}
	}
	
	private void setScaling(double x0, double y0, double x1, double y1) {
		double temp1, temp2, temp3, temp4,hheight,hwidth;
		hheight = size().height/2;
		hwidth = size().width/2;
		if (tripartite) {
			vscale = (1.2/1.28)*hheight;
			hscale = vscale;
			return;
		}
		temp1 =hwidth/Math.abs(x0-x_cent);
		temp2 =hheight/Math.abs((y0-y_cent)*vhratio);
		temp3 =hwidth/Math.abs(x1-x_cent);
		temp4 =hheight/Math.abs((y1-y_cent)*vhratio);
		if (temp2<temp1)
			temp1 = temp2;
		if (temp4<temp3)
			temp3 = temp4;
		if (temp1 < temp3) {
			hscale = temp3;
			vscale = temp3*vhratio;
		} else {
			hscale = temp1;
			vscale = temp1*vhratio;
		}
	}

	private int findNearest(Point p, int rotation) {
		Point r = new Point(0,0);
		int i;
		double distance = 100000.0, d;
		int candidate = 0;
		for (i=0; i<=arraysize; i++) {
			ConvertCoordinates(x[i],y[i],r, rotation);
			d = Math.abs((double)(r.x-p.x)) + Math.abs((double)(r.y-p.y));
			if (d<distance) {
				candidate = i;
				distance = d;
			}
		}
		p.x = (int) distance;
		return candidate;
	}
	
	private void ConvertCoords2(double[] c, int rotation) {
		double xt=c[0], yt=c[1];
		if (rotation == 1) {
			xt = -c[0]/2 - sqrt32*c[1];
			yt = sqrt32*c[0] - c[1]/2;
		} else if (rotation == 2) {
			xt = -c[0]/2 + sqrt32*c[1];
			yt = -sqrt32*c[0] - c[1]/2;
		}
		c[0] = xt;
		c[1] = yt;
	}
	
	public boolean mouseDown(Event evt, int u, int v) {
		Point p = new Point(u, v);
		double[] c = new double[2];
		double x0, y0, x1, y1, x2, y2, x3, y3, x4,y4;
		int i=0, j, k, min_distance=20000, temp=0;
		if (stackFrameIndex == maxStackFrames-1)
			return true;
		if (tripartite) {
			for (int rotation=0; rotation<3; rotation++) {
				p.move(u, v);
				j = findNearest(p, rotation);
				if (p.x < min_distance) {
					i = j;
					min_distance = p.x;
					temp = rotation;
				}
			}
		} else
			i = findNearest(p, 0);
		j = i - (i % 64);
		if ((i%64 <16) && ((j>=64) || tripartite))
			j -= 32;
		else if ((i%64 >48) && ((j<arraysize-64) || tripartite))
			j += 32;
		for (k=0; k<3; k++) {
			segStart[k] = -1;
			segEnd[k] = -1;
		}
		if (tripartite) {
			if (j<0) {
				segStart[(temp+1)%3] = j+arraysize;
				segEnd[(temp+1)%3] = arraysize;
				segStart[temp] = 0;
				segEnd[temp] = 32;
			} else if (j+64>arraysize) {
				segStart[temp] = arraysize-32;
				segEnd[temp] = arraysize;
				segStart[(temp+2)%3] = 0;
				segEnd[(temp+2)%3] = 32;
			} else {
				segStart[temp] = j;
				segEnd[temp] = j+64;
			}
		} else {
			segStart[0] = j;
			segEnd[0] = j+64;
		}
		center = i;
		cen_branch = temp;
		pushStackFrame();
		for (k=0; k<3; k++) {
			segStart[k] = -1;
			segEnd[k] = -1;
		}
		center = -1;
		cen_branch = -1;
		c[0] = x[i];
		c[1] = y[i];
		ConvertCoords2(c, temp);
		x_cent = c[0];
		y_cent = c[1];
		tripartite = false;
		if (j<0) {
			c[0] = x[j+arraysize];
			c[1] = y[j+arraysize];
			ConvertCoords2(c, (temp+1)%3);
		} else {
			c[0] = x[j];
			c[1] = y[j];
			ConvertCoords2(c, temp);
		}
		x0 = c[0];
		y0 = c[1];
		if (j+64>arraysize) {
			c[0] = x[j+64-arraysize];
			c[1] = y[j+64-arraysize];
			ConvertCoords2(c, (temp+2)%3);
		} else {
			c[0] = x[j+64];
			c[1] = y[j+64];
			ConvertCoords2(c, temp);
		}
		x4 = c[0];
		y4 = c[1];
		if ( j%64 == 0)
			InitArray(x0, y0, x4, y4);
		else {
			if (j<0) {
				c[0] = x[j+16+arraysize];
				c[1] = y[j+16+arraysize];
				ConvertCoords2(c, (temp+1)%3);
			} else {
				c[0] = x[j+16];
				c[1] = y[j+16];
				ConvertCoords2(c, temp);
			}
			x1 = c[0];
			y1 = c[1];
			c[0] = x[j+32];
			c[1] = y[j+32];
			ConvertCoords2(c, temp);
			x2 = c[0];
			y2 = c[1];
			if (j+64>arraysize) {
				c[0] = x[j+48-arraysize];
				c[1] = y[j+48-arraysize];
				ConvertCoords2(c, (temp+2)%3);
			} else {
				c[0] = x[j+48];
				c[1] = y[j+48];
				ConvertCoords2(c, temp);
			}
			x3 = c[0];
			y3 = c[1];
			InitArray(x0, y0, x1, y1, x2, y2, x3, y3, x4, y4);
		}
		gbuttonPanel.grayoutZoom(false);
		repaint();
		return true;
	}
		
	public void doZoomOut() {
		if (!popStackFrame())
			return;
		InitArray(x[0],y[0],x[arraysize/4],y[arraysize/4],x[arraysize/2],y[arraysize/2],
					x[3*arraysize/4],y[3*arraysize/4],x[arraysize],y[arraysize]);
		if (stackFrameIndex == -1)
			gbuttonPanel.grayoutZoom(true);
		repaint();
	}

	public void paint(Graphics g) {
		int i, rotation;
		Point p = new Point(0,0);
		setScaling(x[64], y[64], x[arraysize-64], y[arraysize-64]);
		g.setColor(getForeground());
		if (tripartite) {
			for (rotation=3; rotation>=1; rotation--)
				for (i=0; i<=arraysize; i++) {
					if (i == segStart[rotation%3])
						g.setColor(Color.blue);
					else if (i == segEnd[rotation%3])
						g.setColor(getForeground());
					else if ((i == center) && (rotation%3 == cen_branch)) {
						ConvertCoordinates(x[i], y[i], p, rotation);
						g.drawOval(p.x-2, p.y-2, 5, 5);
					}
					plot(g, x[i], y[i], i==0, rotation);
				}
		} else
			for (i=64; i<=arraysize-64; i++) {
				if (i == segStart[0])
					g.setColor(Color.blue);
				else if (i == segEnd[0])
					g.setColor(getForeground());
				else if (i == center) {
					ConvertCoordinates(x[i], y[i], p, 0);
					g.drawOval(p.x-2, p.y-2, 5, 5);
				}
				plot(g, x[i], y[i], i==64, 0);
			}
	}
}

class ButtonControl3 extends Panel{
	private GraphCanvas3 gCanvas;
	private Button zoomoutButton;
	private boolean zoomDisabled = true;

	ButtonControl3() {
		setLayout(new FlowLayout(FlowLayout.CENTER,25,5));
		Button button = new Button("Reset");
		add(button);
		zoomoutButton = new Button("Zoom Out");
		add(zoomoutButton);
	}
	
	public void setCanvas(GraphCanvas3 theCanvas) {
		gCanvas = theCanvas;
	}

	public void grayoutZoom(boolean grayout) {
		zoomDisabled = grayout;
		zoomoutButton.enable(!grayout);
		repaint();
	}

	public boolean action(Event evt, Object arg) {
		if (evt.target instanceof Button) {
			if (((String)arg).equals("Reset"))
				gCanvas.reinit();
			if (((String)arg).equals("Zoom Out") && !zoomDisabled)
				gCanvas.doZoomOut();
			return true;
		} else
			return false;
	}
}