/*  LineDraw
 *
 *  Example of a Java Applet that draws two connected lines near the middle of the screen.
 *  Subsequent clicks reset the line starting point to the previous click location, so the line extends from the previous
 *  mouse click location to the current mouse click location.  Display the current line as well as the previous line.
 *  In addition the line endpoints are displayed as text at the bottom left of the screen.
 *  Ensure line segments don't intersect.
 * 
 *  Note that this is an "old-fashioned" way of handling mouse clicks.  Compiling this will likely  lead to a
 *  warning of using the "deprecated" method for mouseDown().  you can ignore this warning for now.  
 *  A more robust (and more complex) approach is to us Swing and JApplet.  
 */

// import predefined code to help with various aspects of the program
import java.awt.Graphics;       // allows drawing
import java.awt.Event;              // allows handling events
import java.awt.Font;                // allows placing text 
import java.awt.geom.*;            // used in checking for line intersection

// declare the class, that itself is a kind of Applet
public class LineDraw extends java.applet.Applet {

    // Declare the variables used to store the various lines
    // Line 0
    int line0x1;
    int line0y1;
    int line0x2;
    int line0y2;
    // Line 1
    int line1x1;
    int line1y1;
    int line1x2;
    int line1y2;
    // Line 2
    int line2x1;
    int line2y1;
    int line2x2;
    int line2y2;    
     // Line 3
    int line3x1;
    int line3y1;
    int line3x2;
    int line3y2;    
     // Line 4
    int line4x1;
    int line4y1;
    int line4x2;
    int line4y2;      
    
    // store which line should be changed on this turn
    int whichLine = 0;
    final int NUMBER_OF_LINES = 5;      // this is a constant, used below in the program
    

    //-------------------------------------------------------------------------------------------------------------------------------
    // init()
    //       Code inside init() is used to initialize values used in the Applet
    public void init() {
        // set the line 0 to start from the middle and go up
        line0x1 = (getSize().width / 2);
        line0y1 = (getSize().width / 2);
        line0x2 = line0x1;      
        line0y2 =line0y1 - 40;
        
        // set line 1 to then go right.  Add a small offset so that intersection could still work
        line1x1 = line0x2 + 1;        
        line1y1 = line0y2 - 1;
        line1x2 = line1x1 + 40;
        line1y2 = line1y1;
        
        // set line 2 to go down.  Add a small offset so that intersection could still work
        line2x1 = line1x2 + 1;        
        line2y1 = line1y2 + 1;
        line2x2 = line2x1;
        line2y2 = line2y1  + 40;
        
        // set line 3 to again go right.  Add a small offset so that intersection could still work
        line3x1 = line2x2 + 1;        
        line3y1 = line2y2 + 1;
        line3x2 = line3x1  + 40;
        line3y2 = line3y1;
        
        // set line 4 to again go up.  Add a small offset so that intersection could still work
        line4x1 = line3x2 + 1;        
        line4y1 = line3y2 - 1;
        line4x2 = line4x1;
        line4y2 = line4y1  - 40;
        
        setBackground(java.awt.Color.white);                   // set the background color to be white
        setFont(new Font("Helvetica",Font.BOLD,14));    // set the font for displaying text
        requestFocus();                                                          // make the applet window come to the front
    }//end init()
    
    

    //-------------------------------------------------------------------------------------------------------------------------------
    // mouseDown()
    //       Handle the mouse clicks, resetting the line endpoints to be the mouse (x,y) location
    // Before changing line locations, verify that the lines don't intersect.  If they do intersect,
    // don't update the line values and end the program
    public boolean mouseDown(Event evt, int x, int y) {
        // When endpoints overlap, then line intersection doesn't work correctly.  For this reason as each new line is drawn,
        // offset its endpoint by 1.
        int xOffset = 1;
        int yOffset = 1;                                            
        
        // Change the appropriate line, depending on which turn it is.  
        if( whichLine == 0) { 
            // change the values for line 0, where the new starting point for line 0 is the ending point for line 4,
            // and the ending point for line 0 is the mouse click location.
            // First adjust the endpoint offsets, if necessary, so the endpoints aren't the same, which causes intersection problems
            if( x<line4x2)
                xOffset = xOffset * -1;
            if( y<line4y2)
                yOffset = yOffset * -1;
            line0x1 = line4x2 + xOffset;
            line0y1 = line4y2 + yOffset;
            line0x2 = x;
            line0y2 = y;              
        }
        else  if( whichLine == 1) { 
            // change the values for line 1, where the new starting point for line 1 is the ending point for line 0,
            // and the ending point for line 1 is the mouse click location.
             // First adjust the endpoint offsets, if necessary, so the endpoints aren't the same, which causes intersection problems
            if( x<line0x2)
                xOffset = xOffset * -1;
            if( y<line0y2)
                yOffset = yOffset * -1;
            line1x1 = line0x2 + xOffset;
            line1y1 = line0y2 + yOffset;
            line1x2 = x;
            line1y2 = y;     
        } 
        else  if( whichLine == 2) { 
            // change the values for line 2, where the new starting point for line 2 is the ending point for line 1,
            // and the ending point for line 2 is the mouse click location.
             // First adjust the endpoint offsets, if necessary, so the endpoints aren't the same, which causes intersection problems
            if( x<line1x2)
                xOffset = xOffset * -1;
            if( y<line1y2)
                yOffset = yOffset * -1;
            line2x1 = line1x2 + xOffset;
            line2y1 = line1y2 + yOffset;
            line2x2 = x;
            line2y2 = y;     
        } 
        else  if( whichLine == 3) { 
            // change the values for line 3, where the new starting point for line 3 is the ending point for line 2,
            // and the ending point for line 3 is the mouse click location.
             // First adjust the endpoint offsets, if necessary, so the endpoints aren't the same, which causes intersection problems
            if( x<line2x2)
                xOffset = xOffset * -1;
            if( y<line2y2)
                yOffset = yOffset * -1;
            line3x1 = line2x2 + xOffset;
            line3y1 = line2y2 + yOffset;
            line3x2 = x;
            line3y2 = y;     
        } 
        else  if( whichLine == 4) { 
            // change the values for line 3, where the new starting point for line 3 is the ending point for line 2,
            // and the ending point for line 3 is the mouse click location.
             // First adjust the endpoint offsets, if necessary, so the endpoints aren't the same, which causes intersection problems
            if( x<line3x2)
                xOffset = xOffset * -1;
            if( y<line3y2)
                yOffset = yOffset * -1;
            line4x1 = line3x2 + xOffset;
            line4y1 = line3y2 + yOffset;
            line4x2 = x;
            line4y2 = y;     
        }           
        
        // increment whose turn it is.  Once this value reaches the number of lines, have it wrap around to the first
        // line value again.  Do this by using the "mod" function to get the remainder after dividing.
        whichLine = (whichLine + 1) % NUMBER_OF_LINES;        
        
        // repaint() is what you should use so that the Applet itself calls the paint() method.
        repaint();
            
        return true;
    }// end mouseDown()

    

    //-------------------------------------------------------------------------------------------------------------------------------
    // Do whatever drawing needs to be done
    public void paint(Graphics g) {
        // The Applet has previously created the graphics context called "g" here, upon which we will draw
        g.drawLine(line0x1, line0y1, line0x2, line0y2);
        g.drawLine(line1x1, line1y1, line1x2, line1y2);
        g.drawLine(line2x1, line2y1, line2x2, line2y2);
        g.drawLine(line3x1, line3y1, line3x2, line3y2);
        g.drawLine(line4x1, line4y1, line4x2, line4y2);
      
        // make a string to be displayed that contains the x,y locations of the lines.  
        String displayString = "Next update to line " + whichLine;
        
        // Display custom message if any lines intersect
        if(  Line2D.linesIntersect( line0x1, line0y1, line0x2, line0y2,   line1x1, line1y1, line1x2, line1y2)  ||   // line 0 vs line 1
             Line2D.linesIntersect( line0x1, line0y1, line0x2, line0y2,   line2x1, line2y1, line2x2, line2y2)  ||   // line 0 vs.line 2
             Line2D.linesIntersect( line0x1, line0y1, line0x2, line0y2,   line3x1, line3y1, line3x2, line3y2)  ||   // line 0 vs.line 3
             Line2D.linesIntersect( line0x1, line0y1, line0x2, line0y2,   line4x1, line4y1, line4x2, line4y2)  ||   // line 0 vs.line 4
             Line2D.linesIntersect( line1x1, line1y1, line1x2, line1y2,   line2x1, line2y1, line2x2, line2y2)  ||   // line 1 vs.line 2
             Line2D.linesIntersect( line1x1, line1y1, line1x2, line1y2,   line3x1, line3y1, line3x2, line3y2)  ||   // line 1 vs.line 3
             Line2D.linesIntersect( line1x1, line1y1, line1x2, line1y2,   line4x1, line4y1, line4x2, line4y2)  ||   // line 1 vs.line 4
             Line2D.linesIntersect( line2x1, line2y1, line2x2, line2y2,   line3x1, line3y1, line3x2, line3y2)  ||   // line 2 vs.line 3
             Line2D.linesIntersect( line2x1, line2y1, line2x2, line2y2,   line4x1, line4y1, line4x2, line4y2)  ||   // line 2 vs.line 4
             Line2D.linesIntersect( line3x1, line3y1, line3x2, line3y2,   line4x1, line4y1, line4x2, line4y2))  {   // line 3 vs.line 4
                 displayString = " *** Intersection *** " + displayString;    // prepend to the display string           
        }
        
        // note that the string (x,y) position refers to the *bottom* left corner of the "box" containing the string
        g.drawString(displayString, 0, getSize().height-20);   // move up slightly, else the "tails" of the commas are cut
        
        // draw the identifying string on the screen as well
        g.drawString("Dale Reed, Prog. 1, CS 102 Fall 2009", 0, getSize().height - 5);
    }//end paint()
    
    
}//end class