/*
 * This is the CurvePanel class for the Famous Curves applet.
 * Author: Ben Soares < bs@st-and.ac.uk >
 *
 */

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

public class CurvePanel extends Panel {

 // class variable

 static Color darkGreen;

 // member variables

 int pointstage;		//stage at which a chosen point is (0=no point chosen, 1=point chosen)
 int pointX, pointY;		//chosen point position
 int circlestage;		//stage at which a chosen circle is (0=no circle chosen, 1=choosing radius, 2=dragging circle)
 int circleX, circleY, circleCX, circleCY, circleR;
				//chosen circle centre position, circumference point, and radius
 int associatedcurveindex;	//which associated curve option is selected
				/* (0=None, 1=Evolute, 2=Involute, 3=Inverse, 4=Pedal,
				 *  5=Negative Pedal, 6=Caustic, 7=Caustic (parallel lines)) */
 int associatedcurve[][];	//the pixel points of the associated curve
 Curve curve;			//the curve being dealt with
 boolean setaxis;		//have Curves class variables been set?
 boolean clear;			//do you want to clear the curvepanel picture?
 double a, b, c, d, e, f, h, k, m, n, p;// the curves original parameter values
 int steps = 1;				// how many steps to take at each line plot of curve
  // CurvePanel constructor methods
  
public CurvePanel(Curve curve, int associatedcurveindex) {
  
  setBackground(Color.white);
  this.setaxis = false;
  this.curve = curve;
  Font font = new Font("Helvetica", Font.PLAIN, 12);
  setFont(font);
  //  Label label = new Label(curve.name, Label.CENTER);
  //  add(label);
  
  this.pointstage = 0;
  this.circlestage = 0;
  this.pointX = 0;
  this.pointY = 0;
  this.circleX = 0;
  this.circleY = 0;
  this.circleCX = 0;
  this.circleCY = 0;
  this.circleR = 0;
  this.associatedcurveindex = associatedcurveindex;
  this.clear = false;
  darkGreen = new Color(0,140,0);
  
}
  
public CurvePanel(Curve curve){
  
  setBackground(Color.white);
  this.setaxis = false;
  int xsc = (int)(size().width/(curve.xrange*(3/2)));
  int ysc = (int)(size().height/(curve.yrange*(3/2)));
  int sc = Math.min(xsc, ysc);
  Curve.xsc = sc;
  Curve.ysc = sc;
  Curve.Ox = (int)(curve.xb*Curve.xsc*(-3/2));
  Curve.Oy = (int)(curve.yt*Curve.xsc*(3/2));
  Curve.xsize = size().width;
  Curve.ysize = size().height;
  this.curve = curve;
  
  Font font = new Font("Helvetica", Font.PLAIN, 14);
  setFont(font);
  //  Label label = new Label(curve.name, Label.CENTER);
  //  add(label);
  
  this.pointstage = 0;
  this.circlestage = 0;
  this.pointX = 0;
  this.pointY = 0;
  this.circleX = 0;
  this.circleY = 0;
  this.circleCX = 0;
  this.circleCY = 0;
  this.circleR = 0;
  this.associatedcurveindex = 0;
  this.clear = false;
  darkGreen = new Color(0,140,0);
  
} /* end of constructor methods */
  
  // recalculate associated curve method (for scales and translations)
  
public void recalculate() {
  
  switch (associatedcurveindex) {
    
  case 0:			// "None"
    break;
    
  case 1:			// "Evolute"
    this.associatedcurve = curve.evolutePixels();
    break;
    
  case 2:			// "Involute"
    this.associatedcurve = curve.involutePixels(pointX, pointY);
    break;
    
  case 3:			// "Inverse"
    this.associatedcurve = curve.inversePixels(circleX, circleY, circleCX, circleCY);
    break;
    
  case 4:			// Pedal
    this.associatedcurve = curve.pedalPixels(pointX, pointY);
    break;
    
  case 5:			// Negative pedal
    this.associatedcurve = curve.negativePedalPixels(pointX, pointY);
    break;
    
  case 6:			// Caustic
    this.associatedcurve = curve.causticPixels(pointX, pointY);
    break;
    
  case 7:			// Caustic (parallel lines)
    this.associatedcurve = curve.causticPixels(pointX, pointY, new String("parallel"));
    break;
    
  }
  
  this.pointX = Curve.xPointToPixel(Curve.xPixelToPoint(pointX));
  this.pointY = Curve.yPointToPixel(Curve.yPixelToPoint(pointY));
  this.circleX = Curve.xPointToPixel(Curve.xPixelToPoint(circleX));
  this.circleY = Curve.yPointToPixel(Curve.yPixelToPoint(circleY));
  this.circleCX = Curve.xPointToPixel(Curve.xPixelToPoint(circleCX));
  this.circleCY = Curve.yPointToPixel(Curve.yPixelToPoint(circleCY));
  this.circleR = (int)(Math.sqrt((circleCX-circleX)*(circleCX-circleX) + (circleCY-circleY)*(circleCY-circleY)));
  
} /* end of recalculate method */
  
  
  // beginning of scale method
  
public void scale (double f) {
  
  this.pointX = Curve.xPointToPixel(f*Curve.xPixelToPoint(this.pointX));
  this.pointY = Curve.yPointToPixel(f*Curve.yPixelToPoint(this.pointY));
  this.circleX = Curve.xPointToPixel(f*Curve.xPixelToPoint(this.circleX));
  this.circleY = Curve.yPointToPixel(f*Curve.yPixelToPoint(this.circleY));
  this.circleCX = Curve.xPointToPixel(f*Curve.xPixelToPoint(this.circleCX));
  this.circleCY = Curve.yPointToPixel(f*Curve.yPixelToPoint(this.circleCY));
  this.circleR = (int)(Math.sqrt((circleCX-circleX)*(circleCX-circleX)+(circleCY-circleY)*(circleCY-circleY)));
  
} /* end of scale method */
  
  // beginning of translate method
  
public void translate (int xt, int yt) {
  
  this.pointX = this.pointX + xt;
  this.pointY = this.pointY + yt;
  this.circleX = this.circleX + xt;
  this.circleY = this.circleY + yt;
  this.circleCX = this.circleCX + xt;
  this.circleCY = this.circleCY + yt;
  
} /* end of translate method */
  
  // beginning of setParameters method
  
public void setParameters(double a, double b, double c, double d, double e, double f, double h, double k, double m, double n, double p) {
  this.a = a;
  this.b = b;
  this.c = c;
  this.d = d;
  this.e = e;
  this.f = f;
  this.h = h;
  this.k = k;
  this.m = m;
  this.n = n;
  this.p = p;
} /* end of setParameters method */
  
  // beginning of resetCurveParameters method
  
public void resetCurveParameters() {
  this.curve.a = this.a;
  this.curve.b = this.b;
  this.curve.c = this.c;
  this.curve.d = this.d;
  this.curve.e = this.e;
  this.curve.f = this.f;
  this.curve.h = this.h;
  this.curve.k = this.k;
  this.curve.m = this.m;
  this.curve.n = this.n;
  this.curve.p = this.p;
} /* end of resetCurveParameters method */
  
  // mousedown method
  
public boolean mouseDown(Event e, int mx, int my) {
  
  switch (associatedcurveindex) {
    
  case 0:			// "None"
    break;
    
  case 1:			// "Evolute"
    // note this should be drawn from when it is chosen
    break;
    
  case 2:			// "Involute"
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.involutePixels(pointX, pointY);
    repaint();
    break;
    
  case 3:			// "Inverse"
    boolean redraw = true;
    double mR = Math.sqrt( (mx-circleX)*(mx-circleX) + (my-circleY)*(my-circleY) );	// mouse distance from centre
    switch (circlestage) {
    case 0:		// no circle yet
      circleX = mx;
      circleY = my;
      circleCX = mx;
      circleCY = my;
      circleR = 2;
      circlestage = 1;
      break;
    case 1:		// after choosing radius
      if ( circleR-1 < mR && mR < circleR+2 ) {		// if mouse is "on" circumference
	circleCX = mx;
	circleCY = my;
	circleR = (int)(mR);
	circlestage = 1;
	redraw = false;
      } else if ( mR < 4 ) {				// if mouse is "on" centre
	circleX = mx;
	circleY = my;
	circlestage = 2;
	redraw = false;
      } else {						// otherwise start new circle
	circleX = mx;
	circleY = my;
	circleCX = mx;
	circleCY = my;
	circleR = 2;
	circlestage = 1;
      }
      break;
    case 2:		// after dragging circle (same as after choosing radius)
      if ( circleR-2 < mR && mR < circleR+3 ) {		// if mouse is "on" circumference
	circleCX = mx;
	circleCY = my;
	circleR = (int)(mR);
	circlestage = 1;
	redraw = false;
      } else if ( mR < 3 ) {				// if mouse is "on" centre
	circleX = mx;
	circleY = my;
	circlestage = 2;
	redraw = false;
      } else {						// otherwise start new circle
	circleX = mx;
	circleY = my;
	circleCX = mx;
	circleCY = my;
	circleR = 2;
	circlestage = 1;
      }
      break;
    }
    associatedcurve = curve.inversePixels(circleX, circleY, circleCX, circleCY);
    if (redraw) { repaint(); }
    break;
    
  case 4:			// Pedal
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.pedalPixels(pointX, pointY);
    repaint();
    break;
    
  case 5:			// Negative pedal
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.negativePedalPixels(pointX, pointY);
    repaint();
    break;
    
  case 6:			// Caustic
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.causticPixels(pointX, pointY);
    repaint();
    break;
    
  case 7:			// Caustic (parallel lines)
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.causticPixels(pointX, pointY, new String("parallel"));
    repaint();
    break;
    
  }
  
  return true;
  
} /* end of mousedown method */
  
  
  // mousedrag method
  
public boolean mouseDrag(Event e, int mx, int my) {
  
  switch (associatedcurveindex) {
    
  case 0:			// "None"
    break;
    
  case 1:			// "Evolute"
    // note that this should be drawn from when it is chosen
    break;
    
  case 2:			// "Involute"
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.involutePixels(pointX, pointY);
    repaint();
    break;
    
  case 3:			// "Inverse"
    switch (circlestage) {
    case 0:		// no circle yet (this should never happen)
      circleX = mx;
      circleY = my;
      circleCX = mx;
      circleCY = my;
      circleR = 2;
      circlestage = 1;
      break;
    case 1:		// choosing radius
      double mR = Math.sqrt( (mx-circleX)*(mx-circleX) + (my-circleY)*(my-circleY) );	// mouse distance from centre
      circleCX = mx;
      circleCY = my;
      circleR = Math.max(2,(int)(mR));
      circlestage = 1;
      break;
    case 2:		// dragging circle
      circleX = mx;
      circleY = my;
      circleCX = mx + circleR;
      circleCY = my;
      circlestage = 2;
      break;
    }
    associatedcurve = curve.inversePixels(circleX, circleY, circleCX, circleCY);
    repaint();
    break;
    
  case 4:			// Pedal
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.pedalPixels(pointX, pointY);
    repaint();
    break;
    
  case 5:			// Negative pedal
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.negativePedalPixels(pointX, pointY);
    repaint();
    break;
    
  case 6:			// Caustic
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.causticPixels(pointX, pointY);
    repaint();
    break;
    
  case 7:			// Caustic (parallel lines)
    pointX = mx;
    pointY = my;
    pointstage = 1;
    associatedcurve = curve.causticPixels(pointX, pointY, new String("parallel"));
    repaint();
    break;
    
  }
  
  return true;
  
} /* end of mousedrag method */
  
  // paint method
  
public void paint(Graphics g) {
  
  if (!this.setaxis) {
    int sc;
    sc = (int)(size().height/(curve.yrange));
    Curve.xsc = sc;
    Curve.ysc = sc;
    Curve.Ox = (int)(-curve.xb*sc+(size().width-size().height)/2);
    //   Curve.Ox = (int)(size().width/2 + (curve.xb+curve.xt)/2*sc)
    Curve.Oy = (int)(+curve.yt*sc);
    Curve.xsize = size().width;
    Curve.ysize = size().height;
    this.curve.setCurve();
    this.curve.translate(0, 0);
    this.translate(0, 0);
    this.setaxis = true;
  }
  if (this.clear) {
    g.setColor(Color.white);
    g.fillRect(0, 0, size().width-1, size().height-1);
    this.clear = false;
  }
  
  g.setColor(Color.lightGray);
  //draw axis
  g.drawLine(Curve.Ox, 0, Curve.Ox, size().height);
  g.drawLine(0, Curve.Oy, size().width, Curve.Oy);
  
  g.setColor(Color.blue);
  //draw the main curve
  int acx1, acy1, acx2, acy2, acx0, acy0;
  int j = 0;
  for (int i=0; i<=curve.nop-steps; i+=steps) {
    acx1 = curve.fxpixels[i];
    acy1 = curve.fypixels[i];
    acx2 = curve.fxpixels[i+steps];
    acy2 = curve.fypixels[i+steps];
    // the next "if" checks to see at least one of the endpoints is on screen
    if ((0 < acx2 && acx2 < Curve.xsize && 0 < acy2 && acy2 < Curve.ysize) || (0 < acx1 && acx1 < Curve.xsize && 0 < acy1 && acy1 < Curve.ysize)) {
      // the next "if" checks to see the points aren't too far away
      if (Math.abs(acx1 - acx2) < size().height/2 && Math.abs(acy1 - acy2) < size().width/2) {
	g.drawLine(acx1, acy1, acx2, acy2);
      }
    }
    j = i;
  }
  if (j!=curve.nop-1) {
    j++;
    acx1 = curve.fxpixels[j];
    acy1 = curve.fypixels[j];
    acx2 = curve.fxpixels[curve.fxpixels.length-1];
    acy2 = curve.fypixels[curve.fxpixels.length-1];
    // the next "if" checks to see at least one of the endpoints is on screen
    if ((0 < acx2 && acx2 < Curve.xsize && 0 < acy2 && acy2 < Curve.ysize) || (0 < acx1 && acx1 < Curve.xsize && 0 < acy1 && acy1 < Curve.ysize)) {
      // the next "if" checks to see the points aren't too far away
      if (Math.abs(acx1 - acx2) < size().height/2 && Math.abs(acy1 - acy2) < size().width/2) {
	g.drawLine(acx1, acy1, acx2, acy2);
      }
    }
  }
  
  
  g.setColor(Color.green);
  //draw a point if appropriate
  if (pointstage > 0) {
    g.fillArc(pointX-2, pointY-2, 4, 4, 0, 360);
  }
  //draw circle if appropriate
  if (circlestage > 0) {
    g.fillArc(circleX-2, circleY-2, 4, 4, 0, 360);
    g.setColor(darkGreen);
    g.drawArc(circleX-circleR, circleY-circleR, 2*circleR, 2*circleR, 0, 360);
  }
  //draw a line if appropriate
  if (associatedcurveindex == 7 && pointstage>0) {
    g.setColor(darkGreen);
    if (pointX == Curve.Ox) {
      if (pointY == Curve.Oy) {
	g.drawLine(0, Curve.Oy, size().width, Curve.Oy);
      } else {
	g.drawLine(Curve.Ox, 0, Curve.Ox, size().height);
      }
    } else {
      int linepoints[][] = Curve.lineEnds(Curve.yPixelToPoint(pointY)/Curve.xPixelToPoint(pointX), 0.0);
      g.drawLine(linepoints[0][0], linepoints[1][0], linepoints[0][1], linepoints[1][1]);
    }
  }
  
  g.setColor(Color.red);
  //draw associated curve if appropriate
  if ( (associatedcurveindex>0 && pointstage+circlestage>0) || (associatedcurveindex==1) ) {
    for (int i=0; i<=curve.nop+2-steps; i+=steps) {
      acx1 = associatedcurve[0][i];
      acy1 = associatedcurve[1][i];
      acx2 = associatedcurve[0][i+steps];
      acy2 = associatedcurve[1][i+steps];
      // the next "if" checks to see at least one of the endpoints is on screen
      if ((0 < acx2 && acx2 < Curve.xsize && 0 < acy2 && acy2 < Curve.ysize) || (0 < acx1 && acx1 < Curve.xsize && 0 < acy1 && acy1 < Curve.ysize)) {
	// the next "if" checks to see the points aren't too far away
	if (Math.abs(acx1 - acx2) < size().height/2 && Math.abs(acy1 - acy2) < size().width/2) {
	  g.drawLine(acx1, acy1, acx2, acy2);
	}
      }
      j = i;
    }
    if (j!=curve.nop-1) {
      j++;
      acx1 = associatedcurve[0][j];
      acy1 = associatedcurve[1][j];
      acx2 = associatedcurve[0][associatedcurve[0].length-1];
      acy2 = associatedcurve[1][associatedcurve[1].length-1];
      // the next "if" checks to see at least one of the endpoints is on screen
      if ((0 < acx2 && acx2 < Curve.xsize && 0 < acy2 && acy2 < Curve.ysize) || (0 < acx1 && acx1 < Curve.xsize && 0 < acy1 && acy1 < Curve.ysize)) {
	// the next "if" checks to see the points aren't too far away
	if (Math.abs(acx1 - acx2) < size().height/2 && Math.abs(acy1 - acy2) < size().width/2) {
	  g.drawLine(acx1, acy1, acx2, acy2);
	}
      }
    }
  }
  
  g.setColor(darkGreen);
  // outline point or centre of circle if appropriate
  if (pointstage > 0 && associatedcurveindex != 7) {
    g.drawArc(pointX-2, pointY-2, 4, 4, 0, 360);
  }
  if (circlestage > 0) {
    g.drawArc(circleX-2, circleY-2, 4, 4, 0, 360);
  }

} /* end of paint method */

} /* end of CurvePanel class */