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

//  This code is distributed under the terms and conditions of the
//  CCP4 licence agreement as `Part i)' software.  See the conditions
//  in the CCP4 manual for a copyright statement.
//
//  The Xloggraph syntax cannot be implemented quite right due
//  to loss of carriage returns in the input parameters.
//  But it'll do for a proof of concept. by Kevin Cowtan
//
// This program uses the Applet class of the java.applet package which 
// contains the methods (subroutines)  getParameter (returns specified 
// applet parameters as a string) and init (called by the browser to 
// initialize the applet, used here, apart from others. 

public class JLogGraph extends Applet {
  JLogCanvas jlc; // jlc is the variable declared to be of type JLogCanvas
  TextArea jlt; // TextArea and Panel are awt components.
  Panel cards; // These are subclasses of the package java.awt.Component 
  String tabTitle;
  public String[] graphTitles; //declaring a string array 
  public String[] graphFmts;
  public String[] colTitles;
  public int[]    graphNCols; //declaring an integer array
  public int[][]  graphCols; 
  public float[][] data;
  public int ngraphs,ncols,nrows,ndata,currgr;
  Choice grChoice=new Choice(); //Choice is an awt component that provides 
//                                drop down lists from which choices can be 
//                                made.
  String wordise; int wordiseoff;

  public void init() {
    String[] delim={new String("$TAB"),new String("$GRA"),new String("$$"),
		    new String("$$"),new String("$$"),new String("$$")},
		     token=new String[delim.length+1], subtok, subsub;
//
// delim is a string array containing the arrays specified within qoutes.
// token is a string array whose length is determined by that of delim. 
// subtok and subsub are also declared as string arrays.
//
    StringBuffer tabletext; String word; 
//
// The strings created in quotes
// or read into objects of the String class (like delim,token etc)
// cannot be altered. The StringBuffer class allows alteration of the string. 
// tabletext is declared to be an object of StringBuffer class.
//
// read the loggraph
    String table=getParameter("table");
//
// uses the getParameter method to read and store the 'value' of the parameter 
// named 'table' as a string. The 'value' in our log tables includes the table 
// titles, graph titles, graph data columns and the table data.
// 
    for (int i=0; i<delim.length; i++) {
      token[i]=table.substring(0,table.indexOf(delim[i]));
      table=table.substring(table.indexOf(delim[i])+delim[i].length());
    }
//
// The substring method in the String class permits a range of specified 
// characters, of a string  to be copied into another string. You can either   
// specify a start character and a end character or just the start character
// in which case the rest of the string from the start character is copied.
// The indexOf method in the String class is used to find a specified character
// in a string. Here it is used to identify the characters specified by the 
// the elements of the delim string array. Once that is done, the string 
// 'table' is broken up into separate strings containing the table title, 
// graph titles, the column titles, and table data and stored as the array 
// elements of the string 'token'.
// 
    token[delim.length]=table; // Assigning the last element of the array
//
// read the table title
    subtok=tokenise(token[1],':');
//
// The tokenise method in the JLogGraph class, takes the string token[1] 
// breaks it up into a new string each time it encounters the delimiter
// ':' and returns a string array whose elements contain the new strings.
// 
    tabTitle=subtok[1]; // the first element of the string array subtok
//                         will contain the table title.
//
// read the grapth titles
    subtok=tokenise(token[2],':');
    ngraphs=(subtok.length-1)/4; 
// for each graph the delimiter ':' appears  4 times (see the log file)
//
    graphTitles=new String[ngraphs]; 
// instantiating the string object graphTitles whose size is ngraphs
//
    graphFmts  =new String[ngraphs];
    graphNCols =new int[ngraphs];
    graphCols =new int[ngraphs][];
//
// The following loop stores for each graph, the title, formats, the No. of 
// columns of data (in graphNCols), the column numbers of the data (in
// graphCols and adds the graph titles to the dropdown list
    int tok=1,ngraph=0;
    do {
      graphTitles[ngraph]=subtok[tok++].trim();
      graphFmts[ngraph]=subtok[tok++].trim();
      subsub=tokenise(subtok[tok++],',');
      graphNCols[ngraph]=subsub.length;
      graphCols[ngraph]=new int[graphNCols[ngraph]]; //instantiating graphCols
      for (int i=0;i<subsub.length;i++)
	graphCols[ngraph][i]=Integer.valueOf(subsub[i].trim()).intValue()-1;
      grChoice.addItem(graphTitles[ngraph]);
      tok++; ngraph++;
    } while (tok<subtok.length);
//
    grChoice.addItem("View table"); //Adds the last item to the drop down list 
//
// read the colum labels
    colTitles=wordise(token[3]); // token[3] contains the column titles
// wordise is a method in JLogGraph class that is similar to tokenise, one
// difference being, this does not have a separator passed as a parameter. The 
// separator is a blank space' '.
//
    ncols=colTitles.length-1;
//
// save the text label. Stores the column titles and contents of token[4]
// in the StringBuffer tabletext 
    tabletext=new StringBuffer(token[3]+"\n"+token[4]+"\n");
//
// get the data and count
    subtok=wordise(token[5]); // token[5] contains the table data. Since
// wordise takes ' ' as the separator, each data number has to be separated
// by a blank space.
    ndata=subtok.length-1;
    if (ndata%ncols!=0) System.out.println("Error: wrong number of data items");
//
    nrows=ndata/ncols;
// read the data
    data=new float[ncols][nrows];
    tok=0;
    for (int j=0;j<nrows;j++) {
      for (int i=0;i<ncols;i++) {
	word=subtok[tok++];
	tabletext.append(word); // appends each data number to tabletext
	try {
	  data[i][j]=Float.valueOf(word.trim()).floatValue();
// valueOf is a static method in available in datatype classes such as String
// Float etc. Being a static method it is called by referencing its class- in
// this case Float. The data numbers stored as strings are converted to 
// float value and sored in the 2 dimensional array data.
	} catch (NumberFormatException e) {}
// NumberFormatException is an object of the subclass RuntimeException-a 
// descendent of the base exception class Throwable. The catch statement 
// deals with the exception stated within barackets. 
      }
      tabletext.append("\n");
    }

// now make the panel
    jlt=new TextArea(tabletext.toString(),80,132);
//
// TextArea is a subclass the awt component TextComponent. Here jlt, (the
// name of the TextArea), is constructed using the specified rows and columns
// and the specified string. The string tabletext contains the column title
// and table data.
// 
    jlt.setEditable(false);
    jlt.setFont(new Font("Courier",Font.PLAIN,12));
//
    jlc=new JLogCanvas(this);
    jlc.setFont(new Font("Courier",Font.PLAIN,10));
//
// Panels and Canvases are classes in java.awt used for grouping components 
// which can be moved together in a window and are protected from overwriting 
// each other.
//
    cards=new Panel();cards.setLayout(new CardLayout());
//
// Creates an instance of Panel and stores a reference to it in the variable 
// cards. Then sets the layout of the new Panel object cards, to CardLayout
// which means that the components to be added using cards.add will be one
// on top of the other
//
    cards.add("canvas",jlc);
    cards.add("table",jlt);
//
    setLayout(new BorderLayout());
    add("Center",cards);
    add("South",grChoice);
// The layout for the applet is specified to be an object of the container
// BorderLayout, so that when a component is added, we specify which border 
// the component should stick to. In this case the panel cards should be in 
// center and grChoice which is the pull down list should be to the south.
  }
//
// METHOD (SUBROUTINE) TO SPLIT A 'SOURCE' STRING INTO SEPARATE STRINGS EACH
// TIME THE CHARACTER 'SEP' APPEARS IN THE SOURCE AND STORE THEM IN A STRING
// ARRAY 
// 
  String[] tokenise(String source, char sep) {
    int ntokens=0,i,j;
    for (i=0;i<source.length();i++)
      if (source.charAt(i)==sep) ntokens++;
    String[] tokens=new String[ntokens+1];
    ntokens=0; i=0;
    for (j=0;j<source.length();j++)
      if (source.charAt(j)==sep) {
	tokens[ntokens++]=source.substring(i,j);
	i=j+1;
      }
    tokens[ntokens]=source.substring(i);
    return tokens;
  }
//
// METHOD (SUBROUTINE) TO SPLIT A 'SOURCE' STRING INTO SEPARATE STRINGS EACH
// TIME A BLANK SPACE APPEARS IN THE SOURCE AND STORE THEM IN A STRING
//
  String[] wordise(String source) {
    int ntokens=0,i,j;
    for (j=1;j<source.length();j++)
      if (source.charAt(j-1)!=' '&&source.charAt(j)==' ') ntokens++;
    if (source.charAt(j-1)!=' ') ntokens++;
    String[] tokens=new String[ntokens+1];
    ntokens=i=0;
    for (j=1;j<source.length();j++)
      if (source.charAt(j-1)!=' '&&source.charAt(j)==' ') {
	tokens[ntokens++]=source.substring(i,j);
	i=j;
      }
    if (source.charAt(j-1)!=' ') tokens[ntokens++]=source.substring(i,j);
    return tokens;
  }
// ACTION EVENTS ARE GENERATED IN RESPONSE TO THE USER PERFORMING SOME ACTION
// WITH ONE OF THE USER INTERFACE COMPONENTS
  public boolean action(Event e, Object o) {
    if (e.target==grChoice) {
      currgr=grChoice.getSelectedIndex();
      if (currgr==ngraphs) {
	((CardLayout)cards.getLayout()).show(cards,"table");
      } else {
	((CardLayout)cards.getLayout()).show(cards,"canvas");
	jlc.repaint();
      }
    }
    return true;
  }
}

class JLogCanvas extends Canvas {
    JLogGraph parent;
    private int last_x, last_y;
    private float zoom_xmin, zoom_xmax, zoom_ymin, zoom_ymax;
    private int invalid=-99999;
    private int last_gr=-1;
    private boolean zoom,dragging;

// constructor
    public JLogCanvas(JLogGraph parent) {
	this.parent=parent;
    }
           
    public boolean mouseDrag(Event e, int x, int y) { 
	last_x = x; last_y = y;	 
	if (zoom) {
	    this.repaint();
	    return true;
	}

	if (!dragging) {
	    zoom_xmin=x; zoom_ymin=y;
	    dragging=true;
	}
	this.repaint();	   
	return true;	   
    }

    public boolean mouseUp(Event e, int x, int y) { 
	if (zoom) {
	    this.repaint();
	    return true;
	}
	if (dragging) {
	    zoom_xmax=x; zoom_ymax=y;
	    dragging=false;
	    zoom=true;
	} 
	last_x = x; last_y = y;	 
	this.repaint();	   
	return true;	   
    }

    public boolean mouseDown(Event e, int x, int y)  { 
	last_x = x; last_y = y;
	if (x<10 && y<10)
	    zoom=false;
	dragging=false;
	this.repaint();
	return true;
    }
 

    public void paint(Graphics g) {
	float xmin=99999,xmax=-99999,ymin=99999,ymax=-99999,x,y;
	int w=size().width,h=size().height,fw,fh;
	int wx0=2*w/10,wx=w/2,wy0=8*h/10,wy=-7*h/10;
	int[] lx=new int[parent.nrows],ly=new int[parent.nrows];
	Color[] cols={Color.black,Color.gray,Color.red,Color.green,Color.blue,Color.magenta,Color.orange,Color.pink,Color.darkGray,Color.lightGray,Color.yellow,Color.cyan};
// font information
	FontMetrics fontMetrics = g.getFontMetrics();
// clipping rectangles
	Rectangle oldclipbounds = g.getClipBounds();
	Rectangle clipbounds = new Rectangle(wx0,wy0+wy,wx+1,-wy+1);

	if (last_gr==-1)
	    last_gr=parent.currgr;

	if (last_gr!=parent.currgr) {
	    zoom=false;
	    last_gr=parent.currgr;
	}
// background
	g.setColor(Color.white);
	g.fillRect(0,0,w,h);
	g.setColor(Color.gray);
	g.draw3DRect(0,0,w-1,h-1,false);
// dragging rectangle
	g.setColor(Color.red);
	if (dragging)
	    g.draw3DRect((int)zoom_xmin,(int)zoom_ymin,
			 last_x-(int)zoom_xmin,last_y-(int)zoom_ymin,false);
// zoom reset
	if (zoom) {
	    g.fill3DRect(0,0,10,10,false);
	    fh=fontMetrics.getHeight();
	    g.drawString("Reset zoom",15,fh);
	}

	g.setColor(Color.black);
// x axis with ticks
	g.drawLine(wx0,wy0-wy/20,wx0+wx,wy0-wy/20);
	for (int i=0;i<=4;i++) { // ticks
	    g.drawLine(wx0+wx*i/4,wy0-wy/20,wx0+wx*i/4,wy0-wy/15);
	}

// y axis with ticks
	g.drawLine(wx0-wx/20,wy0,wx0-wx/20,wy0+wy);
	for (int i=0;i<=4;i++) { // ticks
	    g.drawLine(wx0-wx/20,wy0+i*wy/4,wx0-wx/15,wy0+i*wy/4);
	}
// get max and min x and y values
	for (int i=0; i<parent.nrows; i++) {
	    x=parent.data[parent.graphCols[parent.currgr][0]][i];
	    xmin=Math.min(xmin,x); xmax=Math.max(xmax,x);
	    for (int j=1; j<parent.graphNCols[parent.currgr]; j++) {
		y=parent.data[parent.graphCols[parent.currgr][j]][i];
		ymin=Math.min(ymin,y); ymax=Math.max(ymax,y);
	    }
	}
//
// get new values of xmin, ymin, xmax, ymax for zoom
if (zoom && zoom_xmin != zoom_xmax && zoom_ymin != zoom_ymax) {
		float tmin,tmax;
		float oxmin,oxmax,oymin,oymax;
// max and min of zoom area
		tmin=Math.min(zoom_xmin,zoom_xmax);
		tmax=Math.max(zoom_xmin,zoom_xmax);
		zoom_xmin=tmin;
		zoom_xmax=tmax;

		tmin=Math.min(zoom_ymin,zoom_ymax);
		tmax=Math.max(zoom_ymin,zoom_ymax);
		zoom_ymin=tmin;
		zoom_ymax=tmax;
// store old values
		oymin=ymin;
		oymax=ymax;
		oxmin=xmin;
		oxmax=xmax;
		
		xmin=(float)((oxmax-oxmin)*(zoom_xmin-wx0)/wx+oxmin);
		xmax=(float)((oxmax-oxmin)*(zoom_xmax-wx0)/wx+oxmin);

		ymax=(float)((oymax-oymin)*(zoom_ymin-wy0)/wy+oymin);
		ymin=(float)((oymax-oymin)*(zoom_ymax-wy0)/wy+oymin);
	} else {
	    zoom=false;
	}

	fh=fontMetrics.getHeight();

	g.setColor(Color.red);
	g.drawString("Mouse Position",wx0+wx+50,wy0-4*fh);
	    g.drawString("(click to update)",wx0+wx+50,wy0-3*fh);
	if(!zoom) {
	    g.drawString("(drag to zoom)",wx0+wx+50,wy0-2*fh);
        }
	g.setColor(Color.blue);
	g.drawString("x = " + String.valueOf((float)((xmax-xmin)*(last_x-wx0)/wx+xmin)),
		     wx0+wx+50,wy0-fh);
	g.drawString("y = " + String.valueOf((float)(ymax-ymin)*(last_y-wy0)/wy+ymin),
		     wx0+wx+50,wy0);
	g.setColor(Color.black);

	// X labels
	for (int i=0; i<=4; i++) {
	    g.drawString(String.valueOf((float)(xmin+((xmax-xmin)*i/4))),
			 wx0+wx*i/4,wy0-wy/15+fh);
	}

	// Y labels
	for (int i=0; i<=4; i++) {
	    fw=fontMetrics.stringWidth(String.valueOf((float)(ymin+(ymax-ymin)*i/4)));
	    g.drawString(String.valueOf((float)(ymin+(ymax-ymin)*i/4)),
			 wx0-wx/15-fw,wy0+wy*i/4+fh/3);
	}

	fw=fontMetrics.stringWidth(
				   parent.colTitles[parent.graphCols[parent.currgr][0]]);
	g.drawString(parent.colTitles[parent.graphCols[parent.currgr][0]],
		     wx0+(wx-fw)/2,wy0-wy/15+2*fh);

	for (int j=1; j<parent.graphNCols[parent.currgr]; j++) {
	    g.setColor(cols[j-1]);
	    g.drawString(parent.colTitles[parent.graphCols[parent.currgr][j]],
			 wx0+wx+fh,wy0+wy+j*fh);
	    for (int i=0; i<parent.nrows; i++) {
		x=parent.data[parent.graphCols[parent.currgr][0]][i];
		y=parent.data[parent.graphCols[parent.currgr][j]][i];
		lx[i]=(int)(wx0+wx*(x-xmin)/(xmax-xmin));
		ly[i]=(int)(wy0+wy*(y-ymin)/(ymax-ymin));
	    }
	    g.setClip(clipbounds);
	    for (int i=1; i<parent.nrows; i++) {
		    g.drawLine(lx[i-1],ly[i-1],lx[i],ly[i]);
	    }
	    g.setClip(oldclipbounds);
	}
    }

    public Dimension minimumSize()   {return new Dimension(200,150);}
    public Dimension preferredSize() {return new Dimension(800,600);}
}