import java.applet.Applet;
import java.awt.Panel;
import java.awt.Canvas;
import java.awt.Label;
import java.awt.Color;
import java.awt.Image;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Dimension;
import java.awt.LayoutManager;
import java.awt.Scrollbar;
import java.awt.Button;
import java.awt.Checkbox;
import java.awt.BorderLayout;
import java.awt.FontMetrics;
import java.awt.FlowLayout;
import java.awt.image.MemoryImageSource;
import java.awt.event.AdjustmentListener;
import java.awt.event.ActionListener;
import java.awt.event.ItemListener;
import java.awt.event.AdjustmentEvent;
import java.awt.event.ActionEvent;
import java.awt.event.ItemEvent;
import java.util.Random;
import java.util.StringTokenizer;

public class poly extends Applet implements Runnable
{
    public static int SLIDER_COUNT = 6;

    public PolyControls controlsPanel;
    public PolyCanvas canvas;
    public Label footlabel = null;
    public int[] coeffs = null;
    public static final int YSCALES_COUNT = 10;
    public static final int[][] YSCALES =
    {
    	{   5,  1 },
        {  10,  1 },
        {  20,  2 },
        {  40,  5 },
        {  60,  5 },
        {  80, 10 },
        { 100, 10 },
        { 150, 10 },
        { 200, 20 },
        { 400, 40 }
    };
    public static final int[][] XSCALES =
    {
    	{   4,  1 },
        {   4,  1 },
        {   4,  1 },
        {   4,  1 },
        {   5,  1 },
        {   5,  1 },
        {   6,  1 },
        {  10,  1 },
        {  15,  1 },
        {  20,  2 }
    };
    public int y_scale_slider = 2;
    public boolean logScale = false;
    public boolean doContour = false;
    public boolean calcComplete = false;
    public boolean calcRunning = false;
    public boolean calcAbort = false;

    public Color backcolor = new Color(255,255,240);
    public Color plotcolor = Color.blue;
    public int minCoeff = -10;
    public int maxCoeff = 10;
    public double plotXDelta = 0.1;

    private final static String PARAM_backcolor = "backcolor";
    private final static String PARAM_plotcolor = "plotcolor";
    private final static String PARAM_mincoeff = "mincoeff";
    private final static String PARAM_maxcoeff = "maxcoeff";

    //----------------------------------------------------------------------------------------------
    public String[][] getParameterInfo()
    {
    	String[][] info =
        {
        	{ PARAM_backcolor, "String", "Background color: r,g,b" },
        	{ PARAM_plotcolor, "String", "Plot line color: r,g,b" },
            { PARAM_mincoeff, "Int", "Minimum polynomial term coefficient" },
            { PARAM_maxcoeff, "Int", "Maximum polynomial term coefficient" }
        };
        return info;
	}

    //----------------------------------------------------------------------------------------------
    public String getAppletInfo()
    {
        return "Greg Keogh's Polynomial Plotter 1.2 <greg@mira.net>";
    }

    //----------------------------------------------------------------------------------------------
    public void init()
    {
    	String param = null;
        param = getParameter(PARAM_backcolor);
        if (param != null)
        	backcolor = rgbToColor(param);
        param = getParameter(PARAM_plotcolor);
        if (param != null)
        	plotcolor = rgbToColor(param);
        param = getParameter(PARAM_mincoeff);
        if (param != null)
        	minCoeff = Integer.parseInt(param);
        param = getParameter(PARAM_maxcoeff);
        if (param != null)
        	maxCoeff = Integer.parseInt(param);

    	coeffs = new int[SLIDER_COUNT];
        randomCoefficients();
        setLayout(new BorderLayout());
        controlsPanel = new PolyControls(this);
        footlabel = new Label("Footer");
        footlabel.setBackground(Color.white);
        add("North", controlsPanel);
        add("Center", canvas = new PolyCanvas(this));
        add("South",footlabel);
    }

    //----------------------------------------------------------------------------------------------
    public Color rgbToColor(String rgb)
    {
    	int r=0,g=0,b=0,seq=0;
    	StringTokenizer st = new StringTokenizer(rgb,",");
        while (st.hasMoreTokens())
        {
			String tok = st.nextToken();
            switch (seq++)
            {
            	case 0 : r=Integer.parseInt(tok); break;
            	case 1 : g=Integer.parseInt(tok); break;
            	case 2 : b=Integer.parseInt(tok); break;
            }
        }
        return new Color(r,g,b);
	}

    //----------------------------------------------------------------------------------------------
    public void randomCoefficients()
    {
	    int range = (maxCoeff - minCoeff)/2;
        coeffs[0] = 1;
        for (int i=1; i<SLIDER_COUNT; i++)
        {
        	coeffs[i] = (int)((Math.random() * (range)) - range/2);
        }
    }

    //----------------------------------------------------------------------------------------------
    public void destroy()
    {
        remove(controlsPanel);
        remove(canvas);
    }

	//----------------------------------------------------------------------------------------------
    public void start()
    {
    }

    //----------------------------------------------------------------------------------------------
    public void stop()
    {
    }

    //----------------------------------------------------------------------------------------------
    public void run()
    {
    }

    //----------------------------------------------------------------------------------------------
    public void updateGraph()
    {
        canvas.repaint();
	}

    //----------------------------------------------------------------------------------------------
/*
    public static void main(String args[])
    {
        Frame f = new Frame("poly");
        poly polyApplet = new poly();
        polyApplet.init();
        f.add("Center", polyApplet);
        f.pack();
        f.show();
        polyApplet.start();
    }
*/

}

	//----------------------------------------------------------------------------------------------
    class PolyCanvas extends Canvas
    {
    	private poly parentApplet = null;
        private int wide = 0;
        private int high = 0;
        private int[] pixtab = null;
        private Random rand = new Random();
        private MemoryImageSource mis = null;
        private Image img = null;
        private int[] rtab = null;
        private int[] gtab = null;
        private int[] btab = null;
        private double a,b,c,d,e,f;
        private double xx,yy,re,im,abs;
        private int x,y;
        private int percent_done = 0;
        private Font font1 = null;
        private Font font2 = null;
        final static double XLIM = 4.0;
        final static double YLIM = 3.0;
        final static double MULT = 2.0;
        final static int PROGRESS_COUNT = 20;

    	//==================================================
        public PolyCanvas(poly parentApplet)
        {
        	this.parentApplet = parentApplet;
            this.setBackground(parentApplet.backcolor);
            font1 = new Font("Arial",Font.PLAIN,36);
            font2 = new Font("Arial",Font.PLAIN,12);
		}

    	//==================================================
        public void paint(Graphics g)
        {
            wide = getSize().width;
            high = getSize().height;
            super.paint(g);
            if (parentApplet.doContour)
            	drawContourPlot(g);
            else
	            drawGraph(g);
            g.setColor(Color.black);
            g.drawLine(0,0,wide-1,0);
            g.drawLine(wide-1,0,wide-1,high-1);
            g.drawLine(wide-1,high-1,0,high-1);
            g.drawLine(0,high-1,0,0);
        }

    	//==================================================
        private void drawContourPlot(Graphics g)
        {
            if (parentApplet.calcComplete)
            	blitContour(g);
            else
            {
	            if (!parentApplet.calcRunning)
                {
                    pixtab = new int[wide*high];
                    for (int i=0; i<wide*high; i++)
                        pixtab[i] = 0xff704050;
                    mis = new MemoryImageSource(wide, high, pixtab, 0, wide);
                    blitContour(g);
                    ContourCalculator calc = new ContourCalculator(g);
                    calc.start();
                    progressMessage(g);
                }
                else
                {
                	progressMessage(g);
                }
            }
		}

    	//==================================================
        private void progressMessage(Graphics g)
        {
        	Font oldfont = g.getFont();
            g.setFont(font1);
            FontMetrics fm = g.getFontMetrics();
            g.setColor(Color.black);
            String msg = "Calculating Contour Plot";
            int msgwidth = fm.stringWidth(msg);
			g.drawString(msg,(wide-msgwidth)/2,(int)(0.25*high));
            msg = percent_done + "% Complete";
            msgwidth = fm.stringWidth(msg);
			g.drawString(msg,(wide-msgwidth)/2,(int)(0.4*high));
            g.setFont(font2);
            fm = g.getFontMetrics();
            msg = "Click the Stop button to abort the calculation";
            msgwidth = fm.stringWidth(msg);
			g.drawString(msg,(wide-msgwidth)/2,(int)(0.6*high));
            g.setFont(oldfont);
		}

    	//==================================================
        private void blitContour(Graphics g)
        {
        	if (!parentApplet.calcComplete)
            {
            }
            else
            {
	            img = createImage(mis);
				g.drawImage(img,0,0,null);
            }
		}

    	//==================================================
        class ContourCalculator extends Thread
        {
        	Graphics g = null;

            public ContourCalculator(Graphics g)
            {
            	this.g = g;
            }

            public void run()
            {
                parentApplet.calcRunning = true;
                a = parentApplet.coeffs[0];
                b = parentApplet.coeffs[1];
                c = parentApplet.coeffs[2];
                d = parentApplet.coeffs[3];
                e = parentApplet.coeffs[4];
                f = parentApplet.coeffs[5];
                rtab = new int[256];
                gtab = new int[256];
                btab = new int[256];
                for (int i=0; i<256; i++)
                {
                    rtab[i] = (int)(rand.nextFloat() * 256);
                    gtab[i] = (int)(rand.nextFloat() * 256);
                    btab[i] = (int)(rand.nextFloat() * 256);
                }
                parentApplet.calcAbort = false;
                for (x=0; x<wide; x++)
                {
                	percent_done = (100*x)/wide;
                	if (parentApplet.calcAbort)
                    {
                    	break;
                    }
                    if (x%(wide/PROGRESS_COUNT)==0)
                    {
                    	parentApplet.updateGraph();
                    }
                    for (y=0; y<high; y++)
                    {
                        xx = ((double)x*2.0*XLIM)/wide - XLIM;
                        yy = ((double)y*2.0*YLIM)/high - YLIM;
                        // The follow code to calculate the real and imaginary parts of the general 5th degree
                        // polynomial were generated by Mathematica 4 in 'CForm' and them converted to Java.
                        re = f + e*xx + d*Math.pow(xx,2) + c*Math.pow(xx,3) + b*Math.pow(xx,4) + a*Math.pow(xx,5)
                                - d*Math.pow(yy,2) - 3*c*xx*Math.pow(yy,2) - 6*b*Math.pow(xx,2)*Math.pow(yy,2)
                                - 10*a*Math.pow(xx,3)*Math.pow(yy,2)
                                + b*Math.pow(yy,4) + 5*a*xx*Math.pow(yy,4);
                        im = e*yy + 2*d*xx*yy + 3*c*Math.pow(xx,2)*yy + 4*b*Math.pow(xx,3)*yy
                                + 5*a*Math.pow(xx,4)*yy - c*Math.pow(yy,3) - 4*b*xx*Math.pow(yy,3)
                                - 10*a*Math.pow(xx,2)*Math.pow(yy,3) + a*Math.pow(yy,5);
                        abs = MULT * Math.sqrt(re*re + im*im);
                        int val = ((int)abs) % 256;
                        int off = x + wide*y;
                        int rx = rtab[val];
                        int gx = gtab[val];
                        int bx = btab[val];
                        int ax = 0xff;
                        int abgr = (ax<<24) | (rx<<16) | (gx<<8) | (bx);
                        pixtab[off] = abgr;
                    }
                }
                parentApplet.calcRunning = false;
                parentApplet.calcComplete = true;
                parentApplet.controlsPanel.setContourBusy(false);
                parentApplet.updateGraph();
            }
        }

    	//==================================================
        private void drawGraph(Graphics g)
        {
        	int i;
            double x,y;
            int xscale0 = parentApplet.XSCALES[parentApplet.y_scale_slider][0];
            int xscale1 = parentApplet.XSCALES[parentApplet.y_scale_slider][1];
            int yscale0 = parentApplet.YSCALES[parentApplet.y_scale_slider][0];
            int yscale1 = parentApplet.YSCALES[parentApplet.y_scale_slider][1];

            // ** Draw the vertical gridlines

            g.setColor(Color.darkGray);
            int midx = wide/2;
            float incx = (float)(wide * xscale1)/(2 * xscale0);
        	for (i=0; i<xscale0; i++)
            {
            	int x1 = midx + (int)(i*incx);
                int x2 = midx - (int)(i*incx);
            	g.drawLine(x1,0,x1,high);
                g.drawLine(x2,0,x2,high);
                g.setColor(Color.lightGray);
            }

            // ** Draw the horizontal gridlines

            FontMetrics fm = g.getFontMetrics();
            g.setColor(Color.darkGray);
            int midy = high/2;
            float incy = (float)(high * yscale1)/(2 * yscale0);
        	for (i=0; i<yscale0; i++)
            {
            	int y1 = midy + (int)(i*incy);
                int y2 = midy - (int)(i*incy);
            	g.drawLine(0,y1,wide,y1);
                g.drawLine(0,y2,wide,y2);
            	if ( (i!=0) && (i%4==0) )
				{
	                g.setColor(Color.black);
                    Integer ii = new Integer(i*yscale1);
	                g.drawString(ii.toString(),midx+10,y2+fm.getHeight()/2);
	                g.drawString("-" + ii.toString(),midx+10,y1+fm.getHeight()/2);
                }
                g.setColor(Color.lightGray);
            }
            if (parentApplet.coeffs == null)
            	return;
            g.setColor(Color.black);

            // ** Construct the graph equation for display

            StringBuffer sb = new StringBuffer(" y = ");
            for (i=0; i<poly.SLIDER_COUNT; i++)
            {
				if (parentApplet.coeffs[i] == 0)
					continue;
            	int pow = poly.SLIDER_COUNT - 1 - i;
                int c = parentApplet.coeffs[i];
                switch (pow)
                {
                	case 0 :
                    	sb.append(c>0 ? " + " : " - ");
                    	sb.append(Math.abs(c));
                    	break;
                    case 1 :
                    	sb.append(c>0 ? " + " : " - ");
                        if (c==1 || c==-1)
                    		sb.append("x");
                        else
                        	sb.append(Math.abs(c) + "x");
                    	break;
                    default :
                    	if (i > 0)
	                    	sb.append(c>0 ? " + " : " - ");
                        if (c==1 || c==-1)
                    		sb.append("x^");
                        else
                        	sb.append(Math.abs(c) + "x^");
	                	sb.append(pow);
                        break;
                }
            }
            //sb.append("  Y-Scale=(" + yscale0 + "," + yscale1 + ")");
            //sb.append("  X-Scale=(" + xscale0 + "," + xscale1 + ")");
            parentApplet.footlabel.setText(sb.toString());

            // ** Draw the polynomial graph

            double lastx = Double.MAX_VALUE;
            double lasty = 0.0;
            g.setColor(parentApplet.plotcolor);
            for (x=-xscale0; x<xscale0; x+= parentApplet.plotXDelta)
            {
            	y = polyCalc(x);
                if (lastx != Double.MAX_VALUE)
				{
                    if (parentApplet.logScale)
                    {
                    	double origy = y;
                    	y = Math.log(Math.abs(y)+1);
                        if (origy < 0.0)
                        	y *= -1.0;
                    }
	                int x1 = (int)((lastx+xscale0)/(2*xscale0) * wide);
	                int x2 = (int)((x+xscale0)/(2*xscale0) * wide);
	                int y1 = high - (int)((lasty+yscale0)/(2*yscale0) * high);
	                int y2 = high - (int)((y+yscale0)/(2*yscale0) * high);
                    int absy1 = Math.abs(y1);
                    // Stop way out-of-range y values from creating spurious lines
					if (absy1 <= (high*10))
                    {
		                g.drawLine(x1,y1,x2,y2);
                    }
                }
                lasty = y;
                lastx = x;
            }
        }

    	//==================================================
        private double polyCalc(double x)
        {
            double y = 0.0;
            for (int i=0; i<poly.SLIDER_COUNT; i++)
            {
                int pow = poly.SLIDER_COUNT - 1 - i;
                switch (pow)
                {
                    case 0 :
                        y += parentApplet.coeffs[i];
                        break;
                    case 1 :
                        y += parentApplet.coeffs[i] * x;
                        break;
                    default :
                        y += parentApplet.coeffs[i] * Math.pow(x,pow);
                        break;
                }
            }
            return y;
        }

    	//==================================================
        public void update(Graphics g)
        {
            paint(g);
        }

    	//==================================================
        public Dimension getMinimumSize()
        {
            return new Dimension(640, 480);
        }

    	//==================================================
        public Dimension getPreferredSize()
        {
            return new Dimension(640, 480);
        }
    }

    //----------------------------------------------------------------------------------------------
    class PolyControls extends Panel
    {
        private poly parentApplet = null;
        private static LayoutManager controlsLayout = new FlowLayout(FlowLayout.CENTER, 10, 5);
        private Scrollbar[] scrollers = null;
        private Button randButton = null;
        private Scrollbar plotyScroller = null;
        private Checkbox logCheck = null;
        public Button contourButton = null;

    	//==================================================
        public PolyControls(poly app)
        {
            parentApplet = app;
            setLayout(controlsLayout);
            scrollers = new Scrollbar[poly.SLIDER_COUNT];
            for (int i=0; i<poly.SLIDER_COUNT; i++)
            {
            	scrollers[i] = new Scrollbar(Scrollbar.HORIZONTAL,parentApplet.coeffs[i],1,parentApplet.minCoeff,parentApplet.maxCoeff+1);
                scrollers[i].addAdjustmentListener(new AdjustmentListener()
                	{
                    	public void adjustmentValueChanged(AdjustmentEvent e)
                        {
                        	sliderChange();
                        }
                    });
	            add(scrollers[i]);
            }
            randButton = new Button("Random");
            randButton.addActionListener(new ActionListener()
            	{
                	public void actionPerformed(ActionEvent e)
                    {
                        parentApplet.calcAbort = true;
                    	parentApplet.randomCoefficients();
                        for (int i=0; i<poly.SLIDER_COUNT; i++)
                        	scrollers[i].setValue(parentApplet.coeffs[i]);
                        parentApplet.doContour = false;
                        parentApplet.updateGraph();
                    }
                });
            add(randButton);
            plotyScroller = new Scrollbar(Scrollbar.HORIZONTAL,
            		2,								// Default y-magnify slider
                    1,
                    1,								// Low y-magnify value
                    parentApplet.YSCALES_COUNT+1);	// High y-magnify value
            plotyScroller.addAdjustmentListener(new AdjustmentListener()
                {
                    public void adjustmentValueChanged(AdjustmentEvent e)
                    {
                        sliderChange();
                    }
                });
            add(plotyScroller);
            logCheck = new Checkbox("Log");
            logCheck.addItemListener(new ItemListener()
            {
            	public void itemStateChanged(ItemEvent e)
                {
                    parentApplet.calcAbort = true;
                	parentApplet.logScale = (parentApplet.logScale ? false : true);
                    parentApplet.doContour = false;
                	parentApplet.updateGraph();
                }
            });
            add(logCheck);
            contourButton = new Button("Contour");
            contourButton.addActionListener(new ActionListener()
            	{
                	public void actionPerformed(ActionEvent e)
                    {
                    	parentApplet.calcAbort = true;
                    	parentApplet.calcComplete = false;
                    	if (parentApplet.calcRunning)
                        {
	                    	parentApplet.calcRunning = false;
	                        parentApplet.doContour = false;
                            setContourBusy(false);
                        }
                        else
                        {
                        	if (parentApplet.doContour)
                            {
                            	parentApplet.doContour = false;
                            }
                            else
                            {
		                        parentApplet.doContour = true;
	                            setContourBusy(true);
                            }
                        }
	                    parentApplet.updateGraph();
                    }
                });
            add(contourButton);
        }

    	//==================================================
        private void sliderChange()
        {
        	parentApplet.calcAbort = true;
        	for (int i=0; i<poly.SLIDER_COUNT; i++)
            {
            	parentApplet.coeffs[i] = scrollers[i].getValue();
            }
            parentApplet.y_scale_slider = plotyScroller.getValue() - 1;
            Button randButton = null;
            parentApplet.doContour = false;
            parentApplet.updateGraph();
        }

    	//==================================================
        public void setContourBusy(boolean busy)
        {
        	for (int i=0; i<parentApplet.SLIDER_COUNT; i++)
            	scrollers[i].setEnabled(!busy);
            randButton.setEnabled(!busy);
            plotyScroller.setEnabled(!busy);
            logCheck.setEnabled(!busy);
            contourButton.setLabel(busy ? "Stop" : "Contour");		// Contour/Plot should toggle
		}

	}