package Current.popups.AnimatedWord;

import Current.*;
import Current.basic.*;
import Current.manage.*;

import java.awt.*;
import java.awt.geom.*;
import java.awt.event.*;
import java.io.Serializable;

public class AnimatedWordCanvas extends Canvas implements MouseListener {
    Manager M;
    AnimatedWordContainer acont;
    AnimatedWordControlCanvas AC;
    public ColorSettings colors;
    VertexPair CV;

    String word;
    Complex[] Z=new Complex[5000];
    Complex[] B=new Complex[2];
    Complex[] v=new Complex[4];
    int location=0;
    ListenSquare[] L=new ListenSquare[20];
    Animator A;
    int speed=1;
    int cut1,cut2;
    ListenSquare[] W=new ListenSquare[5000];
    Color[] COL=new Color[10];
    int start,stop;
    String special;
    Image offscreen=null;
    int width=0;
    int height=0;
    double size;
    int shape=1;


    
    public AnimatedWordCanvas(Manager M,AnimatedWordContainer acont) {
        this.M=M;
	this.acont=acont;
        M.addListener(this);
        colors=(ColorSettings)(M.settings.getDefault(ColorSettings.class));
        word=M.getWord();
        setSize(300,300);

        addMouseListener(this);
        A=new Animator();
        try {A.start();}
        catch(Exception e){}
        start=0;stop=0;
        newWordReceived();
    }
    
    
    public void addAnimatedWordControlCanvas(AnimatedWordControlCanvas AC){
        this.AC=AC;
    }
    
    public static class ColorSettings implements Serializable {
        
        public String getTitle() {
            return "word window colors";
        }
        
        public Color bgColor=new Color(0,0,0);
        public static final String bgColor_name="background color";
        
        public Color hexColor=new Color(0,0,110);
        public static final String hexColor_name="hexagon color";

        public Color gridColor=new Color(0,50,50);
        public static final String gridColor_name="grid color";
        
        public Color pathColor=new Color(200,0,200);
        public static final String pathColor_name="path color";

        public Color onColor=new Color(255,255,0);
        public static final String onColor_name="path highlight color";
        
        public Color borderColor=new Color(80,80,80);
        public static final String borderColor_name="border color";
        
        public Color digit1Color=new Color(0,0,255);
        public static final String digit1Color_name="digit 1 color";
        
        public Color digit2Color=new Color(65,110,255);
        public static final String digit2Color_name="digit 2 color";
        
        public Color digit3Color=new Color(120,160,255);
        public static final String digit3Color_name="digit 3 color";
        
        public Color traceColor=Color.white;
        public static final String traceColor_name="trace color";
        
        public Color textColor=Color.white;
        public static final String textColor_name="text color";

        public Color leftColor=new Color(0,200,0);
        public static final String leftColor_name="left marker color";

        public Color rightColor=new Color(240,0,0);
        public static final String rightColor_name="right marker color";


        
    }
    
    public void newWordReceived() {
	v[1]=new Complex();
	v[2]=new Complex();
	v[3]=new Complex();
	if(shape==0) setVectorsRegular();
	if(shape==1) setVectorsIntegral();
        Z=WordIcon.rawPath(word,v);

        B=getLocation(word.length());
	if(Math.min(start,stop)>word.length()) {start=0;stop=0;}
        try {createBackground();}
        catch(Exception e){}
        repaint();
    }
    


    public Complex spineCompute(int i,int sp) {
	Complex[] V=new Complex[4];
	for(int ii=0;ii<=3;++ii) V[ii]=Complex.times(v[ii],new Complex(.5,0));
	if(i%2==1) return(Complex.plus(Z[i],V[sp]));
	return(Complex.minus(Z[i],V[sp]));

    }



    public void setVectorsIntegral() {
	v[0]=new Complex(0,0);
    	v[1]=new Complex(1,-2);
	v[2]=new Complex(-2,1);	
        v[3]=new Complex(1,1);
    }


    public void setVectorsRegular() {
        double pi=Math.PI;
	double arg1=pi/6+pi/2;
	double arg2=arg1+2*pi/3;
	double arg3=arg2+2*pi/3;
	v[0]=new Complex(0,0);
	v[1]=new Complex(Math.cos(arg1),Math.sin(arg1));
	v[2]=new Complex(Math.cos(arg2),Math.sin(arg2));
	v[3]=new Complex(Math.cos(arg3),Math.sin(arg3));
    }

    
    public void createBackground() {
        COL[0]=colors.digit1Color;
        COL[1]=colors.digit2Color;
        COL[2]=colors.digit3Color;
        if (offscreen!=null) offscreen.flush();
        width=getWidth();
        height=getHeight();
        offscreen = createImage(width, height);
        Graphics gfx = offscreen.getGraphics();
        Graphics2D g=(Graphics2D) gfx;
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(colors.bgColor);
        g.fillRect(0,0,width,height);
        drawBgGrid(g);

	for(int i=0;i<=3;++i) {
	    if(AC.CHOICE[2][i].on==1) drawWordMain(g,i);
	}

	for(int i=0;i<=3;++i) {
	    if(AC.CHOICE[0][i].on==1) subwordDraw(g,i);
	}

	drawOrigin(g);
	      
        makeBorder(g);
        L[6]=new ListenSquare(width-15,3,12,12,colors.textColor);
        L[6].infoRender(g);
        wordLengthRender(g);
        makeCutsMain(g);
        g.dispose();
        gfx.dispose();
    }

    
    public void paint(Graphics gfx) {
        Graphics2D g=(Graphics2D) gfx;
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
        RenderingHints.VALUE_ANTIALIAS_ON);
        if ((offscreen==null)||(width!=getWidth())||(height!=getHeight())) createBackground();
        gfx.drawImage(offscreen, 0, 0, this);
	for(int i=0;i<=3;++i) {
	    if(AC.CHOICE[1][i].on==1) wordDrawExtra(g,i);
	}
        if(AC.CHOICE[1][0].on+AC.CHOICE[1][1].on+AC.CHOICE[1][2].on+AC.CHOICE[1][3].on>0) makeCutsExtra(g);
	g.setColor(Color.white);
    }
    
    
    public void wordLengthRender(Graphics2D g) {
        g.setColor(colors.textColor);
        g.setFont(new Font("Helvetica",Font.PLAIN,10));
        Integer N=new Integer(word.length());
        g.drawString(N.toString(),4,12);
    }
    
    
    public void makeCutsMain(Graphics2D g) {
        COL[0]=colors.digit1Color;
        COL[1]=colors.digit2Color;
        COL[2]=colors.digit3Color;	
        Color[] COL2=new Color[2];
	COL2[0]=colors.bgColor;
	COL2[1]=colors.onColor;
        
        int h=getHeight();
        int w=getWidth();
        int n=word.length();
        n=n/2;
        cut1=(h*n)/(w+h);
        if(cut1==0) cut1=1;
        if(cut1==n) cut1=n-1;
        cut2=n-cut1;
        double w1=(w-56.0)/cut2;
        double h1=(h-56.0)/cut1;
        double tab1,tab2;

        tab1=16;tab2=12;
	int highlight=0;
	for(int i=0;i<2*cut1+2*cut2;++i) {
	    highlight=0;
	  if(i<cut2) {
            if((start<=stop)&&(i>=start)&&(i<=stop)) {highlight=1;}
            if((start>stop+1)&&(i>=start)) {highlight=1;}
            if((start>stop+1)&&(i<=stop)) {highlight=1;}
            int digit=Converter.getDigit(word,i+1);
            W[i]=new ListenSquare(28+w1*i,tab1,w1,tab2,COL[digit]);
            W[i].renderYLayer(g,COL[digit],COL2[highlight]);
	    Integer DIGIT=new Integer(digit+1);
	    g.setColor(colors.textColor);   
            g.setFont(new Font("Helvetica",Font.PLAIN,8));
	    g.drawString(DIGIT.toString(),(float)(W[i].x+.5*W[i].w-2),(float)(W[i].y-2));
	  }
        
	  if((i>=cut2)&&(i<cut1+cut2)) {
            int ii=i-cut2;
            if((start<=stop)&&(i>=start)&&(i<=stop)) {highlight=1;}
            if((start>stop+1)&&(i>=start)) {highlight=1;}
            if((start>stop+1)&&(i<=stop)) {highlight=1;}
            int digit=Converter.getDigit(word,i+1);
            W[i]=new ListenSquare(w-28,28+h1*ii,tab2,h1,COL[digit]);
            W[i].renderXLayer(g,COL2[highlight],COL[digit]);
            Integer DIGIT=new Integer(digit+1);
	    g.setColor(colors.textColor);   
            g.setFont(new Font("Helvetica",Font.PLAIN,8));
	    g.drawString(DIGIT.toString(),(float)(W[i].x+15),(float)(W[i].y+.5*W[i].h+4));


	  }
        
	  if((i>=cut1+cut2)&&(i<cut1+2*cut2)) {
            int ii=i-cut1-cut2;
            int i2=2*cut1+3*cut2-i-1;
            if((start<=stop)&&(i2>=start)&&(i2<=stop)) {highlight=1;}
            if((start>stop+1)&&(i2>=start)) {highlight=1;}
            if((start>stop+1)&&(i2<=stop)) {highlight=1;}
            int digit=Converter.getDigit(word,i2+1);
            W[i2]=new ListenSquare(28+w1*ii,h-28,w1,tab2,COL[digit]);
            W[i2].renderYLayer(g,COL2[highlight],COL[digit]); 
            Integer DIGIT=new Integer(digit+1);
	    g.setColor(colors.textColor);   
            g.setFont(new Font("Helvetica",Font.PLAIN,8));
	    g.drawString(DIGIT.toString(),(float)(W[i2].x+.5*W[i2].w-2),(float)(W[i2].y+22));
	  }
        
          if(i>=cut1+2*cut2) {
            int ii=i-cut1-2*cut2;
            int i2=3*cut1+4*cut2-i-1;
            if((start<=stop)&&(i2>=start)&&(i2<=stop)) {highlight=1;}
            if((start>stop+1)&&(i2>=start)) {highlight=1;}
            if((start>stop+1)&&(i2<=stop)) {highlight=1;}
            int digit=Converter.getDigit(word,i2+1);
            W[i2]=new ListenSquare(tab1,28+h1*ii,tab2,h1,COL[digit]);
            W[i2].renderXLayer(g,COL[digit],COL2[highlight]);
            Integer DIGIT=new Integer(digit+1);
	    g.setColor(colors.textColor);   
            g.setFont(new Font("Helvetica",Font.PLAIN,8));
	    g.drawString(DIGIT.toString(),(float)(W[i2].x-8),(float)(W[i2].y+.5*W[i2].h+4));


	  }
	}


	if(Math.abs(start-stop)>1) {
	    int i=start;
            int digit=Converter.getDigit(word,i+1);
	    if(i<cut2) 
                 W[i].renderYLayer(g,COL[digit],colors.leftColor);
            if((i>=cut2)&&(i<cut1+cut2))    
                 W[i].renderXLayer(g,colors.leftColor,COL[digit]);
            if((i>=cut1+cut2)&&(i<cut1+2*cut2))  
                 W[i].renderYLayer(g,colors.leftColor,COL[digit]);
            if(i>=cut1+2*cut2)     
                 W[i].renderXLayer(g,COL[digit],colors.leftColor);

	    i=stop;
            digit=Converter.getDigit(word,i+1);
	    if(i<cut2) 
                 W[i].renderYLayer(g,COL[digit],colors.rightColor);
            if((i>=cut2)&&(i<cut1+cut2))    
                 W[i].renderXLayer(g,colors.rightColor,COL[digit]);
            if((i>=cut1+cut2)&&(i<cut1+2*cut2))  
                 W[i].renderYLayer(g,colors.rightColor,COL[digit]);
            if(i>=cut1+2*cut2)     
                 W[i].renderXLayer(g,COL[digit],colors.rightColor);
	}

    
    }


    public void makeCutsExtra(Graphics2D g) {
        g.setStroke(new BasicStroke((float)(1.0)));
        W[location].mainRenderSmooth(g,colors.traceColor,Color.black);
	AC.I[0].val=location;
    }
    
    
    public void makeBorder(Graphics2D g) {
        g.setStroke(new BasicStroke((float)(1.0)));
        g.setColor(colors.borderColor);
        g.fillRect(0,0,width,28);
        g.fillRect(0,0,28,height);
        g.fillRect(width-28,0,28,height);
        g.fillRect(0,height-28,width,28);
        g.setColor(Color.blue);
        g.drawRect(28,28,width-56,height-56);
    }
    
    
    public void computeSize() {
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        int n=word.length();
        int ww=(int)(w*1.0/B[0].x);
        int hh=(int)(h*1.0/B[0].y);
        size=ww;
        if(size>hh) size=hh;
    }
    

    /**this routine finds the bounding box of the raw path, and
       also computes the center of the b.box.  The box is wide
       enough to accomodate the spines.*/

    public Complex[] getLocation(int n) {
	double mx,my,Mx,My;
      mx=1000000;
      my=1000000;
      Mx=-1000000;
      My=-1000000;
      for(int i=0;i<n;++i) {
	for(int sp=0;sp<=3;++sp) {
          Complex V=spineCompute(i,sp);
	  if(mx>V.x) mx=V.x;
	  if(Mx<V.x) Mx=V.x;
	  if(my>V.y) my=V.y;
	  if(My<V.y) My=V.y;
	}
      }
      Complex[] Z=new Complex[2];  
      Z[0]=new Complex(Mx-mx,My-my);               //dimensions
      Z[1]=new Complex((Mx+mx)/2.0,(My+my)/2.0);   //center
      return(Z);
    }




    
    public void drawOrigin(Graphics2D g) {
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        int n=word.length();
        computeSize();
        
        double xx=B[1].x;
        double yy=B[1].y;
        g.setColor(Color.white);
        float x1,y1,x2,y2;
        g.translate(30,30);

        Complex Z1=spineCompute(word.length()-1,0);
	Complex Z2=spineCompute(0,0);
        x1=(float)((Z1.x-xx)*size+w/2);
        y1=(float)((Z1.y-yy)*size+h/2);
        x2=(float)((Z2.x-xx)*size+w/2);
        y2=(float)((Z2.y-yy)*size+h/2);
	x1=(x1+x2)/2;
	y1=(y1+y2)/2;

	GeneralPath path=new GeneralPath(); 
	  path.moveTo(x1+3,y1+3);
	  path.lineTo(x1-3,y1+3);
	  path.lineTo(x1-3,y1-3);
	  path.lineTo(x1+3,y1-3);
	  path.closePath();
          g.setColor(colors.pathColor);
          g.fill(path);
          g.translate(-30,-30);
    }





    
    public void drawWordMain(Graphics2D g,int choice) {
	COL[0]=colors.pathColor;
        COL[1]=colors.digit1Color;
        COL[2]=colors.digit2Color;
        COL[3]=colors.digit3Color;
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        int n=word.length();
        computeSize();
        
        double xx=B[1].x;
        double yy=B[1].y;
        g.setColor(Color.white);
        float x1,y1,x2,y2;
        g.translate(30,30);
        

        for(int i=0;i<word.length();++i) {
            GeneralPath path=new GeneralPath();

            Complex Z1=spineCompute(i,choice);
	    Complex Z2=spineCompute(i+1,choice);
            x1=(float)((Z1.x-xx)*size+w/2);
            y1=(float)((Z1.y-yy)*size+h/2);
            x2=(float)((Z2.x-xx)*size+w/2);
            y2=(float)((Z2.y-yy)*size+h/2);

            int on=0;
            if((start<=stop)&&(i>=start)&&(i<=stop)) on=1;
            if((start>stop+1)&&(i>=start)) on=1;
            if((start>stop+1)&&(i<=stop)) on=1;
            g.setStroke(new BasicStroke((float)(2.0)));
            path.moveTo(x1,y1);
            path.lineTo(x2,y2);
	    g.setColor(COL[choice]);
            g.draw(path);
        }

	g.translate(-30,-30);
    }


    
    public void subwordDraw(Graphics2D g,int choice) {
	COL[0]=colors.pathColor;
        COL[1]=colors.digit1Color;
        COL[2]=colors.digit2Color;
        COL[3]=colors.digit3Color;
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        int n=word.length();
        computeSize();
        
        double xx=B[1].x;
        double yy=B[1].y;
        g.setColor(Color.white);
        float x1,y1,x2,y2;
        g.translate(30,30);

        for(int i=0;i<word.length();++i) {
            GeneralPath path=new GeneralPath();
            Complex Z1=spineCompute(i,choice);
	    Complex Z2=spineCompute(i+1,choice);
            x1=(float)((Z1.x-xx)*size+w/2);
            y1=(float)((Z1.y-yy)*size+h/2);
            x2=(float)((Z2.x-xx)*size+w/2);
            y2=(float)((Z2.y-yy)*size+h/2);

            int on=0;
            if((start<=stop)&&(i>=start)&&(i<=stop)) on=1;
            if((start>stop+1)&&(i>=start)) on=1;
            if((start>stop+1)&&(i<=stop)) on=1;
            g.setStroke(new BasicStroke((float)(2.0)));
            path.moveTo(x1,y1);
            path.lineTo(x2,y2);
	    if(on==1) {
               g.setColor(colors.onColor);
               g.draw(path);
	    }

	    //special case
	    if((start==stop+1)&&(i==start)) {
		path.reset();
		System.out.println("here I am " +stop);
		path.moveTo(x1+1,y1+1);
		path.lineTo(x1-1,y1+1);
		path.lineTo(x1-1,y1-1);
		path.lineTo(x1+1,y1-1);
		path.closePath();
                g.setColor(colors.onColor);
                g.draw(path);
	    }
	}


	if(Math.abs(start-stop)>1) {
            GeneralPath path=new GeneralPath();
	    int i=start;

            Complex Z1=spineCompute(i,choice);
	    Complex Z2=spineCompute(i+1,choice);
            x1=(float)((Z1.x-xx)*size+w/2);
            y1=(float)((Z1.y-yy)*size+h/2);
            x2=(float)((Z2.x-xx)*size+w/2);
            y2=(float)((Z2.y-yy)*size+h/2);

            g.setStroke(new BasicStroke((float)(2.0)));
            path.moveTo(x1,y1);
            path.lineTo(x2,y2);
	    g.setColor(colors.leftColor);
            g.draw(path);

            path=new GeneralPath();
	    i=stop;
            Z1=spineCompute(i,choice);
	    Z2=spineCompute(i+1,choice);
            x1=(float)((Z1.x-xx)*size+w/2);
            y1=(float)((Z1.y-yy)*size+h/2);
            x2=(float)((Z2.x-xx)*size+w/2);
            y2=(float)((Z2.y-yy)*size+h/2);

            g.setStroke(new BasicStroke((float)(2.0)));
            path.moveTo(x1,y1);
            path.lineTo(x2,y2);
	    g.setColor(colors.rightColor);
            g.draw(path);
	}

        g.translate(-30,-30);
        g.setStroke(new BasicStroke((float)(1.0)));
    }
    




    
    public double distanceToPath(Point X) { 
        int h=this.getHeight()-60;
        int w=this.getWidth()-60;
        double xx=B[1].x;
        double yy=B[1].y;
	double dist=100000000;
	Complex XX=new Complex(X.x-30,X.y-30);
       for(int i=0;i<word.length();++i) {
	   double x1=(Z[i].x-xx)*size+w/2;
	   double y1=(Z[i].y-yy)*size+h/2;  
           double x2=(Z[i+1].x-xx)*size+w/2;
           double y2=(Z[i+1].y-yy)*size+h/2;
	   Complex ZZ=new Complex(.5*(x1+x2),.5*(y1+y2));
           double test=Complex.dist(XX,ZZ);
           if(dist>test) dist=test;
       }
       return(dist);
    }

    public void markerSwap() {
	int temp=stop;
	stop=start;
	start=temp;
    }






    
    public void wordDrawExtra(Graphics2D g,int ch) {
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        int n=word.length();
        
        double xx=B[1].x;
        double yy=B[1].y;
        float x1,y1,x2,y2;
        g.translate(30,30);
        
        for(int ii=location;ii<location+1;++ii) {
            int i=(ii+word.length())%word.length();
            GeneralPath path=new GeneralPath();

	    Complex Z1=spineCompute(i,ch);
	    Complex Z2=spineCompute(i+1,ch);

            x1=(float)((Z1.x-xx)*size+w/2);
            y1=(float)((Z1.y-yy)*size+h/2);
            x2=(float)((Z2.x-xx)*size+w/2);
            y2=(float)((Z2.y-yy)*size+h/2);
            int digit=Converter.getDigit(word,i+1);
            g.setColor(colors.traceColor);
            g.setStroke(new BasicStroke((float)(3.0)));
            path.moveTo(x1,y1);
            path.lineTo(x2,y2);
	    if(Complex.dist(Z1,Z2)<.0000001) {
                 path.moveTo(x1+1,y1+1);
                 path.lineTo(x1+1,y1-1);
                 path.lineTo(x1-1,y1-1);
                 path.lineTo(x1-1,y1+1);
	    }
	    path.closePath();
            g.draw(path);
        }
        g.translate(-30,-30);
        g.setStroke(new BasicStroke((float)(1.0)));
    }
    
    
    




    
    
    public void drawBgGrid(Graphics2D g) {
        g.translate(30,30);

        double xx=B[1].x;
        double yy=B[1].y;
        computeSize();
        int w=this.getWidth()-60;
        int h=this.getHeight()-60;
        for(int i=0;i<word.length();i=i+2) {
            double x1=(Z[i].x-xx)*size+w/2;
            double y1=(Z[i].y-yy)*size+h/2;
            Complex z=new Complex(x1,y1);

	    if(AC.L[0].on==1) {
	      g.setColor(colors.hexColor);
              GeneralPath path1=makeHexagon(1,z,size);
              GeneralPath path2=makeHexagon(2,z,size);
              GeneralPath path3=makeHexagon(3,z,size);
              g.draw(path1);
              g.draw(path2);
              g.draw(path3);
	    } 


	    if(AC.L[1].on==1) {
	      g.setColor(colors.gridColor);
              GeneralPath path1=makeSquare(1,z,size);
              GeneralPath path2=makeSquare(2,z,size);
              GeneralPath path3=makeSquare(3,z,size);
              g.draw(path1);
              g.draw(path2);
              g.draw(path3);
	    } 



        }
        g.translate(-30,-30);
    }
    



    public GeneralPath makeHexagon(int j,Complex W,double r) {
        GeneralPath path=new GeneralPath();

	Complex ZERO=new Complex(0,0);
	Complex[] V=new Complex[6];
	V[0]=v[1];
	V[1]=Complex.minus(ZERO,v[2]);
	V[2]=v[3];
	V[3]=Complex.minus(ZERO,v[1]);
	V[4]=v[2];
	V[5]=Complex.minus(ZERO,v[3]);
	for(int i=0;i<=5;++i) {
	    V[i]=Complex.plus(W,Complex.times(V[i],new Complex(r,0)));
	}

	path.moveTo((float)(V[0].x),(float)(V[0].y));
	for(int i=1;i<=5;++i) 
	path.lineTo((float)(V[i].x),(float)(V[i].y));
	path.closePath();

	AffineTransform AT=new AffineTransform();
	Complex TRANS=Complex.times(v[j],new Complex(r,0));
	AT.setToTranslation((float)(TRANS.x),(float)(TRANS.y));
	path.transform(AT);
	return(path);
    }
    




    public GeneralPath makeSquare(int j,Complex W,double r) {
        GeneralPath path=new GeneralPath();

	Complex ZERO=new Complex(0,0);
	Complex[] V=new Complex[6];
	V[0]=v[1];
	V[1]=Complex.minus(ZERO,v[2]);
	V[2]=v[3];
	V[3]=Complex.minus(ZERO,v[1]);
	V[4]=v[2];
	V[5]=Complex.minus(ZERO,v[3]);
	for(int i=0;i<=5;++i) {
	    V[i]=Complex.plus(W,Complex.times(V[i],new Complex(r,0)));
	}


	Complex[] VV=new Complex[6];
	for(int i=0;i<=5;++i) VV[i]=new Complex(V[i].x,V[i].y);
	VV[0]=VV[0].plus(VV[1]);
	VV[0]=VV[0].times(new Complex(.5,0));
	VV[1]=V[2].plus(Complex.times(V[1].minus(V[0]),new Complex(.5,0)));
	VV[2]=VV[3].plus(VV[4]);
	VV[2]=VV[2].times(new Complex(.5,0));
	VV[3]=V[5].plus(Complex.times(V[4].minus(V[3]),new Complex(.5,0)));

	path.moveTo((float)(VV[0].x),(float)(VV[0].y));
	for(int i=1;i<=3;++i) 
	path.lineTo((float)(VV[i].x),(float)(VV[i].y));
	path.closePath();

	AffineTransform AT=new AffineTransform();
	Complex TRANS=Complex.times(v[j],new Complex(r,0));
	AT.setToTranslation((float)(TRANS.x),(float)(TRANS.y));
	path.transform(AT);
	return(path);
    }
    







    public void manualSelect(int a,int b) {
	start=a;stop=b;
     if((start<stop)&&(stop<word.length()-1)) {
                special=word.substring(start+1,stop+2);
            }
            
            if((start<stop)&&(stop==word.length()-1)) {
                special=word.substring(start+1,stop+1)+word.substring(0,1);
            }
            
            if(start>stop+1) {
                special=word.substring(start+1,word.length())+word.substring(0,stop+2);
            }
            M.mcbSend(new McbSubword(special));
    }
    
    
    class Animator extends Thread {
        public int count;
        int delay=512;
        
        public void run() {
            
            count=0;
            while(delay!=Integer.MAX_VALUE) {
                int r=word.length();
                if(speed>0) ++count;
                if(speed<0) --count;
                count=(count+r)%r;
                try {sleep(delay);}
                catch(Exception e) {}
                if(speed!=0) location=count;
                repaint();
		AC.repaint();
                yield();
            }
        }
    }
    
    public void mousePressed(MouseEvent e) {}
    public void mouseReleased(MouseEvent e) {}
    public void mouseEntered(MouseEvent e) {}
    public void mouseExited(MouseEvent e) {}
    
    public synchronized void mouseClicked(MouseEvent e) {
        ListenSquare frame=new ListenSquare(32,32,this.getWidth()-64,this.getHeight()-164,Color.white);
        MouseData MD=MouseData.process(M,e);
        int mode=MD.mode;
        Point X=MD.X;

        int test=-1;
        for(int i=0;i<word.length();++i) {
            if(W[i].inside(X)==1) test=i;
        }

        if(test!=-1) {
            if(mode==1) manualSelect(test,stop);
            if(mode==3) manualSelect(start,test); 
        }

        if(L[6].inside(X)==1) document();

	if(frame.inside(X)==1) {
	  if(mode==2) markerSwap();
	  manualSelect(start,stop);
	}

        createBackground();
        repaint();
    }
    
    
    
    /** This is called when the popup is closed */
    public void mcbCleanup() {
        M.remove(this);
    }
    
    public void mcbReceive(ColorSettings s) {
        createBackground();
        repaint();
    }
    
    /** This will be called when a new tile is selected or a new word is selected */
    public void mcbReceive(Tile t) {
        word=t.getStringWord();
        newWordReceived();
    }    
    
    public void document() {
        M.mcbSend(new HelpDocument("AnimatedWordCanvas.html"));
    }    
    

    
}