//LinearApplet.java

import java.util.*;
import java.text.*; 
import java.awt.*;
import java.awt.event.*;   
import javax.swing.*;
import javax.swing.border.*;

public class LinearApplet extends JApplet implements ActionListener, ItemListener {
                            
    JLabel xLowLabel, xHighLabel, yLowLabel, yHighLabel, tickIntLabel;
    JTextField 	xLowField, xHighField, yLowField, yHighField, tickIntField;
    JLabel[] mLabels, bLabels, zeroLabels, x1Labels, y1Labels, x2Labels, y2Labels;
    JTextField[] mFields, bFields, zeroFields, x1Fields, y1Fields, x2Fields, y2Fields;
    JRadioButton intersectionsRadioButton;
    JRadioButton[][] choiceRadios; 
    ButtonGroup[] choiceRadioGroups;
    String lineChoice[];
    JButton zoomInButton, zoomOutButton;
    
    public final int MaxNumLines=5;
    Linear[] linearArray;  //array of Linear objects 
    Color colors[] = {Color.BLUE,Color.RED,Color.GREEN,Color.CYAN,Color.MAGENTA,
	              Color.PINK,Color.YELLOW,Color.ORANGE}; 
        
//    double m, b;
    double xLo, xHi, yLo, yHi, tickInt, scale;
    boolean showIntersections=true;
    DecimalFormat d2;
    public final int westPanelWidth=250;

    public void init() {  

	d2 = new DecimalFormat ("0.00");

	Container container = getContentPane();  
	container.setLayout(null);   //** no Layout Manager	
	
	JPanel gridParamsPanel = new JPanel();  //graph parameters
	//Box gridParamsPanelLabels = new Box(BoxLayout.Y_AXIS);
	//Box gridParamsPanelFields = new Box(BoxLayout.Y_AXIS);
	gridParamsPanel.setLayout( new GridLayout(5,2) ); 
	gridParamsPanel.setBackground(Color.PINK);
	gridParamsPanel.setBounds(westPanelWidth-100,getHeight()-100, 100,100);
	gridParamsPanel.setBorder(BorderFactory.createEtchedBorder(EtchedBorder.RAISED));
	//gridParamsPanelLabels.setBounds(0,getHeight()-100, 50,100);
	//gridParamsPanelFields.setBounds(50,getHeight()-100, 50,100);
	//container.add(gridParamsPanelLabels);
	//container.add(gridParamsPanelFields);
	container.add(gridParamsPanel);

	JPanel westPanel = new JPanel();
	//westPanel.setLayout( new GridLayout(10,4) ); 
	westPanel.setBackground(Color.LIGHT_GRAY);
	westPanel.setBounds(0,0, westPanelWidth,getHeight()-200);
	container.add(westPanel);
	//container.add(westPanel,BorderLayout.WEST);

	JPanel miscPanel = new JPanel();
	miscPanel.setBackground(Color.YELLOW);
	miscPanel.setBounds(0,getHeight()-200, westPanelWidth,200);
	container.add(miscPanel);
	
	Box[] lineBoxes = new Box[MaxNumLines];
	Box[] pointsBoxes = new Box[MaxNumLines];
	Box[] choiceBoxes = new Box[MaxNumLines];
	mLabels = new JLabel[MaxNumLines];
	bLabels = new JLabel[MaxNumLines];
	zeroLabels = new JLabel[MaxNumLines];
	mFields = new JTextField[MaxNumLines];
	bFields = new JTextField[MaxNumLines];
	zeroFields = new JTextField[MaxNumLines];
	x1Labels = new JLabel[MaxNumLines];
	y1Labels = new JLabel[MaxNumLines];
	x2Labels = new JLabel[MaxNumLines];
	y2Labels = new JLabel[MaxNumLines];
	x1Fields = new JTextField[MaxNumLines];
	y1Fields = new JTextField[MaxNumLines];
	x2Fields = new JTextField[MaxNumLines];
	y2Fields = new JTextField[MaxNumLines];
	choiceRadios = new JRadioButton[MaxNumLines][];
	for (int i=0; i<MaxNumLines; i++)
	    choiceRadios[i] = new JRadioButton[3];
	choiceRadioGroups = new ButtonGroup[MaxNumLines];
	lineChoice = new String[MaxNumLines];
	linearArray = new Linear[MaxNumLines];
	
	for (int i=0; i<MaxNumLines; i++) {
	    choiceBoxes[i] = new Box(BoxLayout.X_AXIS);
	    westPanel.add(choiceBoxes[i]);
	    lineBoxes[i] = new Box(BoxLayout.X_AXIS);
	    //lineBoxes[i].setBackground(Color.MAGENTA);  //box has no background??
	    westPanel.add(lineBoxes[i]);
	    pointsBoxes[i] = new Box(BoxLayout.X_AXIS);
	    westPanel.add(pointsBoxes[i]);

	    choiceRadios[i][0] = new JRadioButton( "m b" );
	    choiceRadios[i][0].setBackground(colors[i]);
	    choiceBoxes[i].add( choiceRadios[i][0] );
	    choiceRadios[i][0].addItemListener( this ); 

	    choiceRadios[i][1] = new JRadioButton( "point-slope" );
	    choiceRadios[i][1].setBackground(colors[i]);
	    choiceBoxes[i].add( choiceRadios[i][1] );
	    choiceRadios[i][1].addItemListener( this ); 

	    choiceRadios[i][2] = new JRadioButton( "2 points" );
	    choiceRadios[i][2].setBackground(colors[i]);
	    choiceBoxes[i].add( choiceRadios[i][2] );
	    choiceRadios[i][2].addItemListener( this ); 
	
	    choiceRadioGroups[i] = new ButtonGroup();
	    choiceRadioGroups[i].add(choiceRadios[i][0]);
	    choiceRadioGroups[i].add(choiceRadios[i][1]);
	    choiceRadioGroups[i].add(choiceRadios[i][2]);

	    mLabels[i] = new JLabel( "m" );
	    mLabels[i].setForeground(colors[i]);
	    lineBoxes[i].add( mLabels[i] );
	    mFields[i] = new JTextField( "",3 );
	    mFields[i].setHorizontalAlignment(JTextField.RIGHT);
	    mFields[i].setEditable(false);
	    mFields[i].addActionListener( this );
	    lineBoxes[i].add( mFields[i] );
	
	    bLabels[i] = new JLabel( "  b" );
	    bLabels[i].setForeground(colors[i]);
	    lineBoxes[i].add( bLabels[i] );
	    bFields[i] = new JTextField( "",3 );
	    bFields[i].setHorizontalAlignment(JTextField.RIGHT);
	    bFields[i].setEditable(false);
	    bFields[i].addActionListener( this );
	    lineBoxes[i].add( bFields[i] );

	    zeroLabels[i] = new JLabel( "  zero" );
	    zeroLabels[i].setForeground(colors[i]);
	    lineBoxes[i].add( zeroLabels[i] );
	    zeroFields[i] = new JTextField( "",3 );
	    zeroFields[i].setHorizontalAlignment(JTextField.RIGHT);
	    zeroFields[i].setEditable(false);
	    zeroFields[i].addActionListener( this );
	    lineBoxes[i].add( zeroFields[i] );

	    x1Labels[i] = new JLabel( "x1" );
	    x1Labels[i].setForeground(colors[i]);
	    pointsBoxes[i].add( x1Labels[i] );
	    x1Fields[i] = new JTextField( "",3 );
	    x1Fields[i].setHorizontalAlignment(JTextField.RIGHT);
	    x1Fields[i].setEditable(false);   
	    x1Fields[i].addActionListener( this );
	    pointsBoxes[i].add( x1Fields[i] );

	    y1Labels[i] = new JLabel( "y1" );
	    y1Labels[i].setForeground(colors[i]);
	    pointsBoxes[i].add( y1Labels[i] );
	    y1Fields[i] = new JTextField( "",3 );
	    y1Fields[i].setHorizontalAlignment(JTextField.RIGHT);
	    y1Fields[i].setEditable(false);
	    y1Fields[i].addActionListener( this );
	    pointsBoxes[i].add( y1Fields[i] );

	    x2Labels[i] = new JLabel( "x2" );
	    x2Labels[i].setForeground(colors[i]);
	    pointsBoxes[i].add( x2Labels[i] );
	    x2Fields[i] = new JTextField( "",3 );
	    x2Fields[i].setHorizontalAlignment(JTextField.RIGHT);
	    x2Fields[i].setEditable(false);
	    x2Fields[i].addActionListener( this );
	    pointsBoxes[i].add( x2Fields[i] );

	    y2Labels[i] = new JLabel( "y2" );
	    y2Labels[i].setForeground(colors[i]);
	    pointsBoxes[i].add( y2Labels[i] );
	    y2Fields[i] = new JTextField( "",3 );
	    y2Fields[i].setHorizontalAlignment(JTextField.RIGHT);
	    y2Fields[i].setEditable(false);
	    y2Fields[i].addActionListener( this );
	    pointsBoxes[i].add( y2Fields[i] );
	}
	//first one, identity function
	mFields[0].setText("1");
	bFields[0].setText("0");
	zeroFields[0].setText("0");
	x1Fields[0].setText("0");
	y1Fields[0].setText("0");
	x2Fields[0].setText("1");
	y2Fields[0].setText("1");
	//x1Fields[0].setEditable(true);
	//y1Fields[0].setEditable(true);
	//x2Fields[0].setEditable(true);
	//y2Fields[0].setEditable(true);
	choiceRadios[0][0].setSelected(true);
	lineChoice[0] = "mb";
	mFields[0].setEditable(true);
	bFields[0].setEditable(true);
	//create a Linear object
	linearArray[0] = new Linear(Double.parseDouble(mFields[0].getText()),
	                            Double.parseDouble(bFields[0].getText()));

	zoomInButton = new JButton( "Zoom IN" );
	miscPanel.add( zoomInButton );
	zoomInButton.addActionListener( this );
	
	zoomOutButton = new JButton( "Zoom OUT" );
	miscPanel.add( zoomOutButton );
	zoomOutButton.addActionListener( this );

	intersectionsRadioButton = new JRadioButton( " Show intersections " , true);
	intersectionsRadioButton.setBackground(Color.RED);
	miscPanel.add( intersectionsRadioButton );
	intersectionsRadioButton.addItemListener( this ); 
	

	xLowLabel = new JLabel( "X low" );
	//gridParamsPanelLabels.add( xLowLabel );
	gridParamsPanel.add( xLowLabel );
	xLowField = new JTextField( "-7",3 );
	xLo = Double.parseDouble(xLowField.getText());
	xLowField.setHorizontalAlignment(JTextField.RIGHT);
	xLowField.setBackground(Color.PINK);
	xLowField.addActionListener( this );
	//gridParamsPanelFields.add( xLowField );
	gridParamsPanel.add( xLowField );
	
	xHighLabel = new JLabel( "X high" );
	//gridParamsPanelLabels.add( xHighLabel );
	gridParamsPanel.add( xHighLabel );
	xHighField = new JTextField( "7",3 );
	xHi = Double.parseDouble(xHighField.getText());
	xHighField.setHorizontalAlignment(JTextField.RIGHT);
	xHighField.setBackground(Color.PINK);
	xHighField.addActionListener( this );
	//gridParamsPanelFields.add( xHighField );
	gridParamsPanel.add( xHighField );
	
	yLowLabel = new JLabel( "Y low" );
	//gridParamsPanelLabels.add( yLowLabel );
	gridParamsPanel.add( yLowLabel );
	yLowField = new JTextField( "-5",3 );
	yLo = Double.parseDouble(yLowField.getText());
	yLowField.setHorizontalAlignment(JTextField.RIGHT);
	yLowField.setBackground(Color.PINK);
	yLowField.addActionListener( this );
	//gridParamsPanelFields.add( yLowField );
	gridParamsPanel.add( yLowField );
	
	yHighLabel = new JLabel( "Y high" );
	//gridParamsPanelLabels.add( yHighLabel );
	gridParamsPanel.add( yHighLabel );
	yHighField = new JTextField( "5",3 );
	yHi = Double.parseDouble(yHighField.getText());
	yHighField.setHorizontalAlignment(JTextField.RIGHT);
	yHighField.setBackground(Color.PINK);
	yHighField.addActionListener( this );
	//gridParamsPanelFields.add( yHighField );
	gridParamsPanel.add( yHighField );
	
	tickIntLabel = new JLabel( "Ticks" );
	//gridParamsPanelLabels.add( tickIntLabel );
	gridParamsPanel.add( tickIntLabel );
	tickIntField = new JTextField( "1",2 );
	tickInt = Double.parseDouble(tickIntField.getText());
	tickIntField.setHorizontalAlignment(JTextField.RIGHT);
	tickIntField.setBackground(Color.PINK);
	tickIntField.addActionListener( this );
	//gridParamsPanelFields.add( tickIntField );
	gridParamsPanel.add( tickIntField );
	
    }


    public void actionPerformed( ActionEvent event ) {

	int i;
	double xLoTry,
	     xHiTry, 
	     yLoTry,
	     yHiTry,
	     tickIntTry,
	     mTry, bTry,
	     x1Try, y1Try, x2Try, y2Try;
	double m, b, x1, y1, x2, y2;
	    
    	if ( event.getSource()==xLowField ||
    	     event.getSource()==xHighField ||
    	     event.getSource()==yLowField ||
    	     event.getSource()==yHighField ||
    	     event.getSource()==tickIntField ) {

	    try {
	        xLoTry = Double.parseDouble(xLowField.getText());
	        xHiTry = Double.parseDouble(xHighField.getText());
	        yLoTry = Double.parseDouble(yLowField.getText());
	        yHiTry = Double.parseDouble(yHighField.getText());
	        tickIntTry = Double.parseDouble(tickIntField.getText());
	    }
	    catch (NumberFormatException e) {
	        JOptionPane.showMessageDialog(null,
					  "Plotting coordinates must be numbers",
					  "Linear plotting: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	        return;
	    }

	    if (xLoTry>xHiTry || yLoTry>yHiTry || tickIntTry<=0) {
	        JOptionPane.showMessageDialog(null,
					  "Bad plotting coordinates",
					  "Linear plotting: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	        return;
	    }
	    xLo = xLoTry;
	    xHi = xHiTry;
	    yLo = yLoTry;
            yHi = yHiTry;
            tickInt = tickIntTry;
		
	    repaint();
        }
	else if ( event.getSource() == zoomInButton ) {
	    scale = .9;   //shrink the grid by 10%
	    xLo *= scale;
	    xHi *= scale;
	    yLo *= scale;
	    yHi *= scale;
	    xLowField.setText(""+d2.format(xLo));
	    xHighField.setText(""+d2.format(xHi));
	    yLowField.setText(""+d2.format(yLo));
	    yHighField.setText(""+d2.format(yHi));
	    repaint();    
	}
	else if ( event.getSource() == zoomOutButton ) {
	    scale = 1.1;   //grow the grid by 10%
	    xLo *= scale;
	    xHi *= scale;
	    yLo *= scale;
	    yHi *= scale;
	    xLowField.setText(""+d2.format(xLo));
	    xHighField.setText(""+d2.format(xHi));
	    yLowField.setText(""+d2.format(yLo));
	    yHighField.setText(""+d2.format(yHi));
	    repaint();    
	}
	else {
	    //loop to find which textfield sent event... ??is there a better way?
	    i = 0;
	    while (i<MaxNumLines && event.getSource()!=mFields[i] && event.getSource()!=bFields[i])
	    	i++;
	    if (i<MaxNumLines) { //found an m or b
	        //if (event.getSource()==mFields[i] || event.getSource()==bFields[i]) {
	            if (event.getSource()==mFields[i]) {  //it's the m
	               try {
	                   mTry = Double.parseDouble(mFields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "m and b must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               if (lineChoice[i].equals("mb"))
	                   if (linearArray[i]==null)
	                       if (!bFields[i].getText().equals("")) {
	                           b = Double.parseDouble(bFields[i].getText());
	                           linearArray[i] = new Linear(mTry,b);
		                   zeroFields[i].setText(""+linearArray[i].zero);
	                       }
	                       else //b is still empty
	                           return;
	                   else {   //line already exists.  change it's m and zero
	                       linearArray[i].m = mTry;
	                       linearArray[i].zero = -linearArray[i].b/mTry;
		               zeroFields[i].setText(""+linearArray[i].zero);
	                   }

	               else if (lineChoice[i].equals("ps"))  //only other choice
	                   if (!x1Fields[i].getText().equals("") &&
	                       !y1Fields[i].getText().equals("")) {
	                       m = Double.parseDouble(mFields[i].getText());
	                       x1 = Double.parseDouble(x1Fields[i].getText());
	                       y1 = Double.parseDouble(y1Fields[i].getText());
	                       linearArray[i] = new Linear(m,x1,y1);
		               bFields[i].setText(""+linearArray[i].b); 
		               zeroFields[i].setText(""+linearArray[i].zero);     
	                       //repaint();
	                   }
	                   else
	                       return;  //if either or both x1 and y1 empty
	           }
	           else if (event.getSource()==bFields[i]) {  //it's the b.  'if' not needed
	               try {
	                   bTry = Double.parseDouble(bFields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "m and b must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               if (linearArray[i] == null) 
/*	                   linearArray[i] = new Linear(0,bTry);   //start with m=0
		           mFields[i].setText(""+linearArray[i].m); //0
	               }
	               else {
	                   linearArray[i].b = bTry;
	                   linearArray[i].zero = -bTry/linearArray[i].m;
	               }*/
	                    if (!mFields[i].getText().equals("")) {   //m exists
	                       m = Double.parseDouble(mFields[i].getText());
	                       linearArray[i] = new Linear(m,bTry);
		               zeroFields[i].setText(""+linearArray[i].zero);
	                    }
	                    else //m is still empty
	                       return;
	                else {   //line already exists.  change it's b and zero
	                    linearArray[i].b = bTry;
	                    linearArray[i].zero = -bTry/linearArray[i].m;
		            zeroFields[i].setText(""+linearArray[i].zero);
	                }
	                   
	                   
	           }
		   //common to m or b
		   //zeroFields[i].setText(""+d2.format(linearArray[i].zero));
		   if (lineChoice[i].equals("mb")) {
		       x1Fields[i].setText("0");
		       y1Fields[i].setText(""+d2.format(linearArray[i].b));
		   }
		   if (linearArray[i].m != 0) //not horizontal line
		       if (linearArray[i].zero != 0) {  //not thru origin
 		           x2Fields[i].setText(""+d2.format(linearArray[i].zero));
		           y2Fields[i].setText("0");
		       }
		       else {   //thru origin, so use (1,m+b)
		           x2Fields[i].setText("1");
		           y2Fields[i].setText(""+d2.format(linearArray[i].m+linearArray[i].b));
		       }
		   else {   //horizontal. so use (1,b)
		       x2Fields[i].setText("1");
		       y2Fields[i].setText(""+d2.format(linearArray[i].b));
		   }
	           repaint();
	    }
	    
	    else {   //Not m or b, so might (must?) be one of the point's coords
	             //radio choice can be either point-slope (ps) or 2points (2p)
		i=0;
	        while (i<MaxNumLines && event.getSource()!=x1Fields[i] && 
	        	                event.getSource()!=y1Fields[i] &&
	        	                event.getSource()!=x2Fields[i] &&
	        	                event.getSource()!=y2Fields[i])
	    	    i++;
	        if (i<MaxNumLines) {//found an x1, y1, x2 or y2
	            if (event.getSource()==x1Fields[i]) {  //it's the x1
	               try {
	                   x1Try = Double.parseDouble(x1Fields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "x's and y's must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               //
	            }
	            else if (event.getSource()==y1Fields[i]) {  //it's the y1
	               try {
	                   y1Try = Double.parseDouble(y1Fields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "x's and y's must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               //
	            }
	            else if (event.getSource()==x2Fields[i]) {  //it's the x2
	               try {
	                   x2Try = Double.parseDouble(x2Fields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "x's and y's must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               //
	            }
	            else if (event.getSource()==y2Fields[i]) {  //it's the y2
	               try {
	                   y2Try = Double.parseDouble(y2Fields[i].getText());
	               }
	               catch (NumberFormatException e) {
	                   JOptionPane.showMessageDialog(null,
					  "x's and y's must be numbers",
					  "Linear: Invalid input",
					  JOptionPane.ERROR_MESSAGE);
	                   return;
	               }
	               //
	            }
	            //
	            if (!x1Fields[i].getText().equals("") &&
	            	!y1Fields[i].getText().equals("") &&
	            	!x2Fields[i].getText().equals("") &&
	            	!y2Fields[i].getText().equals("") &&
	            	lineChoice[i].equals("2p")) {  //all 4 coords not empty
	                x1 = Double.parseDouble(x1Fields[i].getText());
	                y1 = Double.parseDouble(y1Fields[i].getText());
	                x2 = Double.parseDouble(x2Fields[i].getText());
	                y2 = Double.parseDouble(y2Fields[i].getText());
		        linearArray[i] = new Linear(x1,y1,x2,y2);
		        mFields[i].setText(""+linearArray[i].m); 
		        bFields[i].setText(""+linearArray[i].b); 
		        zeroFields[i].setText(""+linearArray[i].zero);     
	                repaint();
	            }
		    else if (!x1Fields[i].getText().equals("") &&
	            	     !y1Fields[i].getText().equals("") &&
	            	     lineChoice[i].equals("ps")) {
		        
	                x1 = Double.parseDouble(x1Fields[i].getText());
	                y1 = Double.parseDouble(y1Fields[i].getText());
			if (linearArray[i] != null) { //use the existing m
		            linearArray[i] = new Linear(linearArray[i].m,x1,y1);
		            bFields[i].setText(""+linearArray[i].b); 
		            zeroFields[i].setText(""+linearArray[i].zero);     
	                    //repaint();
		        }
		        else if (!mFields[i].getText().equals("")) { //m already entered but not yet used
	                    m = Double.parseDouble(mFields[i].getText());
		            linearArray[i] = new Linear(m,x1,y1);
		            bFields[i].setText(""+linearArray[i].b); 
		            zeroFields[i].setText(""+linearArray[i].zero);     
	                    //repaint();
		        }
		        else  // no m entered yet
		            return;
		        //now deal with the x2,y2
		       if (linearArray[i].m != 0) //not horizontal line
		           if (linearArray[i].zero != 0) {  //not thru origin
 		               x2Fields[i].setText(""+d2.format(linearArray[i].zero));
		               y2Fields[i].setText("0");
		           }
		           else {   //thru origin, so use (1,m+b)
		               x2Fields[i].setText("1");
		               y2Fields[i].setText(""+d2.format(linearArray[i].m+linearArray[i].b));
		           }
		       else {   //horizontal. so use (1,b)
		           x2Fields[i].setText("1");
		           y2Fields[i].setText(""+d2.format(linearArray[i].b));
		       }
		       repaint();
	            }
	        } //either xs or ys
	    } //which x or y
	} //some m,b, x or y textfield
    }

    public void itemStateChanged( ItemEvent event ) {
	if ( event.getSource() == intersectionsRadioButton ) {
	    showIntersections = !showIntersections;
	    repaint();    
	}
	//find which choiceRadio
	else {
	    int i=0;
	    while (i<MaxNumLines && choiceRadios[i][0]!=event.getSource() &&
	   	                    choiceRadios[i][1]!=event.getSource() &&
	   	                    choiceRadios[i][2]!=event.getSource())
		i++;
	    if (i < MaxNumLines)   //it must be
	        if (choiceRadios[i][0].isSelected()) {  //m b
		   lineChoice[i] = "mb";
	           mFields[i].setEditable(true);
	           bFields[i].setEditable(true);
	           x1Fields[i].setEditable(false);
	           y1Fields[i].setEditable(false);
	           x2Fields[i].setEditable(false);
	           y2Fields[i].setEditable(false);
	        }
		else if (choiceRadios[i][1].isSelected()) {  //point-slope
		   lineChoice[i] = "ps";
	           mFields[i].setEditable(true);
	           bFields[i].setEditable(false);
	           x1Fields[i].setEditable(true);
	           y1Fields[i].setEditable(true);
	           x2Fields[i].setEditable(false);
	           y2Fields[i].setEditable(false);
	        }
		else if (choiceRadios[i][2].isSelected()) {  // 2 points
		   lineChoice[i] = "2p";
	           mFields[i].setEditable(false);
	           bFields[i].setEditable(false);
	           x1Fields[i].setEditable(true);
	           y1Fields[i].setEditable(true);
	           x2Fields[i].setEditable(true);
	           y2Fields[i].setEditable(true);
	        }
	}
    }

    public void paint(Graphics g) {

	super.paint(g);

	int w=getWidth()-westPanelWidth;    
	int h=getHeight();    
	double xWidth = xHi - xLo;   //user grid size
	double yHeight = yHi - yLo;
	double xScale = w / xWidth;   //scale user to panel
	double yScale = h / yHeight;
	double xOffset = xLo * xScale - westPanelWidth;
	double yOffset = yLo * yScale;

	int xAxis = (int)(h+yOffset);
	int yAxis = (int)(-xOffset);

	g.setColor(Color.LIGHT_GRAY);  //grid
	for (double tick=tickInt; tick<=xHi; tick+=tickInt)
	    g.drawLine((int)(tick * xScale - xOffset),0,(int)(tick * xScale - xOffset),h);
	for (double tick=-tickInt; tick>=xLo; tick-=tickInt)
	    g.drawLine((int)(tick * xScale - xOffset),0,(int)(tick * xScale - xOffset),h);
	for (double tick=tickInt; tick<=yHi; tick+=tickInt)
	    g.drawLine(westPanelWidth,h-(int)(tick * yScale - yOffset),getWidth(),h-(int)(tick * yScale - yOffset));
	for (double tick=-tickInt; tick>=yLo; tick-=tickInt)
	    g.drawLine(westPanelWidth,h-(int)(tick * yScale - yOffset),getWidth(),h-(int)(tick * yScale - yOffset));

	g.setColor(Color.BLACK);
	g.drawLine(westPanelWidth,xAxis,getWidth(),xAxis );   //x axis
	g.drawLine(yAxis,0,yAxis,h);    //y axis

	for (double tick=tickInt; tick<=xHi; tick+=tickInt)
	    g.drawLine((int)(tick * xScale - xOffset),xAxis-3,(int)(tick * xScale - xOffset),xAxis+3);
	for (double tick=-tickInt; tick>=xLo; tick-=tickInt)
	    g.drawLine((int)(tick * xScale - xOffset),xAxis-3,(int)(tick * xScale - xOffset),xAxis+3);
	for (double tick=tickInt; tick<=yHi; tick+=tickInt)
	    g.drawLine(yAxis-3,h-(int)(tick * yScale - yOffset),yAxis+3,h-(int)(tick * yScale - yOffset));
	for (double tick=-tickInt; tick>=yLo; tick-=tickInt)
	    g.drawLine(yAxis-3,h-(int)(tick * yScale - yOffset),yAxis+3,h-(int)(tick * yScale - yOffset));

	for (int i=0; i<MaxNumLines; i++) 
	    if (linearArray[i] != null) {
	        double y1, y2, m, b;
	        m = linearArray[i].m;
	        b = linearArray[i].b;
	        y1 = m*xLo + b;
	        y2 = m*xHi + b;
	        g.setColor(colors[i]);
	        if (m!=Double.POSITIVE_INFINITY && m!=Double.NEGATIVE_INFINITY) 
	            g.drawLine((int)(xLo*xScale-xOffset),h-(int)(y1*yScale-yOffset)  ,
	                       (int)(xHi*xScale-xOffset),h-(int)(y2*yScale-yOffset));
	        else  //vertical line
	            g.drawLine((int)(linearArray[i].zero*xScale-xOffset),h-(int)(y1*yScale-yOffset)  ,
	                       (int)(linearArray[i].zero*xScale-xOffset),h-(int)(y2*yScale-yOffset));
	        	
	    }
	if (showIntersections) {
	    g.setColor(Color.BLACK);
	    for (int i=0; i<MaxNumLines-1; i++) 
	        for (int j=i+1; j<MaxNumLines; j++) 
	    	    if (linearArray[i]!=null && linearArray[j]!=null)  //both exist
	    	    	if (linearArray[i].m != linearArray[j].m) {  //not parallel
	    	    	    double x, y;
	    	    	    //note the indexes
	    	    	    x = (linearArray[i].b-linearArray[j].b) / (linearArray[j].m-linearArray[i].m);
	    	    	    //either one's m and b for this common x
	    	    	    y = linearArray[i].m*x + linearArray[i].b;
	                    g.drawString("("+d2.format(x)+","+d2.format(y)+")", 
	                    	         (int)(x*xScale-xOffset),h-(int)(y*yScale-yOffset));
	    	    	}
	}
    }
}

class Linear {
    public double m, b, A, B, C, zero;
    
    public Linear(double m, double b) {
    	this.m = m;
    	this.b = b;
    	zero = -b/m;
    	//how to convert to the others??
    }
    public Linear(double m, double x1, double y1) {
    	this.m = m;
    	this.b = y1 - m*x1;
    	zero = -b/m;
    }    
    public Linear(double x1, double y1, double x2, double y2) {
    	m = (y2-y1)/(x2-x1);
    	A = -m;
    	B = 1;
    	C = y1 - m*x1;
    	b = C;
	if (x1 != x2)  //not vertical line. m!=Inf
    	    zero = C/A;
    	else
    	    zero = x1;  //either x
    }
/*    public Linear(double A, double B, double C) {
    	this.A = A;
    	this.B = B;
    	this.C = C;
    	m = -A/B;
    	b = C/B;
    	zero = C/A;
    }
*/
}