import java.awt.*;
import java.awt.event.MouseEvent;
import java.util.*;
import java.io.*;
import java.lang.*;
import java.text.*;
public class graphWindow extends Frame{

    OutputWindow Caller;
    Button OKButton;
    Label blank1;
    graph2D graph;

    graphWindow(){}
    graphWindow(String title, OutputWindow Caller){
        super(title);
        this.Caller = Caller;
        DoLayout();
        graph.requestFocus();
    }
/*
    public synchronized void reshape(int x, int y, int w, int h)
    {
        super.reshape(x, y, w, h);
        paint(super.getGraphics());
        repaint();
    }
*/
    public final void DoLayout(){
        addNotify();
        resize(500,400);
//        Event e = new Event(this, Event.WINDOW_DEICONIFY, 
//                    new Object());
//        postEvent(e);
        
        graph = new graph2D(this);
        OKButton = new Button("OK");
        blank1 = new Label("",Label.LEFT);

        OKButton.setFont(new Font ("Arial", Font.PLAIN, 12));
        OKButton.setBackground(Color.lightGray);
        OKButton.setForeground(Color.black);
        this.setBackground(Color.blue.brighter());
        this.setForeground(Color.black);

        GridBagLayout gridbag = new GridBagLayout();
        GridBagConstraints constraints = new GridBagConstraints();
        setLayout(gridbag);

        //Row 1
        buildConstraints(constraints, 0, 0, 1, 1, 100, 90);
        constraints.fill = GridBagConstraints.BOTH;
        constraints.anchor = GridBagConstraints.CENTER;
        gridbag.setConstraints(graph, constraints);
        add(graph);
/*
        //Row 2
        buildConstraints(constraints, 0, 1, 1, 1, 100, 10);
        constraints.fill = GridBagConstraints.NONE;
        constraints.anchor = GridBagConstraints.CENTER;
        constraints.ipadx = 40;
        gridbag.setConstraints(OKButton, constraints);
        add(OKButton);
*/
        show(); validate();
    }
    public synchronized void update(Graphics g)
    {
        graph.repaint();
        paint(g);
    }
    public void buildConstraints(GridBagConstraints gbc, int gx, int gy,
                                 int gw, int gh, int wx, int wy){
        gbc.gridx = gx;
        gbc.gridy = gy;
        gbc.gridwidth = gw;
        gbc.gridheight = gh;
        gbc.weightx = wx;
        gbc.weighty = wy;
    }
    public Insets insets(){
          return new Insets(30, 10, 32, 10);
//        return new Insets(38, 18, 40, 18); //Without button
//        return new Insets(38, 18, 25, 18);   //With button

    }
    public boolean action(Event e, Object arg){
        Object theSource; String label=null;

        theSource = e.target;
        if(theSource instanceof Button){
            label = ((Button)theSource).getLabel();
            if(label == "OK"){
                hide();
                //dispose();
                validate();
                return(true);
            }
        }
        return(false);
    }
    // Make sure that pressing on a button is handled in 
    // the same way as clicking on it (action event).
    public boolean keyDown(Event e, int key){
        Object theSource;
        theSource = e.target;
        if(key == Event.ENTER){
            if(theSource instanceof Button ){
                //Create an "ACTION_EVENT" associated with any
                //button (target=(Button)theSource) and post it here 
                //for processing.
                e = new Event((Button)theSource, Event.ACTION_EVENT, 
                    ((Button)theSource).getLabel());                
                //this.postEvent(e);
                postEvent(e);
                return(true);            
            }
        }
        return(false);
    }
    public boolean handleEvent(Event e){
        Object theSource; int id;
        theSource = e.target;

        id = e.id;
        switch(id){
        case(Event.WINDOW_DESTROY):
            hide();
            return(true);
        default:
            return super.handleEvent(e);
        } 
    }
}
class graph2D extends Panel{
    private static final double zero=0.0e0;
    private static final double  one=1.0e0;
    graphWindow Caller;
    private OutputWindow output;
    private int Degree;
    private double x[][];
    private double y[];
    private double Y[], z[];
    private double rms, Rsquared, correlation;
    private int nx, Ncards, Nparms, Imethod;
    private boolean Constant;
    private double scale=0.1e0;
    private int Umin, Umax, Vmin, Vmax;
    private int    UMIN, UMAX, VMIN, VMAX;
    private double XMIN, XMAX, YMIN, YMAX;
    private int w, h, Npoints=100, NaxisDiv=5;
    private double T[][], V[][], Mwv[][], Sx, Sy, Ou[], Ox[];
    private double X[][], Px[], Py[], P[][];
    private int Xtic[], Ytic[];
    private int Iv[];
    private Util util;
    private graphUtil gutil;
    private function2D function;
    private NumFormat nf;
    private String XexpoStr, YexpoStr, Xstr[], Ystr[];

    graph2D(){}
    graph2D(graphWindow Caller){
        this.Caller = Caller;
        this.output = Caller.Caller;
        init();
    }
    public void init()
    {
        gutil = new graphUtil();
        util = new Util();
        nf = new NumFormat();
        T = new double[3][3]; V = new double[3][3]; 
        Ou = new double[2]; Ox = new double[2];
        setBackground(Color.white);
        setForeground(Color.black);
        //Retrieve info associated with the "calling" output window.
        Imethod = output.getMethod();
        Degree = output.getDegree();
        Constant = output.isConstant();
        rms = output.getRMS();
        Rsquared = output.getRsquared();
        correlation = output.getCorrelation();
        Ncards = output.getN();
        nx = output.getNx();
        x = new double[Ncards][nx];
        y = new double[Ncards];
//      Y = new double[Ncards];
        x = output.GetX(); y = output.GetY();
        getWorldlimits();
        Xstr = new String[NaxisDiv]; Ystr = new String[NaxisDiv];
        getAxisValues();
//      Y = output.getYY();
        Nparms = output.getNparms();
        z = new double[Nparms];
        z = output.getParameters();
        X  = new double[Ncards][3]; P = new double[Npoints][3];
        function = new function2D(Npoints, Imethod, Degree, 
                                  Constant, z, XMIN, XMAX);
        Px = function.GetX(); Py = function.GetY();
        Xtic = new int[NaxisDiv]; Ytic = new int[NaxisDiv];
//        gutil.setClipFactor(0.95e0);
        gutil.setClipFactor(one);

    }
    public synchronized void paint(Graphics g)
    {
        w = this.size().width; h = this.size().height;
        gutil.ViewportWindowBounds(w, h, scale, scale, scale, scale);
        gutil.DrawFrame(g, false);
        Iv = new int[4];
        Iv = gutil.get2DWindowLimits();
        UMIN = Iv[0]; UMAX = Iv[1]; VMIN = Iv[2]; VMAX = Iv[3];
        Mwv = getMwv();
        putTicMarks(g);
        g.setFont(new Font ("Courier", Font.PLAIN, 11));
        putAxisValues(g);
        putLegends(g);
        gutil.setClipRectangle(g);
        g.setColor(Color.blue);
        drawOutputFunction(g);
        g.setColor(Color.red);
        drawInputPoints(g);
    }
    public void drawInputPoints(Graphics g)
    {
        int W=3;
        for(int i=0; i<Ncards; i++){
            X[i][0] = x[i][0]; X[i][1] = y[i]; X[i][2] = one;
        }
        gutil.TransformCoord2D(Ncards, X, Mwv);
        for(int i=0; i<Ncards; i++){
            g.fillOval((int)X[i][0]-W/2, (int)X[i][1]-W/2, W, W);
        }
    }
    public void drawOutputFunction(Graphics g){
        for(int i=0; i<Npoints; i++){
            P[i][0] = Px[i]; P[i][1] = Py[i]; P[i][2] = one;
        }
        gutil.TransformCoord2D(Npoints, P, Mwv);
        //Just draw a unique line with the endpoints for a linear
        //function.
        if(Degree == 1){
            g.drawLine( (int)P[0][0], (int)P[0][1], 
                        (int)P[Npoints-1][0], (int)P[Npoints-1][1]);
            return;
        }
        for(int i=0; i<Npoints-1; i++){
            g.drawLine((int)P[i][0],   (int)P[i][1], 
                       (int)P[i+1][0], (int)P[i+1][1]);
        }
        return;
    }
    //Construct the world-window to viewport transformation.    
    public double[][] getMwv()
    {
        Ou[0] = UMIN; Ou[1] = VMAX;
        Ox[0] = XMIN; Ox[1] = YMIN;
        gutil.Translate2D(T, Ox, '-');
        Sx = (double)(UMAX - UMIN) / (XMAX - XMIN);
        Sy = (double)(VMIN - VMAX) / (YMAX - YMIN);
        gutil.Scale2D(V, Sx, Sy);
        util.Matprod1(V, T, 3);
        gutil.Translate2D(T, Ou, '+');
        util.Matprod1(T, V, 3);
        return(T);
    }
    public void getWorldlimits()
    {
        double Scale = 0.15e0, deltax, deltay;
        double Vx[] = new double[Ncards]; 
        double Vy[] = new double[Ncards];

        for(int i=0; i<Ncards; i++){Vx[i] = x[i][0]; Vy[i] = y[i];}
        util.sortAscending(Ncards, Vx);
        util.sortAscending(Ncards, Vy);
        deltax = Vx[Ncards-1] - Vx[0];
        deltay = Vy[Ncards-1] - Vy[0];
        //This allows the window to contain all input points.
	  XMIN = Vx[0] - Scale*deltax; 
        XMAX = Vx[Ncards-1] + Scale*deltax;
        YMIN = Vy[0] - Scale*deltay; 
        YMAX = Vy[Ncards-1] + Scale*deltay;
    }
    public void putAxisValues(Graphics g)
    {
        int Len;
                         //X axis
        for(int i=0; i<NaxisDiv; i++){
            g.drawString(Xstr[i], Xtic[i]-15, VMAX+20);
        }
        g.drawString(XexpoStr, UMAX+50, VMAX+20);
                         //Left Y axis
        for(int i=0; i<NaxisDiv; i++){
            Len = Ystr[i].length();
            //This allows the values to be right-justified.
            g.drawString(Ystr[i], UMIN-10*Len, Ytic[i]+5);
        }
        Len = YexpoStr.length();
        g.drawString(YexpoStr, UMIN-10*Len-5, VMIN-20);
/*
                         //Right Y axis
        for(int i=0; i<NaxisDiv; i++){
            //The values will be left-justified.
            g.drawString(Ystr[i], UMAX+15, Ytic[i]+5);
        }
        g.drawString(YexpoStr, UMAX+15, VMIN-20);
*/
    }
    public void putLegends(Graphics g)
    {
        double slope, intercept;
        String str, strIntercept=null, strSlope=null, strCorr=null,
               minusSign=" - ", plusSign=" + ", theSign;

        nf.setForceRightPadding(false);
        if(Degree == 1){
            //Write equation for function of degree 1.
            if(Constant){
                if(Imethod == 0){
                    slope = z[1];
                    intercept = z[0];
                }else{
                    slope = z[0];
                    intercept = z[1];
                }
                nf.setFieldLength(0);
                nf.setFractionDigits(6);
                strSlope = nf.format(slope);
                str = nf.format(intercept);
                strIntercept = nf.stripSign(str);
                if(intercept < zero){
                    theSign = minusSign;
                }else{
                    theSign = plusSign;
                }
                g.drawString("Y = " +strSlope +"X" +theSign +strIntercept,
                             UMIN+10, VMIN-10);
            }else{
                //Just write equation of function of degree 1 
                //with no constant.
                nf.setFieldLength(0);
                nf.setFractionDigits(6);
                strSlope = nf.format(z[0]);
                g.drawString("Y = " +strSlope +"X",
                             UMIN+10, VMIN-10);
            }
        }
        nf.setFieldLength(11); nf.setFractionDigits(6);
        int shift = (VMIN + VMAX) / 4; shift -= 30;
        if(Degree == 1 && Constant){
            //Write computed correlation coefficient.
            strCorr = nf.format(correlation);
            g.drawString("Correlation", UMAX +10, VMIN + shift);
            g.drawString("coefficient:", UMAX +10,VMIN + shift+15);
            g.drawString(strCorr, UMAX+10, VMIN + shift +30);
        }else{
            //Write computed R-squared.
            strCorr = nf.format(Rsquared);
            g.drawString("  R-squared:", UMAX +10,VMIN + shift+15);
            g.drawString(strCorr, UMAX+10, VMIN + shift +30);
        }              
    }
    public void putTicMarks(Graphics g)
    {
        getTicCoordinates();
        for(int i=0; i<NaxisDiv; i++){   //X axis
            g.drawLine(Xtic[i], VMAX+5, Xtic[i], VMAX);
        }
        for(int i=0; i<NaxisDiv; i++){   //Left Y axis 
            g.drawLine(UMIN-5, Ytic[i], UMIN, Ytic[i]);
        }
/*
        for(int i=0; i<NaxisDiv; i++){   //Right Y axis
            g.drawLine(UMAX, Ytic[i], UMAX+5, Ytic[i]);
        }
*/
    }
    public void getTicCoordinates()
    {
        int i, j; int dx, dy;

        dx = (int)( (double)(UMAX - UMIN) / (NaxisDiv - 1) );
        dy = (int)( (double)(VMAX - VMIN) / (NaxisDiv - 1) );
        //Impose the values at the end of the axis, which we
        //know to be exact.
        Xtic[NaxisDiv - 1] = UMAX; Ytic[NaxisDiv-1] = VMIN;
        //Now do the rest.
        for(i=0; i<NaxisDiv-1; i++){
            Xtic[i] = UMIN + i*dx;
            Ytic[i] = VMAX - i*dy;
        }
    }
    public void getAxisValues()
    {
        int i, j; double dx, dy; String Expo="E";

        dx = (XMAX - XMIN) / (NaxisDiv-1);
        dy = (YMAX - YMIN) / (NaxisDiv-1);
        double x[] = new double[NaxisDiv];
        double y[] = new double[NaxisDiv];
        double Xaxe[] = new double[NaxisDiv];
        double Yaxe[] = new double[NaxisDiv];
        for(i=0; i<NaxisDiv; i++){
            x[i] = XMIN + i*dx;
            y[i] = YMIN + i*dy;
        }
        int Xexpo = scaleAxisValues(NaxisDiv, x, Xaxe, 1);
        int Yexpo = scaleAxisValues(NaxisDiv, y, Yaxe, 1);
        nf.setFieldLength(0);
        nf.setForceRightPadding(true);
        nf.setFractionDigits(2);
        nf.setIntegerDigits(1);

        for(i=0; i<NaxisDiv; i++){
            Xstr[i] = nf.format(Xaxe[i]);
            Ystr[i] = nf.format(Yaxe[i]);
        }
        if(Xexpo == 0){
            XexpoStr = "";
        }else{
            XexpoStr = Expo.concat(nf.format(Xexpo));
        }
        if(Yexpo == 0){
            YexpoStr = "";
        }else{
            YexpoStr = Expo.concat(nf.format(Yexpo));
        }
    }
    public int scaleAxisValues(int n, double x[], double numbers[], 
                     int max_power_10)
    {
        double max, log_max, fact;
        int i, power_10_max;

        max = zero;
        for(i=0;i<n;i++){
            if(Math.abs(x[i]) > max){
	          max=Math.abs(x[i]);
            }
        }
        power_10_max=util.Ilog10(max);
/*      we want the graduations to run to a maximum of 10E(max_power_10),
        in units of power_10_max */
        if( Math.pow(10.0,(double)power_10_max) - max == zero ){
            power_10_max=power_10_max - max_power_10;
        }
        fact=Math.pow(10.0,-power_10_max);
        for(i=0;i<n;i++){
            numbers[i]=x[i]*fact;
        }
        return(power_10_max);
    }
}