//Mod1Input.java
/*
 * Panel with all input operations for Module1.1
 * Using null layout - positions of elements hard-coded
 * authors: Umberto Ravaioli, Janice Richards
 * version 1.0 - Copyright: Amanogawa.com - All Rights Reserved
 */

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;

public class Mod1Input extends Panel implements ChangeListener {
    private Mod1State state;
    private static final Color bgcolor = new Color(236,236,236);
    public int ScrollMax = 100;   //10000;
    private int endingX;
    private Label titlelabel, lab;
    private String vectrA, vectrB;
    private Label labzA, labThetaA, labzB, labThetaB;
    private Label ulabzA, ulabThetaA, ulabzB, ulabThetaB;
    public TextField textzA, textThetaA, textzB, textThetaB;
    private Label labxA, labyA, labxB, labyB;
    private Label ulabxA, ulabyA, ulabxB, ulabyB;
    public TextField textxA, textyA, textxB, textyB;
    public JSlider sliderxA, slideryA, sliderxB, slideryB;
    public JSlider sliderzA, sliderThetaA, sliderzB, sliderThetaB;

    public Checkbox choiceA, choiceB, choiceAplusB, choiceAminusB;
    public CheckboxGroup plotChoices;
    private Label plotChoicesLab;
    private String choiceAlab, choiceBlab, choiceAplusBlab, choiceAminusBlab;

    public Choice ch;
    
    private Font labfont, boldLabfont, boldfont, normalfont;
    private boolean ignoreSliderAdjustment = false;
    private MiniCanvas miniGraphA, miniGraphB;
    static double piOver180 = Math.PI/180.0;
    //public static Font labfont = new Font("SanSerif",Font.BOLD,12);

    public Mod1Input(Mod1State state){
	super();
	setLayout(null);
	setBackground(bgcolor);
	this.state = state;

        //labfont = state.sanSerifFont.deriveFont(12F);
        //boldLabfont = state.sanSerifFont.deriveFont(Font.BOLD,12F);
        //normalfont = state.sanSerifFont.deriveFont(14F);
        //boldfont = state.sanSerifFont.deriveFont(Font.BOLD,14F);
        
        labfont = new Font("SanSerif",Font.PLAIN,state.font12);
        boldLabfont = new Font("SanSerif",Font.BOLD,state.font12);
        normalfont = new Font("SanSerif",Font.PLAIN,state.font14);
        boldfont = new Font("SanSerif",Font.BOLD,state.font14);
        
        miniGraphA = new MiniCanvas(state,bgcolor,'A');
        miniGraphB = new MiniCanvas(state,bgcolor,'B');
        add(miniGraphA);
        add(miniGraphB);

	titlelabel = new Label("Input",Label.CENTER);
	//titlelabel.setFont(TheFonts.bold16);
        titlelabel.setFont(new Font("SanSerif",Font.BOLD,state.font16));
        //titlelabel = "Input";
	
	Label lab = new Label("Select coordinate system: ", Label.RIGHT);
        lab.setFont(normalfont);
        //lab = "Select coordinate system: ";
        //lab.setFont(boldLabfont);

        ch = new Choice();
        //ch.setFont(TheFonts.sanSerif14);
        ch.setFont(normalfont);
        //ch.setFont(boldLabfont);
	ch.addItem(" rectangular (x,y)");
	ch.addItem(" polar (|z|, "+Character.toString((char)0x03b8)+")");


        plotChoicesLab = new Label("Compute and display",Label.RIGHT);
        plotChoicesLab.setFont(normalfont);
        //plotChoicesLab = "Compute and display";
	plotChoices = new CheckboxGroup();
	choiceA = new Checkbox(" ",plotChoices,true);
        choiceB = new Checkbox(" ",plotChoices,false);
        choiceAplusB = new Checkbox(" ",plotChoices,false);
        choiceAminusB = new Checkbox(" ",plotChoices,false);
        choiceAlab = STR.RED+"A"+STR.ENDRED+" alone";
        choiceBlab = STR.BLUE+"B"+STR.ENDBLUE+" alone";
        choiceAplusBlab = STR.GREEN+"C"+STR.ENDGREEN+" = "+
            STR.RED+"A"+STR.ENDRED+" + "+STR.BLUE+"B"+STR.ENDBLUE;
        choiceAminusBlab = STR.GREEN+"C"+STR.ENDGREEN+" = "+
            STR.RED+"A"+STR.ENDRED+" - "+STR.BLUE+"B"+STR.ENDBLUE;


        //Label vectrA = new Label("Vector ", Label.LEFT);
        //vectrA.setFont(TheFonts.bold14);   //state.ttfFont.deriveFont(16f));
        //Label vectrB = new Label("Vector ", Label.LEFT);
        //vectrB.setFont(TheFonts.bold14);   //state.ttfFont.deriveFont(16f));
        //Label vA = new Label("A", Label.LEFT);
        //Label vB = new Label("B", Label.LEFT);
        //vA.setFont(TheFonts.bold14);   //state.ttfFont.deriveFont(16f));
        //vB.setFont(TheFonts.bold14);   //state.ttfFont.deriveFont(16f));
        //vA.setForeground(state.redColor);
        //vB.setForeground(state.blueColor);
        vectrA = "Vector "+STR.RED+"A"+STR.ENDRED;
        vectrB = "Vector "+STR.BLUE+"B"+STR.ENDBLUE;
        
	

        createRectInputsA(true);   // The default option
        createRectInputsB(true);   // The default option
        createPolarInputsA(false); // NOT the default option
        createPolarInputsB(false); // NOT the default option

	
        // Set slider values to defaults:
        //initializePolarInputs();
        initializeRectInputs();

	
	add(titlelabel);
        //add(vectrA);
        //add(vectrB);
        //add(vA);
        //add(vB);

        add(labxA);
        add(labxB);
        add(labyA);
        add(labyB);
        add(textxA);
        add(textxB);
        add(textyA);
        add(textyB);
        add(sliderxA);
        add(sliderxB);
        add(slideryA);
        add(slideryB);
	add(labzA);
	add(labzB);
	add(labThetaA);
	add(labThetaB);
	add(textzA);
	add(textzB);
	add(textThetaA);
	add(textThetaB);
	add(sliderzA);
	add(sliderzB);
	add(sliderThetaA);
	add(sliderThetaB);

        add(lab);
        add(ch);

	add(ulabxA);
	add(ulabxB);
	add(ulabyA);
	add(ulabyB);
	add(ulabzA);
	add(ulabzB);
	add(ulabThetaA);
	add(ulabThetaB);

        add(plotChoicesLab);
	add(choiceA);
        add(choiceB);
        add(choiceAplusB);
        add(choiceAminusB);


        // TEMPORARY?? 7/26/14 try to get rid of "..." on macs
        //lab.setBounds(20,35,180,20);
        //ch.setBounds(210,35,180,20);
        lab.setBounds(state.s20,state.s35,state.s200,state.s20);
        ch.setBounds(state.s220,state.s35,state.s200,state.s20);


	titlelabel.setBounds(state.s20,state.s5,state.s50,state.s18);
        //vectrA.setBounds(20,77,50,18);
        //vA.setBounds(70,77,15,18);
        //vectrB.setBounds(20,180,50,18);
        //vB.setBounds(70,180,15,18);

        /*
        plotChoicesLab.setBounds(20,300,150,18);
        choiceA.setBounds(180,300,20,18);
        choiceB.setBounds(180,320,20,18);
        choiceAplusB.setBounds(180,340,20,18);
        choiceAminusB.setBounds(180,360,20,18);
        */

        // TEMPORARY?? 7/26/14 try to get rid of "..." on macs
        //plotChoicesLab.setBounds(20,370,150,18);
        //choiceA.setBounds(180,370,20,18);
        //choiceB.setBounds(180,390,20,18);
        //choiceAplusB.setBounds(180,410,20,18);
        //choiceAminusB.setBounds(180,430,20,18);
        
        plotChoicesLab.setBounds(state.s20,state.s370,state.s170,state.s18);
        choiceA.setBounds(state.s200,state.s370,state.s20,state.s18);
        choiceB.setBounds(state.s200,state.s390,state.s20,state.s18);
        choiceAplusB.setBounds(state.s200,state.s410,state.s20,state.s18);
        choiceAminusB.setBounds(state.s200,state.s430,state.s20,state.s18);

        posnRectInputsA();
        posnRectInputsB();
        posnPolarInputsA();
        posnPolarInputsB();

        /*
        miniGraphA.setBounds(200,60,60,60);
        //miniGraphB.setBounds(200,170,60,60);
        miniGraphB.setBounds(200,222,60,60); //vpos: add (70-18=52) 170+52=222
	*/

        // NEW size of miniGraphs is 1.5 X 60  (=90)
        //miniGraphA.setBounds(200,60,90,90);
        //miniGraphB.setBounds(200,222,90,90); //vpos: add (70-18=52) 170+52=222
        //miniGraphA.setBounds(185,45,90,90);
        miniGraphA.setBounds(state.s185,state.s69,state.s90,state.s90);
        miniGraphB.setBounds(state.s185,state.s207,state.s90,state.s90); //vpos: add (70-18=52) 170+52=222

	//Listeners
	sliderxA.addChangeListener(this);
	sliderxB.addChangeListener(this);
	slideryA.addChangeListener(this);
	slideryB.addChangeListener(this);
	sliderzA.addChangeListener(this);
	sliderzB.addChangeListener(this);
	sliderThetaA.addChangeListener(this);
	sliderThetaB.addChangeListener(this);
    }


    // INITIALIZE mini graphs
    public void createMiniGraphs() {
        miniGraphA.repaint();
        miniGraphB.repaint();
    }
    
    public void drawMiniGraphs() {
        miniGraphA.repaint();
        miniGraphB.repaint();
    }



    private void createPolarInputsA(boolean disp) {		
	labzA = new Label("|z| =  ",Label.RIGHT);
        labzA.setFont(boldLabfont);
        labzA.setForeground(state.redColor);
        labzA.setVisible(disp);
        //labzA = STR.RED+"|z|"+STR.ENDRED+" = ";
        labThetaA = new Label(Character.toString((char)0x03b8)+" =  ",
                             Label.RIGHT);
        labThetaA.setFont(TheFonts.symbol14);
        labThetaA.setForeground(state.redColor);
        labThetaA.setVisible(disp);
        //labThetaA = STR.RED+Character.toString((char)0x03b8)+STR.ENDRED+
        //    " =  ";
		
	//textz = new TextField(""+state.zVal,8);
	textzA = new TextField(8);
        textzA.setFont(boldLabfont);
        textzA.setForeground(state.redColor);
        textzA.setVisible(disp);
	//textTheta = new TextField(""+state.thetaVal,8);
	textThetaA = new TextField(8);
        textThetaA.setFont(boldLabfont);
        textThetaA.setForeground(state.redColor);
        textThetaA.setVisible(disp);
	
	ulabzA = new Label(" ",Label.LEFT);
        ulabzA.setFont(labfont);
        ulabzA.setForeground(state.redColor);
        //ulabzA = " ";
	ulabThetaA = new Label("\u00b0",Label.LEFT);
        ulabzA.setVisible(disp);
        ulabThetaA.setFont(labfont);
        ulabThetaA.setForeground(state.redColor);
        ulabThetaA.setVisible(disp);
        //ulabThetaA = STR.RED+"\u00b0"+STR.ENDRED;

	sliderzA = new JSlider(0,ScrollMax+1);
	sliderzA.setValue(0);
	sliderThetaA = new JSlider(0,ScrollMax+1);
	sliderThetaA.setValue(0);
	/*
	sliderzA = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
	sliderThetaA = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
        sliderzA.setBackground(Color.white);
        sliderThetaA.setBackground(Color.white);
	*/
        sliderzA.setVisible(disp);
        sliderThetaA.setVisible(disp);
    }



    private void createPolarInputsB(boolean disp) {		
	labzB = new Label("|z| =  ",Label.RIGHT);
        labzB.setFont(boldLabfont);
        labzB.setForeground(state.blueColor);
        labzB.setVisible(disp);
        //labzB = STR.BLUE+"|z|"+STR.ENDBLUE+" = ";
        labThetaB = new Label(Character.toString((char)0x03b8)+" =  ",
                             Label.RIGHT);
        labThetaB.setFont(TheFonts.symbol14);
        labThetaB.setForeground(state.blueColor);
        labThetaB.setVisible(disp);
        //labThetaB = STR.BLUE+Character.toString((char)0x03b8)+STR.ENDBLUE+
        //    " =  ";
		
	//textz = new TextField(""+state.zVal,8);
	textzB = new TextField(8);
        textzB.setFont(boldLabfont);
        textzB.setForeground(state.blueColor);
        textzB.setVisible(disp);
	//textTheta = new TextField(""+state.thetaVal,8);
	textThetaB = new TextField(8);
        textThetaB.setFont(boldLabfont);
        textThetaB.setForeground(state.blueColor);
        textThetaB.setVisible(disp);
	
	ulabzB = new Label(" ",Label.LEFT);
        ulabzB.setFont(labfont);
        ulabzB.setForeground(state.blueColor);
        //ulabzB = " ";
	ulabThetaB = new Label("\u00b0",Label.LEFT);
        ulabzB.setVisible(disp);
        ulabThetaB.setFont(labfont);
        ulabThetaB.setForeground(state.blueColor);
        ulabThetaB.setVisible(disp);
        //ulabThetaB = STR.BLUE+"\u00b0"+STR.ENDBLUE;

	sliderzB = new JSlider(0,ScrollMax+1);
	sliderzB.setValue(0);
	sliderThetaB = new JSlider(0,ScrollMax+1);
	sliderThetaB.setValue(0);
	/*
	sliderzB = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
	sliderThetaB = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
        sliderzB.setBackground(Color.white);
        sliderThetaB.setBackground(Color.white);
	*/
        sliderzB.setVisible(disp);
        sliderThetaB.setVisible(disp);
    }



    private void createRectInputsA(boolean disp) {		
	labxA = new Label("x =  ",Label.RIGHT);
        labxA.setFont(boldLabfont);
        labxA.setForeground(state.redColor);
        labxA.setVisible(disp);
        //labxA = STR.RED+"x"+STR.ENDRED+" = ";
	labyA = new Label("y =  ",Label.RIGHT);
        labyA.setFont(boldLabfont);
        labyA.setForeground(state.redColor);
        labyA.setVisible(disp);
        //labyA = STR.RED+"y"+STR.ENDRED+" = ";
		
	//textx = new TextField(""+state.xVal,8);
        textxA = new TextField(8);
        textxA.setFont(boldLabfont);
        textxA.setForeground(state.redColor);
        textxA.setVisible(disp);
	//texty = new TextField(""+state.yVal,8);
        textyA = new TextField(8);
        textyA.setFont(boldLabfont);
        textyA.setForeground(state.redColor);
        textyA.setVisible(disp);
	
	ulabxA = new Label(" ",Label.LEFT);
        ulabxA.setFont(labfont);
        ulabxA.setVisible(disp);
        ulabxA.setForeground(state.redColor);
        //ulabxA = " ";
	ulabyA = new Label(" ",Label.LEFT);
        ulabyA.setFont(labfont);
        ulabyA.setVisible(disp);
        ulabyA.setForeground(state.redColor);
        //ulabyA = " ";

	sliderxA = new JSlider(0,ScrollMax+1);
	sliderxA.setValue(0);
	slideryA = new JSlider(0,ScrollMax+1);
	slideryA.setValue(0);
	/*
	sliderxA = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
	slideryA = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
        sliderxA.setBackground(Color.white);
        slideryA.setBackground(Color.white);
	*/
        sliderxA.setVisible(disp);
        slideryA.setVisible(disp);
        return;
    }



    private void createRectInputsB(boolean disp) {		
	labxB = new Label("x =  ",Label.RIGHT);
        labxB.setFont(boldLabfont);
        labxB.setForeground(state.blueColor);
        labxB.setVisible(disp);
        //labxB = STR.BLUE+"x"+STR.ENDBLUE+" = ";
	labyB = new Label("y =  ",Label.RIGHT);
        labyB.setFont(boldLabfont);
        labyB.setForeground(state.blueColor);
        labyB.setVisible(disp);
        //labyB = STR.BLUE+"y"+STR.ENDBLUE+" = ";
		
	//textx = new TextField(""+state.xVal,8);
        textxB = new TextField(8);
        textxB.setFont(boldLabfont);
        textxB.setForeground(state.blueColor);
        textxB.setVisible(disp);
	//texty = new TextField(""+state.yVal,8);
        textyB = new TextField(8);
        textyB.setFont(boldLabfont);
        textyB.setForeground(state.blueColor);
        textyB.setVisible(disp);
	
	ulabxB = new Label(" ",Label.LEFT);
        ulabxB.setFont(labfont);
        ulabxB.setVisible(disp);
        ulabxB.setForeground(state.blueColor);
        //ulabxB = " ";
	ulabyB = new Label(" ",Label.LEFT);
        ulabyB.setFont(labfont);
        ulabyB.setVisible(disp);
        ulabyB.setForeground(state.blueColor);
        //ulabyB = " ";

	sliderxB = new JSlider(0,ScrollMax+1);
	sliderxB.setValue(0);
	slideryB = new JSlider(0,ScrollMax+1);
	slideryB.setValue(0);
	/*
	sliderxB = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
	slideryB = new Scrollbar(Scrollbar.HORIZONTAL,0,1,0,ScrollMax+1);
        sliderxB.setBackground(Color.white);
        slideryB.setBackground(Color.white);
	*/
        sliderxB.setVisible(disp);
        slideryB.setVisible(disp);
        return;
    }



    private void posnPolarInputsA() {
	//int vPosInit = 57, vPos, dvPos = 4, vHeight = 20; 
	//int vPosInit = 107, vPos, dvPos = 4, vHeight = 20; 
	int vPosInit = state.s147, vPos, dvPos = state.s4, vHeight = state.s20; 
	vPos = vPosInit;
	
	labzA.setBounds(state.s20,vPos,state.s80,vHeight);
	textzA.setBounds(state.s100,vPos,state.s80,vHeight);
	ulabzA.setBounds(state.s180,vPos,state.s1,vHeight);
	
	    vPos += vHeight + dvPos; 
	   

	sliderzA.setBounds(state.s22,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps1 = new Panel();
            //ps1.setBackground(Color.cyan);
            ps1.setBackground(Mod1State.redColor);
	    add(ps1);
	    ps1.setBounds(state.s22-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps2 = new Panel();
	    ps2.setBackground(Color.black);
	    add(ps2);
	    ps2.setBounds(state.s22-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
	vPos = vPosInit;
        int column2 = state.s220;
	    
	//
	//labThetaA.setBounds(20+column2,vPos,80,vHeight);    
	labThetaA.setBounds(state.s60+column2,vPos,state.s40,vHeight);    
	textThetaA.setBounds(state.s100+column2,vPos,state.s80,vHeight);
	ulabThetaA.setBounds(state.s180+column2,vPos,state.s40,vHeight);  
	  
	     vPos += vHeight + dvPos;
	     
	sliderThetaA.setBounds(state.s22+column2,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps9 = new Panel();
	    ps9.setBackground(Mod1State.redColor);
	    add(ps9);
	    ps9.setBounds(state.s22+column2-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps10 = new Panel();
	    ps10.setBackground(Color.black);
	    add(ps10);
	    ps10.setBounds(state.s22+column2-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
    }



    private void posnPolarInputsB() {
	//int vPosInit = 57, vPos, dvPos = 4, vHeight = 20; 
	//int vPosInit = 217, vPos, dvPos = 4, vHeight = 20; 
	int vPosInit = state.s287, vPos, dvPos = state.s4, vHeight = state.s20; 
	vPos = vPosInit;
	
	labzB.setBounds(state.s20,vPos,state.s80,vHeight);
	textzB.setBounds(state.s100,vPos,state.s80,vHeight);
	ulabzB.setBounds(state.s180,vPos,state.s1,vHeight);
	
	    vPos += vHeight + dvPos; 
	   

	sliderzB.setBounds(state.s22,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps1 = new Panel();
            //ps1.setBackground(Color.cyan);
            ps1.setBackground(Mod1State.blueColor);
	    add(ps1);
	    ps1.setBounds(state.s22-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps2 = new Panel();
	    ps2.setBackground(Color.black);
	    add(ps2);
	    ps2.setBounds(state.s22-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/   
	vPos = vPosInit;
        int column2 = state.s220;
	    
	//
	//labThetaB.setBounds(20+column2,vPos,80,vHeight);    
	labThetaB.setBounds(state.s60+column2,vPos,state.s40,vHeight);    
	textThetaB.setBounds(state.s100+column2,vPos,state.s80,vHeight);
	ulabThetaB.setBounds(state.s180+column2,vPos,state.s40,vHeight);  
	  
	     vPos += vHeight + dvPos;
	     
	sliderThetaB.setBounds(state.s22+column2,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps9 = new Panel();
	    ps9.setBackground(Mod1State.blueColor);
	    add(ps9);
	    ps9.setBounds(state.s22+column2-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps10 = new Panel();
	    ps10.setBackground(Color.black);
	    add(ps10);
	    ps10.setBounds(state.s22+column2-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
    }



    private void posnRectInputsA() {
	//int vPosInit = 57, vPos, dvPos = 4, vHeight = 20; 
	//int vPosInit = 107, vPos, dvPos = 4, vHeight = 20; 
	int vPosInit = state.s147, vPos, dvPos = state.s4, vHeight = state.s20; 
	vPos = vPosInit;
	
	labxA.setBounds(state.s20,vPos,state.s80,vHeight);
	textxA.setBounds(state.s100,vPos,state.s80,vHeight);
	ulabxA.setBounds(state.s180,vPos,state.s1,vHeight);
	
	    vPos += vHeight + dvPos; 
	   

	sliderxA.setBounds(state.s22,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps1 = new Panel();
            //ps1.setBackground(Color.cyan);
            ps1.setBackground(Mod1State.redColor);
	    add(ps1);
	    ps1.setBounds(state.s22-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps2 = new Panel();
	    ps2.setBackground(Color.black);
	    add(ps2);
	    ps2.setBounds(state.s22-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
	vPos = vPosInit;
        int column2 = state.s220;
	    
	//
	//labyA.setBounds(20+column2,vPos,80,vHeight);    
	labyA.setBounds(state.s60+column2,vPos,state.s40,vHeight);    
	textyA.setBounds(state.s100+column2,vPos,state.s80,vHeight);
	ulabyA.setBounds(state.s180+column2,vPos,state.s1,vHeight);  
	  
	     vPos += vHeight + dvPos;
	     
	slideryA.setBounds(state.s22+column2,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps9 = new Panel();
	    ps9.setBackground(Mod1State.redColor);
	    add(ps9);
	    ps9.setBounds(state.s22+column2-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps10 = new Panel();
	    ps10.setBackground(Color.black);
	    add(ps10);
	    ps10.setBounds(state.s22+column2-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
    }



    private void posnRectInputsB() {
	//int vPosInit = 57, vPos, dvPos = 4, vHeight = 20; 
	//int vPosInit = 217, vPos, dvPos = 4, vHeight = 20; 
	int vPosInit = state.s287, vPos, dvPos = state.s4, vHeight = state.s20; 
	vPos = vPosInit;
	
	labxB.setBounds(state.s20,vPos,state.s80,vHeight);
	textxB.setBounds(state.s100,vPos,state.s80,vHeight);
	ulabxB.setBounds(state.s180,vPos,state.s1,vHeight);
	
	    vPos += vHeight + dvPos; 
	   

	sliderxB.setBounds(state.s22,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps1 = new Panel();
            //ps1.setBackground(Color.cyan);
            ps1.setBackground(Mod1State.blueColor);
	    add(ps1);
	    ps1.setBounds(state.s22-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps2 = new Panel();
	    ps2.setBackground(Color.black);
	    add(ps2);
	    ps2.setBounds(state.s22-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
	vPos = vPosInit;
        int column2 = state.s220;
	    
        //
        //labyB.setBounds(20+column2,vPos,80,vHeight);    
        labyB.setBounds(state.s60+column2,vPos,state.s40,vHeight);    
	textyB.setBounds(state.s100+column2,vPos,state.s80,vHeight);
	ulabyB.setBounds(state.s180+column2,vPos,state.s1,vHeight);  
	  
	     vPos += vHeight + dvPos;
	     
	slideryB.setBounds(state.s22+column2,vPos+state.s2,state.s196,vHeight);
	/*
	Panel ps9 = new Panel();
	    ps9.setBackground(Mod1State.blueColor);
	    add(ps9);
	    ps9.setBounds(state.s22+column2-1,vPos+state.s2-1,state.s196+2,vHeight+2);
	    
	Panel ps10 = new Panel();
	    ps10.setBackground(Color.black);
	    add(ps10);
	    ps10.setBounds(state.s22+column2-2,vPos+state.s2-2,state.s196+4,vHeight+4);
	*/
    }


    public void setPolarVisible() {
        labxA.setVisible(false);
        labxB.setVisible(false);
        labyA.setVisible(false);
        labyB.setVisible(false);
        textxA.setVisible(false);
        textxB.setVisible(false);
        textyA.setVisible(false);
        textyB.setVisible(false);
        ulabxA.setVisible(false);
        ulabxB.setVisible(false);
        ulabyA.setVisible(false);
        ulabyB.setVisible(false);
        sliderxA.setVisible(false);
        sliderxB.setVisible(false);
        slideryA.setVisible(false);
        slideryB.setVisible(false);

	labzA.setVisible(true);
	labzB.setVisible(true);
        labThetaA.setVisible(true);
        labThetaB.setVisible(true);
	textzA.setVisible(true);
	textzB.setVisible(true);
	textThetaA.setVisible(true);
	textThetaB.setVisible(true);
	ulabzA.setVisible(true);
	ulabzB.setVisible(true);
	ulabThetaA.setVisible(true);
	ulabThetaB.setVisible(true);
	sliderzA.setVisible(true);
	sliderzB.setVisible(true);
	sliderThetaA.setVisible(true);
	sliderThetaB.setVisible(true);
        return;
    }



    public void setRectVisible() {
        labxA.setVisible(true);
        labxB.setVisible(true);
        labyA.setVisible(true);
        labyB.setVisible(true);
        textxA.setVisible(true);
        textxB.setVisible(true);
        textyA.setVisible(true);
        textyB.setVisible(true);
        ulabxA.setVisible(true);
        ulabxB.setVisible(true);
        ulabyA.setVisible(true);
        ulabyB.setVisible(true);
        sliderxA.setVisible(true);
        sliderxB.setVisible(true);
        slideryA.setVisible(true);
        slideryB.setVisible(true);

	labzA.setVisible(false);
	labzB.setVisible(false);
        labThetaA.setVisible(false);
        labThetaB.setVisible(false);
	textzA.setVisible(false);
	textzB.setVisible(false);
	textThetaA.setVisible(false);
	textThetaB.setVisible(false);
	ulabzA.setVisible(false);
	ulabzB.setVisible(false);
	ulabThetaA.setVisible(false);
	ulabThetaB.setVisible(false);
	sliderzA.setVisible(false);
	sliderzB.setVisible(false);
	sliderThetaA.setVisible(false);
	sliderThetaB.setVisible(false);
        return;
    }



    public void initializePolarInputs() {
        state.zValA = Math.min(state.zValA,state.zMax);
	textzA.setText(""+MaestroA.rounder(state.zValA,2));
	textThetaA.setText(""+MaestroA.rounder(state.thetaValA,2));
	sliderzA.setValue((int)((state.zValA-state.zMin)*
                               ScrollMax/(state.zMax-state.zMin)));
	sliderThetaA.setValue((int)((state.thetaValA-state.thetaMin)*
                                   ScrollMax/(state.thetaMax-state.thetaMin)));

        state.zValB = Math.min(state.zValB,state.zMax);
	textzB.setText(""+MaestroA.rounder(state.zValB,2));
	textThetaB.setText(""+MaestroA.rounder(state.thetaValB,2));
	sliderzB.setValue((int)((state.zValB-state.zMin)*
                               ScrollMax/(state.zMax-state.zMin)));
	sliderThetaB.setValue((int)((state.thetaValB-state.thetaMin)*
                                   ScrollMax/(state.thetaMax-state.thetaMin)));
    }



    public void initializeRectInputs() {
	textxA.setText(""+MaestroA.rounder(state.xValA,2));
	textyA.setText(""+MaestroA.rounder(state.yValA,2));
	sliderxA.setValue((int)((state.xValA-state.xMin)*
                               ScrollMax/(state.xMax-state.xMin)));
	slideryA.setValue((int)((state.yValA-state.yMin)*
                               ScrollMax/(state.yMax-state.yMin)));

	textxB.setText(""+MaestroA.rounder(state.xValB,2));
	textyB.setText(""+MaestroA.rounder(state.yValB,2));
	sliderxB.setValue((int)((state.xValB-state.xMin)*
                               ScrollMax/(state.xMax-state.xMin)));
	slideryB.setValue((int)((state.yValB-state.yMin)*
                               ScrollMax/(state.yMax-state.yMin)));
    }



    
    public void paint(Graphics g){
        Graphics2D g2d = (Graphics2D)g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                             RenderingHints.VALUE_ANTIALIAS_ON);
        g.clearRect(0,0,getSize().width-1,getSize().height-1);
	
	//g.setColor(bgcolor.darker());
	//g.fillRect(0,getSize().height-2,getSize().width,2);
	//g.fillRect(getSize().width-2,0,2,getSize().height);
	//g.setColor(bgcolor.brighter());
	//g.fillRect(0,0,2,getSize().height-1);
	//g.fillRect(0,0,getSize().width-2,2);

        // label font: state.sanSerifFont.deriveFont(Font.BOLD,16F)
        // bold font: state.sanSerifFont.deriveFont(Font.BOLD,14F)
        // normal font: state.sanSerifFont.deriveFont(14F)
        g.setColor(Color.black);
        //g.setFont(labfont);
	//titlelabel.setBounds(20,5,50,18);
        //endingX = STR.displayString(titlelabel,g,20,5);
        //g.setFont(normalfont);
        //lab.setBounds(20,35,180,20);
        //endingX = STR.displayString(lab,g,20,35);
        g.setFont(boldfont);
        //vectrA.setBounds(20,77,50,18);
        //endingX = STR.displayString(vectrA,g,20,97);  // add 20 to y
        endingX = STR.displayString(vectrA,g,state.s20,state.s119);  // add 20+24(-2) to y
        //vectrB.setBounds(20,180,50,18);
        //endingX = STR.displayString(vectrB,g,20,200);  //    ""
        //endingX = STR.displayString(vectrB,g,20,252);  //add 70-18 to vpos
        endingX = STR.displayString(vectrB,g,state.s20,state.s257);  //add another 5 to vpos
        g.setFont(normalfont);
        //plotChoicesLab.setBounds(20,300,150,18);
        //endingX = STR.displayString(plotChoicesLab,g,20,300);
        //choiceAlab.setBounds(200,300,20,18);
        //endingX = STR.displayString(choiceAlab,g,200,315);
        //endingX = STR.displayString(choiceAlab,g,200,385);
        endingX = STR.displayString(choiceAlab,g,state.s220,state.s385);
        //choiceBlab.setBounds(200,320,20,18);
        //endingX = STR.displayString(choiceBlab,g,200,335);
        //endingX = STR.displayString(choiceBlab,g,200,405);
        endingX = STR.displayString(choiceBlab,g,state.s220,state.s405);
        //choiceAplusBlab.setBounds(200,340,20,18);
        //endingX = STR.displayString(choiceAplusBlab,g,200,355);
        //endingX = STR.displayString(choiceAplusBlab,g,200,425);
        endingX = STR.displayString(choiceAplusBlab,g,state.s220,state.s425);
        //choiceAminusBlab.setBounds(200,360,20,18);
        //endingX = STR.displayString(choiceAminusBlab,g,200,375);
        //endingX = STR.displayString(choiceAminusBlab,g,200,445);
        endingX = STR.displayString(choiceAminusBlab,g,state.s220,state.s445);

        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                             RenderingHints.VALUE_ANTIALIAS_ON);

        /*
        if (textzA.isVisible()) {
            //int vPosInit = 107, vPos, dvPos = 4, vHeight = 20; 
            //labzA.setBounds(20,vPos,80,vHeight);
            endingX = STR.displayString(labzA,g,20,107);
            //ulabzA.setBounds(180,vPos,40,vHeight);
            endingX = STR.displayString(ulabzA,g,180,107);
            //labThetaA.setBounds(20+column2,vPos,80,vHeight);    
            endingX = STR.displayString(labThetaA,g,240,107);
            //ulabThetaA.setBounds(180+column2,vPos,40,vHeight);  
            endingX = STR.displayString(ulabThetaA,g,400,107);
            
            //int vPosInit = 217, vPos, dvPos = 4, vHeight = 20; 
            //int column2 = 220;
            //labzB.setBounds(20,vPos,80,vHeight);
            endingX = STR.displayString(labzB,g,20,217);
            //ulabzB.setBounds(180,vPos,40,vHeight);
            endingX = STR.displayString(ulabzB,g,180,217);
            //labThetaB.setBounds(20+column2,vPos,80,vHeight);    
            endingX = STR.displayString(labThetaB,g,240,217);
            //ulabThetaB.setBounds(180+column2,vPos,40,vHeight);  
            endingX = STR.displayString(ulabThetaB,g,400,217);
        } else {
            //int vPosInit = 107, vPos, dvPos = 4, vHeight = 20; 
            //labxA.setBounds(20,vPos,80,vHeight);
            endingX = STR.displayString(labxA,g,20,107);
            //ulabxA.setBounds(180,vPos,40,vHeight);
            endingX = STR.displayString(ulabxA,g,180,107);
            //labyA.setBounds(20+column2,vPos,80,vHeight);    
            endingX = STR.displayString(labyA,g,240,107);
            //ulabyA.setBounds(180+column2,vPos,40,vHeight);  
            endingX = STR.displayString(ulabyA,g,400,107);

            //int vPosInit = 217, vPos, dvPos = 4, vHeight = 20; 
            //vPos = vPosInit;
            //labxB.setBounds(20,vPos,80,vHeight);
            endingX = STR.displayString(labxB,g,20,217);
            //ulabxB.setBounds(180,vPos,40,vHeight);
            endingX = STR.displayString(ulabxB,g,180,217);
            //labyB.setBounds(20+column2,vPos,80,vHeight);    
            endingX = STR.displayString(labyB,g,240,217);
            //ulabyB.setBounds(180+column2,vPos,40,vHeight);  
            endingX = STR.displayString(ulabyB,g,400,217);
        }
        */
	sliderxA.requestFocusInWindow();
	sliderxB.requestFocusInWindow();
	slideryA.requestFocusInWindow();
	slideryB.requestFocusInWindow();
	sliderzA.requestFocusInWindow();
	sliderzB.requestFocusInWindow();
	sliderThetaA.requestFocusInWindow();
	sliderThetaB.requestFocusInWindow();
    }


    public void readTextUpdateSlider(TextField textF, JSlider slider,
                                     double min, double max) {
        double value = 0;
        ignoreSliderAdjustment = true;
        try { if(Double.valueOf(textF.getText()).doubleValue()<=max &&
                 Double.valueOf(textF.getText()).doubleValue()>=min){
                value = Double.valueOf(textF.getText()).doubleValue();
                slider.setValue((int)(ScrollMax*(value-min)/(max-min)));
            } else if(Double.valueOf(textF.getText()).doubleValue()>max){
                  value = max;
                  textF.setText(""+max);
                  slider.setValue(ScrollMax);
              }
              else if(Double.valueOf(textF.getText()).doubleValue()<min){
                  value = min;
                  textF.setText(""+min);
                  slider.setValue(0);
              }
        } catch(NumberFormatException e){
            value =  0.0;
        }
        setStateValue(textF,value);

        if (textzA.isVisible()) calculateXandY();
        else calculateZandTheta();
        repaint();
    }


    private void setStateValue(TextField textF, double value) {
        if (textF == textzA) state.zValA = value;
        else if (textF == textzB) state.zValB = value;
        else if (textF == textThetaA) state.thetaValA = value;
        else if (textF == textThetaB) state.thetaValB = value;
        else if (textF == textxA) state.xValA = value;
        else if (textF == textxB) state.xValB = value;
        else if (textF == textyA) state.yValA = value;
        else if (textF == textyB) state.yValB = value;
    }
    

    
    public void OLDreadTextUpdateSliders() {
        //ignoreSliderAdjustment = true;
        try { if(Double.valueOf(textzA.getText()).doubleValue()<=state.zMax &&
                 Double.valueOf(textzA.getText()).doubleValue()>=state.zMin){
                state.zValA=Double.valueOf(textzA.getText()).doubleValue();
                sliderzA.setValue((int)(ScrollMax*(state.zValA-state.zMin)
                                       /(state.zMax-state.zMin)));
            } else if(Double.valueOf(textzA.getText()).doubleValue()>state.zMax){
                  state.zValA = state.zMax;
                  textzA.setText(""+state.zMax);
                  sliderzA.setValue(ScrollMax);
              }
              else if(Double.valueOf(textzA.getText()).doubleValue()<state.zMin){
                  state.zValA = state.zMin;
                  textzA.setText(""+state.zMin);
                  sliderzA.setValue(0);
              }
        } catch(NumberFormatException e){
            state.zValA =  0.0;
        }
        
        try { if(Double.valueOf(textzB.getText()).doubleValue()<=state.zMax &&
                 Double.valueOf(textzB.getText()).doubleValue()>=state.zMin){
                state.zValB=Double.valueOf(textzB.getText()).doubleValue();
                sliderzB.setValue((int)(ScrollMax*(state.zValB-state.zMin)
                                       /(state.zMax-state.zMin)));
            } else if(Double.valueOf(textzB.getText()).doubleValue()>state.zMax){
                  state.zValB = state.zMax;
                  textzB.setText(""+state.zMax);
                  sliderzB.setValue(ScrollMax);
              }
              else if(Double.valueOf(textzB.getText()).doubleValue()<state.zMin){
                  state.zValB = state.zMin;
                  textzB.setText(""+state.zMin);
                  sliderzB.setValue(0);
              }
        } catch(NumberFormatException e){
            state.zValB =  0.0;
        }


        try { if(Double.valueOf(textThetaA.getText()).doubleValue()<=state.thetaMax &&
                 Double.valueOf(textThetaA.getText()).doubleValue()>=state.thetaMin){
                state.thetaValA=Double.valueOf(textThetaA.getText()).doubleValue();
                sliderThetaA.setValue((int)(ScrollMax*(state.thetaValA-state.thetaMin)
                                       /(state.thetaMax-state.thetaMin)));
            } else if(Double.valueOf(textThetaA.getText()).doubleValue()>state.thetaMax){
                  state.thetaValA = state.thetaMax;
                  textThetaA.setText(""+state.thetaMax);
                  sliderThetaA.setValue(ScrollMax);
              }
              else if(Double.valueOf(textThetaA.getText()).doubleValue()<state.thetaMin){
                  state.thetaValA = state.thetaMin;
                  textThetaA.setText(""+state.thetaMin);
                  sliderThetaA.setValue(0);
              }
        } catch(NumberFormatException e){
            state.thetaValA =  0.0;
        }

        try { if(Double.valueOf(textThetaB.getText()).doubleValue()<=state.thetaMax &&
                 Double.valueOf(textThetaB.getText()).doubleValue()>=state.thetaMin){
                state.thetaValB=Double.valueOf(textThetaB.getText()).doubleValue();
                sliderThetaB.setValue((int)(ScrollMax*(state.thetaValB-state.thetaMin)
                                       /(state.thetaMax-state.thetaMin)));
            } else if(Double.valueOf(textThetaB.getText()).doubleValue()>state.thetaMax){
                  state.thetaValB = state.thetaMax;
                  textThetaB.setText(""+state.thetaMax);
                  sliderThetaB.setValue(ScrollMax);
              }
              else if(Double.valueOf(textThetaB.getText()).doubleValue()<state.thetaMin){
                  state.thetaValB = state.thetaMin;
                  textThetaB.setText(""+state.thetaMin);
                  sliderThetaB.setValue(0);
              }
        } catch(NumberFormatException e){
            state.thetaValB =  0.0;
        }

                
        try { if(Double.valueOf(textxA.getText()).doubleValue()<=state.xMax &&
                 Double.valueOf(textxA.getText()).doubleValue()>=state.xMin){
                state.xValA=Double.valueOf(textxA.getText()).doubleValue();
                sliderxA.setValue((int)(ScrollMax*(state.xValA-state.xMin)
                                       /(state.xMax-state.xMin)));
            } else if(Double.valueOf(textxA.getText()).doubleValue()>state.xMax){
                  state.xValA = state.xMax;
                  textxA.setText(""+state.xMax);
                  sliderxA.setValue(ScrollMax);
              }
              else if(Double.valueOf(textxA.getText()).doubleValue()<state.xMin){
                  state.xValA = state.xMin;
                  textxA.setText(""+state.xMin);
                  sliderxA.setValue(0);
              }
        } catch(NumberFormatException e){
            state.xValA =  0.0;
        }
                
        try { if(Double.valueOf(textxB.getText()).doubleValue()<=state.xMax &&
                 Double.valueOf(textxB.getText()).doubleValue()>=state.xMin){
                state.xValB=Double.valueOf(textxB.getText()).doubleValue();
                sliderxB.setValue((int)(ScrollMax*(state.xValB-state.xMin)
                                       /(state.xMax-state.xMin)));
            } else if(Double.valueOf(textxB.getText()).doubleValue()>state.xMax){
                  state.xValB = state.xMax;
                  textxB.setText(""+state.xMax);
                  sliderxB.setValue(ScrollMax);
              }
              else if(Double.valueOf(textxB.getText()).doubleValue()<state.xMin){
                  state.xValB = state.xMin;
                  textxB.setText(""+state.xMin);
                  sliderxB.setValue(0);
              }
        } catch(NumberFormatException e){
            state.xValB =  0.0;
        }


        try { if(Double.valueOf(textyA.getText()).doubleValue()<=state.yMax &&
                 Double.valueOf(textyA.getText()).doubleValue()>=state.yMin){
                state.yValA=Double.valueOf(textyA.getText()).doubleValue();
                slideryA.setValue((int)(ScrollMax*(state.yValA-state.yMin)
                                       /(state.yMax-state.yMin)));
            } else if(Double.valueOf(textyA.getText()).doubleValue()>state.yMax){
                  state.yValA = state.yMax;
                  textyA.setText(""+state.yMax);
                  slideryA.setValue(ScrollMax);
              }
              else if(Double.valueOf(textyA.getText()).doubleValue()<state.yMin){
                  state.yValA = state.yMin;
                  textyA.setText(""+state.yMin);
                  slideryA.setValue(0);
              }
        } catch(NumberFormatException e){
            state.yValA =  0.0;
        }

        try { if(Double.valueOf(textyB.getText()).doubleValue()<=state.yMax &&
                 Double.valueOf(textyB.getText()).doubleValue()>=state.yMin){
                state.yValB=Double.valueOf(textyB.getText()).doubleValue();
                slideryB.setValue((int)(ScrollMax*(state.yValB-state.yMin)
                                       /(state.yMax-state.yMin)));
            } else if(Double.valueOf(textyB.getText()).doubleValue()>state.yMax){
                  state.yValB = state.yMax;
                  textyB.setText(""+state.yMax);
                  slideryB.setValue(ScrollMax);
              }
              else if(Double.valueOf(textyB.getText()).doubleValue()<state.yMin){
                  state.yValB = state.yMin;
                  textyB.setText(""+state.yMin);
                  slideryB.setValue(0);
              }
        } catch(NumberFormatException e){
            state.yValB =  0.0;
        }
        

        if (textzA.isVisible()) calculateXandY();
        else calculateZandTheta();
        repaint();
    }

    
    public void stateChanged(ChangeEvent evt){//NEED HERE
        if (ignoreSliderAdjustment) {
            ignoreSliderAdjustment = false;
            // BUT don't want to remove event, so Mod1 can still see it,
            //  and draw the plot and display the output
            return;
        }

        if (evt.getSource()==sliderzA) {
            if(sliderzA.getValue()>=ScrollMax){
                state.zValA=state.zMax;
                sliderzA.setValue((int)((state.zValA-state.zMin)*
                                       ScrollMax/(state.zMax-state.zMin)));
	    } else {
		state.zValA = state.zMin + 
		    (state.zMax-state.zMin)*
                    sliderzA.getValue()/ScrollMax;
                state.zValA = MaestroA.rounder(state.zValA,2);
	    }
            
	    textzA.setText(""+MaestroA.rounder(state.zValA,2));
	    calculateXandY();
        } else if (evt.getSource()==sliderzB) {
            if(sliderzB.getValue()>=ScrollMax){
                state.zValB=state.zMax;
                sliderzB.setValue((int)((state.zValB-state.zMin)*
                                       ScrollMax/(state.zMax-state.zMin)));
	    } else {
		state.zValB = state.zMin + 
		    (state.zMax-state.zMin)*
                    sliderzB.getValue()/ScrollMax;
                state.zValB = MaestroA.rounder(state.zValB,2);
	    }
            
	    textzB.setText(""+MaestroA.rounder(state.zValB,2));
	    calculateXandY();

        } else if (evt.getSource()==sliderThetaA) {
            if(sliderThetaA.getValue()>=ScrollMax){
                state.thetaValA=state.thetaMax;
                sliderThetaA.setValue((int)((state.thetaValA-state.thetaMin)*
                                       ScrollMax/(state.thetaMax-state.thetaMin)));
	    } else {
		state.thetaValA = state.thetaMin + 
		    (state.thetaMax-state.thetaMin)*
                    sliderThetaA.getValue()/ScrollMax;
                state.thetaValA = MaestroA.rounder(state.thetaValA,2);
	    }
            
	    textThetaA.setText(""+MaestroA.rounder(state.thetaValA,2));
	    calculateXandY();
        } else if (evt.getSource()==sliderThetaB) {
            if(sliderThetaB.getValue()>=ScrollMax){
                state.thetaValB=state.thetaMax;
                sliderThetaB.setValue((int)((state.thetaValB-state.thetaMin)*
                                       ScrollMax/(state.thetaMax-state.thetaMin)));
	    } else {
		state.thetaValB = state.thetaMin + 
		    (state.thetaMax-state.thetaMin)*
                    sliderThetaB.getValue()/ScrollMax;
                state.thetaValB = MaestroA.rounder(state.thetaValB,2);
	    }
            
	    textThetaB.setText(""+MaestroA.rounder(state.thetaValB,2));
	    calculateXandY();

        } else if (evt.getSource()==sliderxA) {
	    if (sliderxA.getValue()>=ScrollMax) {
                state.xValA=state.xMax;
                sliderxA.setValue((int)((state.xValA-state.xMin)*
                                       ScrollMax/(state.xMax-state.xMin)));
	    } else {
                state.xValA = state.xMin + 
                    (state.xMax-state.xMin)*
                    sliderxA.getValue()/ScrollMax;
	    }
            
	    textxA.setText(""+MaestroA.rounder(state.xValA,2));
	    calculateZandTheta();
        } else if (evt.getSource()==sliderxB) {
	    if (sliderxB.getValue()>=ScrollMax) {
                state.xValB=state.xMax;
                sliderxB.setValue((int)((state.xValB-state.xMin)*
                                       ScrollMax/(state.xMax-state.xMin)));
	    } else {
                state.xValB = state.xMin + 
                    (state.xMax-state.xMin)*
                    sliderxB.getValue()/ScrollMax;
	    }
            
	    textxB.setText(""+MaestroA.rounder(state.xValB,2));
	    calculateZandTheta();

	} else if (evt.getSource()==slideryA) {
	    if(slideryA.getValue()>=ScrollMax) {
                state.yValA=state.yMax;
                slideryA.setValue((int)((state.yValA-state.yMin)*
                                       ScrollMax/(state.yMax-state.yMin)));
	    } else {
		state.yValA = state.yMin + 
		    (state.yMax-state.yMin)*
                    slideryA.getValue()/ScrollMax;
	    }
            
	    textyA.setText(""+MaestroA.rounder(state.yValA,2));
	    calculateZandTheta();
        } else if (evt.getSource()==slideryB) {
	    if(slideryB.getValue()>=ScrollMax) {
                state.yValB=state.yMax;
                slideryB.setValue((int)((state.yValB-state.yMin)*
                                       ScrollMax/(state.yMax-state.yMin)));
	    } else {
		state.yValB = state.yMin + 
		    (state.yMax-state.yMin)*
                    slideryB.getValue()/ScrollMax;
	    }
            
	    textyB.setText(""+MaestroA.rounder(state.yValB,2));
	    calculateZandTheta();
        }
    }


    public void calculateXandY() {
        state.xValA = state.zValA*Math.cos(piOver180*state.thetaValA);
        state.xValB = state.zValB*Math.cos(piOver180*state.thetaValB);
        state.yValA = state.zValA*Math.sin(piOver180*state.thetaValA);
        state.yValB = state.zValB*Math.sin(piOver180*state.thetaValB);
    }



    public void calculateZandTheta() {
        state.zValA = Math.sqrt((1.0*state.xValA*state.xValA)+
                          (state.yValA*state.yValA));
        state.zValB = Math.sqrt((1.0*state.xValB*state.xValB)+
                          (state.yValB*state.yValB));
        state.thetaValA = Math.atan2(state.yValA,state.xValA)/piOver180;
        state.thetaValB = Math.atan2(state.yValB,state.xValB)/piOver180;
    }
 
}



class MiniCanvas extends Canvas{
    Mod1State state;
    Color bgcolor;
    private char graphType;
    private int endingX;
    private Image im;
    private Graphics buf;
    //private static double arrowLengthLimit = 1.5;
    private static double arrowLengthLimit = 1.0;

    public MiniCanvas(Mod1State state, Color bgcolor, char graphType){
        super();
        this.state = state;
        this.bgcolor = bgcolor;
        this.graphType = graphType;
    }
    
    public void paint(Graphics g){
        if(im == null){
            im = createImage(getSize().width,getSize().height);
            buf = im.getGraphics();
            drawCanvas(buf);
        }
        else{
            drawCanvas(buf);
        }
        g.drawImage(im,0,0,null);
    }
    
    //Addition to reduce flicker new routine
    public void update(Graphics g){		// added to avoid clearing
        paint(g);
    }
    
    public void clear(){
        this.getGraphics().clearRect(0,0,getSize().width,getSize().height);
        repaint();
    }

    public void drawCanvas(Graphics g){
        Graphics2D g2d = (Graphics2D)g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                             RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(bgcolor);
        //g.fillRect(0,0,getSize().width,getSize().height);
        g.fillRect(0,0,state.s90,state.s90);

        // NOTE: assuming width and height are 60
        // Draw the axes:
        g.setColor(Color.black);
        g.drawLine(0,state.s45,state.s90,state.s45); // x Axis
        g.drawLine(state.s45,0,state.s45,state.s90); // y Axis

        // Now draw mini vectors
        // NOTE that there are 9 pixels per 1.0 vector length
        if (graphType == 'A') {
            g.setColor(Color.red);
            g.drawLine(state.s45,state.s45,state.s45+(int)(state.xValA*9),
                               state.s45-(int)(state.yValA*9));
            if (Math.abs(state.xValA) >= arrowLengthLimit ||
                Math.abs(state.yValA) >= arrowLengthLimit){
                
                drawMiniArrowHead(g,state.s45,state.s45,state.s45+(int)(state.xValA*9),
                                  state.s45-(int)(state.yValA*9));
            }
        } 
        else {
            g.setColor(Color.blue);
            g.drawLine(state.s45,state.s45,state.s45+(int)(state.xValB*9),
                       state.s45-(int)(state.yValB*9));
            if (Math.abs(state.xValB) >= arrowLengthLimit ||
                Math.abs(state.yValB) >= arrowLengthLimit){
                
                drawMiniArrowHead(g,state.s45,state.s45,state.s45+(int)(state.xValB*9),
                                  state.s45-(int)(state.yValB*9));
            }
        }
    }

        
    /*
    public void drawCanvas(Graphics g){
        Graphics2D g2d = (Graphics2D)g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                             RenderingHints.VALUE_ANTIALIAS_ON);
        g.setColor(bgcolor);
        //g.fillRect(0,0,getSize().width,getSize().height);
        g.fillRect(0,0,60,60);

        // NOTE: assuming width and height are 60
        // Draw the axes:
        g.setColor(Color.black);
        g.drawLine(0,30,60,30); // x Axis
        g.drawLine(30,0,30,60); // y Axis

        // Now draw mini vectors
        // NOTE that there are 6 pixels per 1.0 vector length
        if (graphType == 'A') {
            g.setColor(Color.red);
            g.drawLine(30,30,30+(int)(state.xValA*6),
                               30-(int)(state.yValA*6));
            if (Math.abs(state.xValA) >= arrowLengthLimit ||
                Math.abs(state.yValA) >= arrowLengthLimit)
                drawMiniArrowHead(g,30,30,30+(int)(state.xValA*6),
                                  30-(int)(state.yValA*6));
        } else {
            g.setColor(Color.blue);
            g.drawLine(30,30,30+(int)(state.xValB*6),
                       30-(int)(state.yValB*6));
            if (Math.abs(state.xValB) >= arrowLengthLimit ||
                Math.abs(state.yValB) >= arrowLengthLimit)
                drawMiniArrowHead(g,30,30,30+(int)(state.xValB*6),
                                  30-(int)(state.yValB*6));
        }
    }
    */
    private void drawMiniArrowHead(Graphics g, int x1, int y1, int x2, int y2) {
        Point[] arrowPts = MyArrows.getArrowHeadPts(x2, y2, x1, y1, state.sfactor);
        int[] arrowXPts = new int[3];
        int[] arrowYPts = new int[3];
        arrowXPts[0] = arrowPts[0].x; arrowYPts[0] = arrowPts[0].y;
        arrowXPts[1] = arrowPts[1].x; arrowYPts[1] = arrowPts[1].y;
        arrowXPts[2] = arrowPts[2].x; arrowYPts[2] = arrowPts[2].y;
        g.fillPolygon(arrowXPts,arrowYPts,3);
    }
}
