//XYplot.java
//
// a scribbable plotting java applet
//
// by SHC HSTX 11/12/97
//
import java.applet.Applet;
import java.awt.*;
//import gjt.*;

public class XYplot extends java.applet.Applet
{
	int x, y; // bufferring for paint()
	int xp,yp; // bufferring for mouseDown and mouseDrag
	int height,width;
	Plot p,p2;
	FunctionPad fb;
	protected PlotCanvas plotCanvas,plotCanvas2;
	double xarr[][],yarr[][];

	public void init()
	{
		x=50;
		y=50;
		String att=getParameter("width");
		width = (att == null) ? 600 : Integer.valueOf(att).intValue();
		att=getParameter("height");
		height = (att == null) ? 600 : Integer.valueOf(att).intValue();

		xarr=new double[2][12];
		yarr=new double[2][12];
		for(int i=0;i<12;i++){
		    xarr[0][i]=(double)i;
		    yarr[0][i]=i*i*0.1;
		    xarr[1][i]= xarr[0][i];
		    yarr[1][i]=-yarr[0][i];
		}
		p=new Plot(width,height,"X","Y",0.,20.,-10.,10.,10,2,10,2);
		p.setTitle("This is a test plot");
		//plotCanvas=new PlotCanvas(this,p,width,height,xarr,yarr,2,12);
		plotCanvas=new PlotCanvas(this,p,width,height,xarr,yarr);
		fb=new FunctionPad(plotCanvas);
		setLayout(new BorderLayout());
		add("Center",plotCanvas);
		add("South",fb);
	}
    public void circle (Graphics c, int x0,int y0,int radius)
    {
	int x1,y1,x2,y2;
	double theta,dtheta; 

	theta=0.0;
	dtheta=2.0*Math.PI/36.;
	x1=radius+x0;
	y1=y0;
	for(int i=1;i<=36;i++){
		theta+=dtheta;
		x2=(int) (radius*Math.cos(theta)+x0);
		y2=(int) (radius*Math.sin(theta)+y0);
		c.drawLine(x1,y1,x2,y2);
		x1=x2;
		y1=y2;
	}
    }

    public void box (Graphics c, int x0,int y0,int height,int width)
    {
	int x2,y2;
	x2=x0+width;
	y2=y0+height;
	c.drawLine(x0,y0,x2,y0);
	c.drawLine(x2,y0,x2,y2);
	c.drawLine(x2,y2,x0,y2);
	c.drawLine(x0,y2,x0,y0);

    }
}
//-----------------------------------------------------------------
//
// class PlotCanvas()
//
//-----------------------------------------------------------------
class PlotCanvas extends Canvas 
{
    XYplot xyplot;
    Plot p;
    double xarr[],yarr[];
    double xarr2[][],yarr2[][];
    int height,width;
    int x,y;
    int xp,yp;
    int sets=1,npts;

    public PlotCanvas(XYplot xyplot,Plot p,int width,int height,
			double xarr[],double yarr[],int sets,int npts)
    {
	this.xyplot=xyplot;
	this.p=p;
	this.width=width;
	this.height=height;
	this.xarr=xarr;
	this.yarr=yarr;
	this.sets=sets;
	this.npts=npts;
	this.x=50;
	this.y=50;
    }
    public PlotCanvas(XYplot xyplot,Plot p,int width,int height,
			double xarr[],double yarr[],int npts)
    {
	this.xyplot=xyplot;
	this.p=p;
	this.width=width;
	this.height=height;
	this.xarr=xarr;
	this.yarr=yarr;
	this.npts=npts;
	this.x=50;
	this.y=50;
    }
    public PlotCanvas(XYplot xyplot,Plot p,int width,int height,
			double xarr2[][],double yarr2[][])
    {
	this.xyplot=xyplot;
	this.p=p;
	this.width=width;
	this.height=height;
	this.xarr2=xarr2;
	this.yarr2=yarr2;
	this.sets=0;
	this.npts=0;
	this.x=50;
	this.y=50;
    }
    public void paint(Graphics g) 
    {
	int start=0;
	int stop=npts-1;
    	p.paint(g);
	if(npts != 0 && sets != 0){
	    for(int i=0;i<sets;i++){ 
		p.draw(g,xarr,yarr,start,stop);
		start=start+npts;
		stop=start+npts-1;
	    }
	} 
	else if(npts == 0 && sets == 0){
		p.draw(g,xarr2,yarr2);
	}

    	p.draw(g,"Look!",10.,0.);
    	this.xyplot.box(g,x+100,y+100,height/4,width/4);
	this.xyplot.circle(g,x+100,y+100,100);
    }
    public boolean mouseDown(Event e,int x,int y)
    {
	    this.xp=x;
	    this.yp=y;
	    return true;
    }
    public boolean mouseDrag (Event e, int x,int y)
    {
	    Graphics g=getGraphics();
	    g.setColor(Color.red);
	    g.drawLine(this.xp,this.yp,x,y);
	    this.xp=x;
	    this.yp=y;
	    g.dispose();
	    return true;
    }
}
//-----------------------------------------------------------------
//
// class FunctionPad()
//
//-----------------------------------------------------------------
class FunctionPad extends XYplot 
{
    Button redraw;
    PlotCanvas plotCanvas;

    public FunctionPad(PlotCanvas plotCanvas)
    {
	this.plotCanvas=plotCanvas;
	redraw=new Button("Redraw");
	//redraw.setForeground(Color.black);
	//redraw.setBackground(Color.lightGray);
	setLayout(new GridLayout(1,1));
	this.add(redraw);
    }

    public boolean action(Event ev, Object ob)
    {
	if(ev.target == redraw){
	try
	{
	    Graphics g=plotCanvas.getGraphics();
	    plotCanvas.paint(g);
	    g.dispose();
	    return true;
	}
	catch(ClassCastException e)
	{
	    return false;
	}
	}
	else return super.action(ev,ob);
    }

}
//-----------------------------------------------------------------
//
// class Plot()
//
//-----------------------------------------------------------------
class Plot extends Canvas 
{
    String title;
    Axis xa,ya,xb,yb;
    int xp,yp,xpos,ypos,xtitle,ytitle;
    int xmajor_ticks,xminor_ticks,ymajor_ticks,yminor_ticks;
    int width,height,xlength,ylength;
    double xmin,xmax,ymin,ymax;
    double xratio,yratio;
    //
    // private methods
    //
    void init()
    {
	title=" ";
	xpos=(int)(width*0.15);
	ypos=height-(int)(height*0.15);
	xlength=(int)(width*0.8);
	ylength=(int)(height*0.8);
	xtitle=(int)((xpos+xlength)*0.5);
	ytitle=(int)((ypos-ylength)*0.5);
	xa=new Axis(xmin,xmax,xmajor_ticks,xminor_ticks);
	ya=new Axis(ymin,ymax,ymajor_ticks,yminor_ticks);
	xb=new Axis(xmin,xmax,xmajor_ticks,xminor_ticks);
	yb=new Axis(ymin,ymax,ymajor_ticks,yminor_ticks);
	xratio=xlength/(xmax-xmin);
	yratio=-ylength/(ymax-ymin);
    }
    // 
    // looking for maxima and minima of x[] and y[]
    //
    void MaxMin(double x[],double y[],int n)
    {
	xmin=x[0];
	xmax=x[0];
	ymin=y[0];
	ymax=y[0];
	for(int i=1;i<n;i++){

	    if(x[i]>xmax) xmax=x[i];
	    else if(x[i]<xmin) xmin=x[i];

	    if(y[i]>ymax) ymax=y[i];
	    else if(y[i]<ymin) ymin=y[i];
  	}
    }
    //
    // Constructors 
    //
    Plot(double x[],double y[],int n,int width,int height)
    {
	this.width=width;
	this.height=height;
	MaxMin(x,y,n);
	setTicks();
        init();
	xb.setLabels();
    	xb.setTitle("X");
	ya.setLabels();
    	ya.setTitle("Y");
    }
    Plot(double x[],double y[],int n,int width,int height,
	String sx,String sy)
    {
	this.width=width;
	this.height=height;
	MaxMin(x,y,n);
	setTicks();
        init();
	xb.setLabels();
    	xb.setTitle(sx);
	ya.setLabels();
    	ya.setTitle(sy);
    }
    Plot(int width,int height, String sx,String sy,
	double xmin,double xmax,double ymin,double ymax,
	int xmajor_ticks,int xminor_ticks,int ymajor_ticks,int yminor_ticks)
    {
	this.width=width;
	this.height=height;
	this.xmin=xmin;
	this.xmax=xmax;
	this.ymin=ymin;
	this.ymax=ymax;
	setTicks(xmajor_ticks,xminor_ticks,ymajor_ticks,yminor_ticks);
        init();
	xb.setLabels();
    	xb.setTitle(sx);
	ya.setLabels();
    	ya.setTitle(sy);
    }
    //
    // public methods
    //
    public void setTicks()
    {
	this.xmajor_ticks=10;
	this.xminor_ticks=2;
	this.ymajor_ticks=10;
	this.yminor_ticks=2;
    }
    public void setTicks(int xmajor_ticks,int xminor_ticks,
			 int ymajor_ticks,int yminor_ticks)
    {
	this.xmajor_ticks=xmajor_ticks;	
	this.xminor_ticks=xminor_ticks;	
	this.ymajor_ticks=ymajor_ticks;	
	this.yminor_ticks=yminor_ticks;	
    }
    public void setTitle(String title)
    {
	this.title=title.toUpperCase();
	xtitle-=title.length()*3;
    }
    public void paint(Graphics g)
    {
	g.setColor(Color.white);
	g.fillRect(0,0,width,height);
	g.setColor(Color.black);
	xa.draw(g,1,xpos,ypos-ylength,xlength);
	ya.draw(g,2,xpos,ypos,-ylength);
	xb.draw(g,-1,xpos,ypos,xlength);
	yb.draw(g,-2,xpos+xlength,ypos,-ylength);
	g.drawString(title,xtitle,ytitle);
    }
    public void paint(Graphics g,double xarr[],double yarr[],int n)
    {
	this.paint(g);
	this.draw(g,xarr,yarr,n);
    }
    public void draw(Graphics g,double x[],double y[],int n)
    {
	int x1,y1,x2,y2;

	x1=(int)((x[0]-xmin)*xratio)+xpos;
	y1=(int)((y[0]-ymin)*yratio)+ypos;
	for(int i=1;i<n;i++) {
		x2=(int)((x[i]-xmin)*xratio)+xpos;
		y2=(int)((y[i]-ymin)*yratio)+ypos;
		g.drawLine(x1,y1,x2,y2);
		x1=x2;
		y1=y2;
	}
    }
    public void draw(Graphics g,String legend,double x,double y)
    {
	int x0,y0;
	x0=(int)((x-xmin)*xratio)+xpos;
	y0=(int)((y-ymin)*yratio)+ypos;
	g.drawString(legend,x0,y0);
    }
    public void draw(Graphics g,double x[],double y[],int start,int stop)
    {
	int x1,y1,x2,y2;

	x1=(int)((x[start]-xmin)*xratio)+xpos;
	y1=(int)((y[start]-ymin)*yratio)+ypos;
	for(int i=start+1;i<=stop;i++) {
		x2=(int)((x[i]-xmin)*xratio)+xpos;
		y2=(int)((y[i]-ymin)*yratio)+ypos;
		g.drawLine(x1,y1,x2,y2);
		x1=x2;
		y1=y2;
	}
    }
    public void draw(Graphics g,double x[],double y[])
    {
	int x1,y1,x2,y2;

	int npts=Math.min(x.length,y.length);
	x1=(int)((x[0]-xmin)*xratio)+xpos;
	y1=(int)((y[0]-ymin)*yratio)+ypos;
	for(int i=1;i<npts;i++) {
		x2=(int)((x[i]-xmin)*xratio)+xpos;
		y2=(int)((y[i]-ymin)*yratio)+ypos;
		g.drawLine(x1,y1,x2,y2);
		x1=x2;
		y1=y2;
	}
    }
    public void draw(Graphics g,double x[][],double y[][])
    {
	int x1,y1,x2,y2,npts;

	int sets=Math.min(x.length,y.length);
	for(int j=0;j<sets;j++){
	    x1=(int)((x[j][0]-xmin)*xratio)+xpos;
	    y1=(int)((y[j][0]-ymin)*yratio)+ypos;
	    npts=Math.min(x[j].length,y[j].length);
	    for(int i=1;i<npts;i++) {
		x2=(int)((x[j][i]-xmin)*xratio)+xpos;
		y2=(int)((y[j][i]-ymin)*yratio)+ypos;
		g.drawLine(x1,y1,x2,y2);
		x1=x2;
		y1=y2;
	    }
	}
    }
}
//-----------------------------------------------------------------
//
// class Axis()
//
//-----------------------------------------------------------------
class Axis
{
    int major_ticks;
    int minor_ticks;
    double max;
    double min; 
    String title;
    String labels[];
    // 
    // private methods
    //
    void drawTicks(Graphics g,int type,int x0,int y0,int length)
    {
	int major_tick_length;
	int minor_tick_length;
	double dx,dy,dx_minor,dy_minor;
	int x,y,x1,y1,x_minor,y_minor,x1_minor,y1_minor,shift,gap;

	major_tick_length=(int)(0.02*Math.abs(length));
	minor_tick_length=(int)(0.5*major_tick_length);
	gap=(int) (0.05*Math.abs(length));

	if(type < 0){ 
	    major_tick_length=-major_tick_length;
	    minor_tick_length=-minor_tick_length;
	    gap=-gap;
	}

	if(type == 0){ // draw a box without ticks
	    x1=x0+length;
	    y1=y0+length;
	    g.drawLine(x0,y0,x1,y0);
	    g.drawLine(x1,y0,x1,y1);
	    g.drawLine(x1,y1,x0,y1);
	    g.drawLine(x0,y1,x0,y0);
	}
	else if(Math.abs(type) == 8){ // draw a horizontal line 
	    x1=x0+length;
	    g.drawLine(x0,y0,x1,y0);
	    x=(length+20)/2-title.length()*2;
	    g.drawString(title,x,y0-2*gap);
	}
	else if(Math.abs(type) == 9){ // draw a vertical line 
	    y1=y0+length;
	    g.drawLine(x0,y0,x0,y1);
	    y=(length+20)/2-title.length()*2;
	    g.drawString(title,x0-2*gap,y);
	}
	else if(Math.abs(type) == 1){ // draw a horizontal axis 
	    x1=x0+length;
	    g.drawLine(x0,y0,x1,y0);
	    x=x0;
	    dx=length/major_ticks;
	    y=y0;
	    y1=y0+major_tick_length;
	    dx_minor=dx/minor_ticks;
	    y_minor=y0;
	    y1_minor=y0+minor_tick_length;
	    //
	    // draw major ticks
	    //
	    for(int i=0;i<major_ticks;i++){
		g.drawLine(x,y,x,y1);
		// label under each tick
	        g.drawString(labels[i],x-labels[i].length()*3,y-gap); 
		//
		// draw minor ticks
		//
		x_minor=x;
	        for(int j=1;j<minor_ticks;j++){
		    x_minor+=(int)dx_minor;
		    g.drawLine(x_minor,y_minor,x_minor,y1_minor);
		}
		x+=(int)dx;
	    }
	    g.drawLine(x,y,x,y1);
		// label under the tick
	    g.drawString(labels[major_ticks],
		x-labels[major_ticks].length()*3,y-gap); 
	    // 
	    // title
            //
	    if(length > 0) x=(length+x0-title.length())/2;
	    else x=(length)/2+x0-title.length();
	    g.drawString(title,x,y-2*gap);
	}
	else if(Math.abs(type) == 2){ // draw a vertical axis
	    y1=y0+length;
	    g.drawLine(x0,y0,x0,y1);
	    x=x0;
	    x1=x0+major_tick_length;
	    y=y0;
	    dy=length/major_ticks;
	    x_minor=x0;
	    x1_minor=x0+minor_tick_length;
	    dy_minor=dy/minor_ticks;
	    //
	    // draw major ticks
	    //
	    for(int i=0;i<major_ticks;i++){
	        g.drawLine(x,y,x1,y);
			// label under the tick
	        g.drawString(labels[i],x-gap-labels[i].length()*3,y+5); 
		//
		// draw minor ticks
		//
		y_minor=y;
	        for(int j=1;j<minor_ticks;j++){
		    y_minor+=(int)dy_minor;
	    	    g.drawLine(x_minor,y_minor,x1_minor,y_minor);
		}
		y+=(int)dy;
	    }
	    g.drawLine(x,y,x1,y);
		// label under the tick
	    g.drawString(labels[major_ticks],
		x-gap-labels[major_ticks].length()*3,y+5); 
	    // 
	    // title
            //
	    if(length > 0) y=(y0+length)/2-title.length();
	    else y=(length)/2+y0-title.length();
	    g.drawString(title,x-3*gap,y);
	}
    }
    //
    // Constructors
    //
    public Axis()
    {
	min=0.0;
	max=1.0;
	major_ticks=1;
	minor_ticks=1;
	title=" ";
	labels=new String[major_ticks+1];
	for(int i=0;i<=major_ticks;i++) labels[i]=" ";
    }

    public Axis(double ex_min,double ex_max)
    {
	min=ex_min;
	max=ex_max;
	major_ticks=1;
	minor_ticks=1;
	title=" ";
	labels=new String[major_ticks+1];
	for(int i=0;i<=major_ticks;i++) labels[i]=" ";
    }

    public Axis(double ex_min,double ex_max,
		int ex_major_ticks,int ex_minor_ticks)
    {
	min=ex_min;
	max=ex_max;
	major_ticks=ex_major_ticks;
	if(major_ticks <= 0) major_ticks=1;
	minor_ticks=ex_minor_ticks;
	if(minor_ticks <= 0) minor_ticks=1;
	title=" ";
	labels=new String[major_ticks+1];
	for(int i=0;i<=major_ticks;i++) labels[i]=" ";
    }

    public Axis(Axis ex_axis)
    {
	int ex_major_ticks=0,ex_minor_ticks=0;
	double ex_min=0.0,ex_max=0.0;

	ex_axis.getParameters(ex_min,ex_max,ex_major_ticks,ex_minor_ticks);
	min=ex_min;
	max=ex_max;
	major_ticks=ex_major_ticks;
	minor_ticks=ex_minor_ticks;
	title=" ";
	labels=new String[major_ticks+1];
	for(int i=0;i<=major_ticks;i++) labels[i]=" ";
    }
    //
    // public methods
    // 
    public void draw(Graphics g,int type,int x0,int y0,int length)
    {
	drawTicks(g,type,x0,y0,length);
    }
    public void setLabels()
    {
	double buf;

	labels[0]=String.valueOf(min);
	buf=(max-min)/major_ticks;
	for(int i=1;i<=major_ticks;i++){
	    labels[i]=String.valueOf(buf*i+min);
	}
    }
    public void setTitle(String title)
    {
	this.title=title;
    }
    public void getParameters(double ex_min,double ex_max,
	int ex_major_ticks,int ex_minor_ticks)
    {
	ex_min=min;
	ex_max=max;
	ex_major_ticks=major_ticks;
	ex_minor_ticks=minor_ticks;
    }
}