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

public class OrigamiApplet extends java.applet.Applet {
	Origami origami;
	public void init() { 
		setBackground(Color.white);
		origami=new Origami(); 
	}
	public void destroy() { 
		origami.frame.dispose(); 
	}
}

class Origami extends Canvas
implements MouseListener,MouseMotionListener,ItemListener,ActionListener,WindowListener {
	Frame frame=new Frame("おりがみ");
	Menu general=new Menu("おりがみ"),
		oru=new Menu("おる"),
		iroerabi=new Menu("いろ");
	MenuItem sara=new MenuItem("かみをかえる"),
		yameru=new MenuItem("やめる"),
		modosu=new MenuItem("もとい"),
		yamaori=new MenuItem("やまおり"),
		taniori=new MenuItem("たにおり"),
		orime=new MenuItem("おりめをつける"),
		migi=new MenuItem("みぎにまわす"),
		hidari=new MenuItem("ひだりにまわす"),
		ura=new MenuItem("うらがえす");
	CheckboxMenuItem grid=new CheckboxMenuItem("きちっと おる"),
		ugokasu=new CheckboxMenuItem("うごかす");
	MenuBar menubar=new MenuBar();
	Image offscreen;
	Graphics og;
	Vector kasanari,motoi;
	Point from,to,right,left;
	Color iro=new Color(0x66cc99);
	Hashtable colortable=new Hashtable();
	
	static public void main(String[] args) {
		new Origami();
	}
	
	public Origami() {
		addMouseListener(this);
		addMouseMotionListener(this);
		init();
		init();
		
		modosu.setEnabled(false);
		sara.addActionListener(this);
		yamaori.addActionListener(this);
		taniori.addActionListener(this);
		orime.addActionListener(this);
		modosu.addActionListener(this);
		migi.addActionListener(this);
		hidari.addActionListener(this);
		ura.addActionListener(this);
		yameru.addActionListener(this);
		setColor("あんずいろ",0xff9900);
		setColor("カプチーノ",0x996633);
		setColor("くもいろ",0xcccccc);
		setColor("すみいろ",0x333333);
		setColor("ミント",0x66cc99);
		setColor("モスグリーン",0x669966);
		setColor("よあけいろ",0xff6666);
		setColor("ラベンダー",0x6666cc);
		
		general.add(sara);
		general.addSeparator();
		general.add(iroerabi);
		general.add(grid);
		general.addSeparator();
		general.add(yameru);
		oru.add(modosu);
		oru.addSeparator();
		oru.add(taniori);
		oru.add(yamaori);
		oru.add(orime);
		oru.addSeparator();
		oru.add(ura);
		oru.add(ugokasu);
		oru.add(migi);
		oru.add(hidari);
		
		menubar.add(general);
		menubar.add(oru);
		
		frame.setMenuBar(menubar);
		frame.add(this,BorderLayout.CENTER);
		frame.addWindowListener(this);
		frame.setSize(360,360);
		frame.show();
	}
	
	void init() {
		motoi=kasanari;
		kasanari=new Vector();
		kasanari.addElement(new Kami(-128,-128,256,256));
		from=to=right=left=null;
	}
	
	void setColor(String name,int color) {
		MenuItem item=new MenuItem(name);
		colortable.put(item,new Color(color));
		item.addActionListener(this);
		iroerabi.add(item);
	}
	
	void attract(Point p) {
		double nearest=10;
		int x=p.x,y=p.y;
		for (int i=0;i<kasanari.size();i++) {
			Kami kami=(Kami)kasanari.elementAt(i);
			for (int j=0;j<kami.npoints;j++) {
				double distance=Math.sqrt(Math.pow(p.x-kami.xpoints[j],2)+Math.pow(p.y-kami.ypoints[j],2));
				if (distance<nearest) {
					nearest=distance;
					x=kami.xpoints[j];
					y=kami.ypoints[j];
				}
			}
		}
		if (p.x==x && p.y==y)
			for (int i=0;i<kasanari.size();i++) {
				Kami kami=(Kami)kasanari.elementAt(i);
				for (int j=0;j<kami.npoints;j++) {
					int u=kami.xpoints[(j+1)%kami.npoints]-kami.xpoints[j];
					int v=kami.ypoints[(j+1)%kami.npoints]-kami.ypoints[j];
					int dx=kami.xpoints[j]-p.x;
					int dy=kami.ypoints[j]-p.y;
					double s=(double)(-v*dx+u*dy)/(u*u+v*v);
					double t=(double)(-u*dx-v*dy)/(u*u+v*v);
					if (t>=0 && t<=1 && Math.abs(s)*Math.sqrt(u*u+v*v)<nearest) {
						nearest=Math.abs(s)*Math.sqrt(u*u+v*v);
						x=p.x-(int)(s*v);
						y=p.y+(int)(s*u);
					}
				}
			}
		p.setLocation(x,y);
	}
	
	void drawLine() {
		int u0=to.x-from.x,v0=to.y-from.y;
		for (int i=0;i<kasanari.size();i++)
			((Kami)kasanari.elementAt(i)).applied=false;
		Kami source=null;
		for (int i=kasanari.size()-1;i>=0;i--) {
			double max=-Double.MAX_VALUE,min=Double.MAX_VALUE;
			Kami kami=(Kami)kasanari.elementAt(i);
			for (int j=0;j<kami.npoints;j++) {
				int u1=kami.xpoints[(j+1)%kami.npoints]-kami.xpoints[j];
				int v1=kami.ypoints[(j+1)%kami.npoints]-kami.ypoints[j];
				int dx=kami.xpoints[j]-from.x;
				int dy=kami.ypoints[j]-from.y;
				double s=(double)(-v1*dx+u1*dy)/(v0*u1-u0*v1);
				double t=(double)(-v0*dx+u0*dy)/(v0*u1-u0*v1);
				if (t>-0.01 && t<1.01) {
					if (s>max) max=s;
					if (s<min) min=s;
				}
			}
			if (min*Math.sqrt(u0*u0+v0*v0)<1 && max*Math.sqrt(u0*u0+v0*v0)>1) {
				source=kami;
				break;
			}
		}
		if (source!=null) apply(source,(from.x+to.x)/2,(from.y+to.y)/2,-v0,u0);
		double max=-Double.MAX_VALUE,min=Double.MAX_VALUE;
		for (int i=0;i<kasanari.size();i++) {
			Kami kami=(Kami)kasanari.elementAt(i);
			if (kami.applied) for (int j=0;j<kami.npoints;j++) {
				int u1=kami.xpoints[(j+1)%kami.npoints]-kami.xpoints[j];
				int v1=kami.ypoints[(j+1)%kami.npoints]-kami.ypoints[j];
				int dx=kami.xpoints[j]-(from.x+to.x)/2;
				int dy=kami.ypoints[j]-(from.y+to.y)/2;
				double s=(double)(-v1*dx+u1*dy)/(u0*u1+v0*v1);
				double t=(double)(-u0*dx-v0*dy)/(u0*u1+v0*v1);
				if (t>=0 && t<=1) {
					if (s>max) max=s;
					if (s<min) min=s;
				}
			}
		}
		if (max>-Double.MAX_VALUE && min<Double.MAX_VALUE) {
			if (right==null) right=new Point();
			if (left==null) left=new Point();
			right.setLocation((from.x+to.x)/2-(int)(max*v0),(from.y+to.y)/2+(int)(max*u0));
			left.setLocation((from.x+to.x)/2-(int)(min*v0),(from.y+to.y)/2+(int)(min*u0));
		} else
			right=left=null;
	}
	
	void apply(Kami kami,int x,int y,int u,int v) {
		kami.applied=true;
		if (kasanari.contains(kami))
			for (int i=kasanari.indexOf(kami);i<kasanari.size();i++) {
				Kami upper=(Kami)kasanari.elementAt(i);
				if (!upper.applied && kami.intersects(upper,x,y,u,v))
					apply(upper,x,y,u,v);
			}
		for (int i=0;i<kami.npoints;i++)
			if (kami.extention[i]!=null && !kami.extention[i].applied &&
			((kami.xpoints[i]-x)*v-(kami.ypoints[i]-y)*u<0 ||
			(kami.xpoints[(i+1)%kami.npoints]-x)*v-(kami.ypoints[(i+1)%kami.npoints]-y)*u<0))
				apply(kami.extention[i],x,y,u,v);
	}
	
	void fold(boolean oru,boolean taniori) {
		if (right==null || left==null) return;
		//mirror
		Vector fold=new Vector();
		for (int i=0;i<kasanari.size();i++)
			fold.addElement(((Kami)kasanari.elementAt(i)).mirror());
		//relate
		for (int i=0;i<kasanari.size();i++) {
			Kami original=(Kami)kasanari.elementAt(i);
			Kami mirror=(Kami)fold.elementAt(i);
			for (int j=0;j<original.npoints;j++) 
				if (original.extention[j]!=null && kasanari.contains(original.extention[j]))
					mirror.extention[j]=(Kami)fold.elementAt(kasanari.indexOf(original.extention[j]));
				else mirror.extention[j]=null;
		}
		//cut
		Vector successor=new Vector();
		for (int i=0;i<kasanari.size();i++) {
			Kami original=(Kami)kasanari.elementAt(i);
			if (!original.applied && (!oru || taniori)) {
				successor.addElement(original);
				fold.setElementAt(null,i);
			} else {
				original=original.cut(right.x,right.y,left.x,left.y);
				Kami mirror=((Kami)fold.elementAt(i)).cut(left.x,left.y,right.x,right.y);
				if (original!=null) {
					successor.addElement(original);
					if (mirror!=null) {
						original.extention[original.npoints-1]=mirror;
						mirror.extention[mirror.npoints-1]=original;
					}
				}
				fold.setElementAt(mirror,i);
			}
		}
		//fold
		if (oru)
			if (taniori) for (int i=fold.size()-1;i>=0;i--) {
				Kami mirror=(Kami)fold.elementAt(i);
				if (mirror!=null) successor.addElement(mirror.reverse(right.x,right.y,left.x,left.y));
			} else for (int i=0;i<fold.size();i++) {
				Kami mirror=(Kami)fold.elementAt(i);
				if (mirror!=null) successor.insertElementAt(mirror.reverse(right.x,right.y,left.x,left.y),0);
			}
		else
			for  (int i=0;i<fold.size();i++)
				if (fold.elementAt(i)!=null)
					successor.addElement(fold.elementAt(i));
		//restructure
		for (int i=0;i<successor.size();i++) {
			Kami kami=(Kami)successor.elementAt(i);
			kami.restructure();
		}
		modosu.setEnabled(true);
		motoi=kasanari;
		kasanari=successor;
		from=to=right=left=null;
	}
	
	void turn(boolean clockwise) {
		for (int i=0;i<kasanari.size();i++) {
			Kami kami=(Kami)kasanari.elementAt(i);
			for (int j=0;j<kami.npoints;j++) {
				int x=kami.xpoints[j];
				int y=kami.ypoints[j];
				if (clockwise) {
					kami.xpoints[j]=-y;
					kami.ypoints[j]=x;
				} else {
					kami.xpoints[j]=y;
					kami.ypoints[j]=-x;
				}
			}
		}
		from=to=right=left=null;
	}
	
	void reverse() {
		Vector successor=new Vector();
		for (int i=kasanari.size()-1;i>=0;i--) {
			Kami kami=(Kami)kasanari.elementAt(i);
			successor.addElement(kami.reverse(0,100,0,-100));
		}
		for (int i=0;i<successor.size();i++) {
			Kami kami=(Kami)successor.elementAt(i);
			kami.restructure();
		}
		kasanari=successor;
		from=to=right=left=null;
	}
	
	public void mouseClicked(MouseEvent evt) {}
	public void mouseEntered(MouseEvent evt) {}
	public void mouseExited(MouseEvent evt) {}
	public void mousePressed(MouseEvent evt) {
		from=new Point(evt.getX()-getSize().width/2,evt.getY()-getSize().height/2);
		to=new Point(from);
		if (!ugokasu.getState()) {
			if (grid.getState()) attract(from);
			drawLine();
			repaint();
		}
	}
	public void mouseReleased(MouseEvent evt) {
		ugokasu.setState(false);
	}
	
	public void mouseDragged(MouseEvent evt) {
		to.setLocation(evt.getX()-getSize().width/2,evt.getY()-getSize().height/2);
		if (ugokasu.getState()) {
			for (int i=kasanari.size()-1;i>=0;i--)
				((Kami)kasanari.elementAt(i)).translate(to.x-from.x,to.y-from.y);
			from.setLocation(to);
			right=left=null;
		} else {
			if (grid.getState()) attract(to);
			drawLine();
		}
		repaint();
	}
	public void mouseMoved(MouseEvent evt) {}
	
	public void actionPerformed (ActionEvent evt) {
		if (evt.getSource()==sara) init();
		else if (evt.getSource()==taniori) fold(true,true);
		else if (evt.getSource()==yamaori) fold(true,false);
		else if (evt.getSource()==orime) fold(false,false);
		else if (evt.getSource()==modosu) {
			Vector temp=kasanari;
			kasanari=motoi;
			motoi=temp;
		} else if (evt.getSource()==migi) turn(true);
		else if (evt.getSource()==hidari) turn(false);
		else if (evt.getSource()==ura) reverse();
		else if (evt.getSource()==yameru)
			try {
				System.exit(0);
			} catch (Exception e) {
				frame.dispose();
			}
		else if (colortable.containsKey(evt.getSource()))
			iro=(Color)colortable.get(evt.getSource());
		repaint();
	}
	
	public void itemStateChanged(ItemEvent evt) {}
	
	public void paint(Graphics g) {
		offscreen=createImage(getSize().width,getSize().height);
		og=offscreen.getGraphics();
		og.translate(getSize().width/2,getSize().height/2);
		update(g);
	}
	
	public void update(Graphics g) {
		try {
			og.clearRect(-getSize().width/2,-getSize().height/2,getSize().width,getSize().height);
			for (int i=0;i<kasanari.size();i++) {
				Kami kami=(Kami)kasanari.elementAt(i);
				if (kami.omote) og.setColor(iro);
				else og.setColor(Color.white);
				og.fillPolygon(kami);
				og.setColor(Color.gray);
				og.drawPolygon(kami);
				og.setColor(Color.darkGray);
				for (int j=0;j<kami.npoints;j++)
					if (kami.extention[j]==null)
						og.drawLine(kami.xpoints[j],kami.ypoints[j]
							,kami.xpoints[(j+1)%kami.npoints],kami.ypoints[(j+1)%kami.npoints]);
			}
			if (right!=null && left!=null) {
				og.setColor(Color.red);
				og.drawLine(right.x,right.y,left.x,left.y);
			}
			if (from!=null &&to!=null && !ugokasu.getState()) {
				og.setColor(Color.blue);
				og.drawLine(from.x,from.y,to.x,to.y);
				double theta=Math.atan2(from.x-to.x,from.y-to.y);
				og.drawLine(to.x,to.y,to.x+(int)(10*Math.sin(theta+0.5)),to.y+(int)(10*Math.cos(theta+0.5)));
				og.drawLine(to.x,to.y,to.x+(int)(10*Math.sin(theta-0.5)),to.y+(int)(10*Math.cos(theta-0.5)));
			}
			g.drawImage(offscreen,0,0,this);
		} catch (NullPointerException e) {
		}
	}
	
	public void windowOpened(WindowEvent evt) {}
	public void windowActivated(WindowEvent evt) {}
	public void windowDeactivated(WindowEvent evt) {}
	public void windowIconified(WindowEvent evt) {}
	public void windowDeiconified(WindowEvent evt) {}
	public void windowClosing(WindowEvent evt) {
		try {
			System.exit(0);
		} catch (Exception e) {
			frame.dispose();
		}
	}
	public void windowClosed(WindowEvent evt) {}
}

class Kami extends Polygon {
	Kami[] extention;
	Kami next;
	boolean omote=false,applied=true;
	
	private Kami(int npoints) {
		super(new int[npoints],new int[npoints],npoints);
		extention=new Kami[npoints];
	}
	
	public Kami(int x,int y,int width,int height) {
		this(4);
		xpoints[0]=xpoints[3]=x;
		xpoints[1]=xpoints[2]=x+width;
		ypoints[0]=ypoints[1]=y;
		ypoints[2]=ypoints[3]=y+height;
	}
	
	Kami mirror() {
		Kami mirror=new Kami(npoints);
		for (int i=0;i<npoints;i++) {
			mirror.xpoints[i]=xpoints[i];
			mirror.ypoints[i]=ypoints[i];
			mirror.extention[i]=extention[i];
			mirror.omote=omote;
		}
		return mirror;
	}
	
	void restructure() {
		for (int i=0;i<npoints;i++)
			while (extention[i]!=null && extention[i].next!=null)
				extention[i]=extention[i].next;
	}
	
	Kami cut(int x0,int y0,int x1,int y1) {
		double max=-Double.MAX_VALUE,min=Double.MAX_VALUE;
		int imax=-1,imin=-1,u0=x1-x0,v0=y1-y0;
		for (int i=0;i<npoints;i++) {
			int u1=xpoints[(i+1)%npoints]-xpoints[i];
			int v1=ypoints[(i+1)%npoints]-ypoints[i];
			int dx=xpoints[i]-x0;
			int dy=ypoints[i]-y0;
			double s=(double)(-v1*dx+u1*dy)/(v0*u1-u0*v1);
			double t=(double)(-v0*dx+u0*dy)/(v0*u1-u0*v1);
			if (t>=0 && t<1) {
				if (s>max) {
					max=s;
					imax=i;
				}
				if (s<min) {
					min=s;
					imin=i;
				}
			}
		}
		if (imax>=0 && imin>=0 && imin!=imax) {
			Kami cut=new Kami((imin-imax+npoints)%npoints+2);
			cut.xpoints[0]=x0+(int)(max*u0);
			cut.ypoints[0]=y0+(int)(max*v0);
			cut.extention[0]=extention[imax];
			for (int i=1;i<cut.npoints-1;i++) {
				cut.xpoints[i]=xpoints[(i+imax)%npoints];
				cut.ypoints[i]=ypoints[(i+imax)%npoints];
				cut.extention[i]=extention[(i+imax)%npoints];
			}
			cut.xpoints[cut.npoints-1]=x0+(int)(min*u0);
			cut.ypoints[cut.npoints-1]=y0+(int)(min*v0);
			cut.omote=omote;
			return next=cut;
		} else {
			for (int i=0;i<npoints;i++)
				if ((xpoints[i]-x0)*v0-(ypoints[i]-y0)*u0>0)
					return next=null;
			return next=mirror();
		}
	}
	
	Kami reverse(int x0,int y0,int x1,int y1) {
		Kami reverse=new Kami(npoints);
		int u=x1-x0,v=y1-y0;
		for (int i=0;i<npoints;i++) {
			double s=(double)(u*(xpoints[i]-x0)+v*(this.ypoints[i]-y0))/(u*u+v*v);
			reverse.xpoints[npoints-1-i]=xpoints[i]+(int)(2*(x0+s*u-xpoints[i]));
			reverse.ypoints[npoints-1-i]=ypoints[i]+(int)(2*(y0+s*v-ypoints[i]));
			reverse.extention[(2*npoints-2-i)%npoints]=extention[i];
		}
		reverse.omote=!omote;
		return next=reverse;
	}
	
	boolean intersects(Polygon poly,int x,int y,int u,int v) {
		for (int i=0;i<npoints;i++)
			if (poly.contains(xpoints[i],ypoints[i]) && (xpoints[i]-x)*v-(ypoints[i]-y)*u<0)
				return true;
		for (int i=0;i<poly.npoints;i++)
			if (contains(poly.xpoints[i],poly.ypoints[i]) && (poly.xpoints[i]-x)*v-(poly.ypoints[i]-y)*u<0)
				return true;
		for (int i=0;i<npoints;i++) {
			int u0=xpoints[(i+1)%npoints]-xpoints[i];
			int v0=ypoints[(i+1)%npoints]-ypoints[i];
			for (int j=0;j<poly.npoints;j++) {
				int u1=poly.xpoints[(j+1)%poly.npoints]-poly.xpoints[j];
				int v1=poly.ypoints[(j+1)%poly.npoints]-poly.ypoints[j];
				int dx=poly.xpoints[j]-xpoints[i];
				int dy=poly.ypoints[j]-ypoints[i];
				double s=(double)(-v1*dx+u1*dy)/(v0*u1-u0*v1);
				double t=(double)(-v0*dx+u0*dy)/(v0*u1-u0*v1);
				if (s>=0 && t>=0 && s<1 && t<1
				&& (xpoints[i]+s*u0-x)*v-(ypoints[i]+s*v0-y)*u<0)
					return true;
			}
		}
		return false;
	}
}