import java.awt.*;

/**
    Program:  NextWave81
    Purpose:  
    @author:  Paul Garrett, garrett@math.umn.edu
    @version: 81, Sun Jan 26 14:53:56 CST 1997
*/

public class NextWave81 extends java.applet.Applet implements Runnable {

  Thread theThread;
  int[][] thePoints;
  int theTime; 
  final int numberSubintervals = 100;
  final int totalTime = 400;
  final int xIncrement = 4;
  int[] xs, thePosition, previousPosition;

  boolean queryMouseDown;
  boolean queryRun; // true if clicked to go

  int theIndex; // of point picked-up by mouse

  final int xinc = 2;
  final int yinc = 5; // size of handles, now invisible, though

  Color bgColor; // background
  Color fgColor; // foreground

  Image offScreenImage; // for double-buffering
  Graphics offScreenGraphics; // ditto

  Button firstButton, secondButton, thirdButton;

  /* Above are all the instance variables.... */

  public void init() {
    theTime = 1;

    firstButton = new Button("Run");
    add(firstButton);

    thirdButton = new Button("Smooth");
    add(thirdButton);
    
    queryMouseDown = false;
    queryRun = false;

    xs = new int[numberSubintervals];

    //    thePosition = new int[numberSubintervals+1]; // the y's are init'd to 0's
    //    previousPosition = new int[numberSubintervals+1]; // the y's are init'd to 0's

    for (int i=0; i<numberSubintervals; i++) {
      xs[i] = i * xIncrement;
    }
    offScreenImage = createImage(this.size().width,
				 this.size().height); // size of applet
    offScreenGraphics = offScreenImage.getGraphics();

    bgColor = Color.darkGray;
    fgColor = Color.white; // for example...... reverse video...
    setBackground(bgColor);
    setForeground(fgColor);
   
    thePoints = new int[totalTime][numberSubintervals + 1]; // NB the "+1"    
    repaint();
  }

  /* Above is all the initialization */

  public boolean action(Event e, Object buttonName) {
    if (e.target instanceof Button) {
      if ((String) buttonName == "Run") { // at very beginning...
	queryRun = true;
	firstButton.setLabel("Freeze"); 
	remove(thirdButton);
	computeFrames();
	start(); // does nothing without queryRun = true
      }
      else if ((String) buttonName == "Freeze") { 
	stop();
	queryRun = false;
	firstButton.setLabel("Continue"); // for subsequent restart
	secondButton = new Button("Reset");
	thirdButton = new Button("Smooth");
	add(secondButton);
	add(thirdButton);
	repaint();
      }
      else if ((String) buttonName == "Continue") { // "Continue" case
	queryRun = true;
	firstButton.setLabel("Freeze"); // for subsequent restart
	remove(secondButton); // removes Reset button
	remove(thirdButton); // removes Smooth button
	computeFrames();
	start();
      }
      else if ((String) buttonName == "Reset") {
	queryRun = false;
	stop();
	theTime = 1;
	firstButton.setLabel("Run"); // for subsequent restart
	remove(secondButton); // removes Reset button
	thePoints = new int[totalTime][numberSubintervals + 1];
	repaint(); 
      }
      else if ((String) buttonName == "Smooth") {
	smooth();
	theTime = theTime + 2;
	computeFrames();
	repaint();
      }

      firstButton.getParent().invalidate();
      firstButton.getParent().validate(); // all these buttons have the same parent
    } // end "if ... Button"
    return true;
  }

  void smooth() {
    for (int i=1; i < numberSubintervals; i++) {
      thePoints[theTime+2][i] = (thePoints[theTime][i-1] + 2 * thePoints[theTime][i] 
                  + thePoints[theTime][i+1])/4;
      thePoints[theTime+1][i] =  (thePoints[theTime-1][i-1] + 2 * thePoints[theTime-1][i] 
                  + thePoints[theTime-1][i+1])/4;
    }
  }

  void computeFrames() { // from _two_ initial position descriptions...
    for (int t=theTime+1; t<totalTime; t++) {
      for (int x=1; x < numberSubintervals; x++) { // interior points
	thePoints[t][x] = thePoints[t-1][x-1]
	 + thePoints[t-1][x+1] - thePoints[t-2][x]; 
	 // NB: 2 * thePoints[t-1][x] cancelled !
      }
    }
  }
  
  public void start() {
    if (theThread == null && queryRun) {
      theThread = new Thread(this);
      theThread.start();
    }
  }
  public void stop() {
    if (theThread != null) {
      theThread.stop();
      theThread = null;
    }
  }
  void pause(int time) { // in milliseconds
    try { Thread.sleep(time); }
    catch ( InterruptedException e) { }
  }

  public void run() { 
    /* this calls repaint which calls "update" ... which schedules paint() */
    while (theTime < totalTime) {
      repaint();
      theTime++;
      pause(50); 
    }
  }	

  public void update(Graphics g) { // don't clear the screen for duhbuff
    paint(g); 
  }

  public void paint(Graphics g) {
    offScreenGraphics.setColor(bgColor);
    offScreenGraphics.fillRect(0, 0, this.size().width, this.size().height);
    offScreenGraphics.setColor(fgColor);
    offScreenGraphics.drawString("Time is " + theTime, 10, 15);
    offScreenGraphics.drawString("garrett@math.umn.edu", 350, 297); // ad hoc
    for (int i=0; i< numberSubintervals; i++) {
      offScreenGraphics.drawLine(50 + i*xIncrement, 150 -  thePoints[theTime][i],
				 50 + (i+1)*xIncrement, 150 - thePoints[theTime][i+1]);
    }
    //    if (!queryRun) {
    //      drawHandles(offScreenGraphics);  
    //    }

    g.drawImage(offScreenImage, 0, 0, this);
  }

/*  void drawHandles(Graphics g) {
 *  for (int i=1; i < numberSubintervals; i++) {
 *      g.fillRect(50+ xs[i]-inc, 150-thePoints[theTime][i]-inc, 2 * inc + 1, 2 * inc + 1);
 *    }
 *  }
 *    Don't draw the handles, I guess!
 *
 */


  public boolean mouseDrag(Event e, int x, int y) {
    if (queryMouseDown == true) {
      thePoints[theTime][theIndex] = 150 - y;
      if (theIndex > 1) {
	thePoints[theTime -1][theIndex-1] = 150 - y; // Edit this
      }
      repaint();
    }
    return true;
  }

  public boolean mouseUp(Event e, int x, int y) {
    if (queryMouseDown) {
      queryMouseDown = false;
      repaint();
    }
    return true;
  }

 public boolean mouseDown(Event e, int x, int y) {
     for (int i=1; i< numberSubintervals; i++) {
       if ((Math.abs(x-(50 + i * xIncrement)) <= xinc) && 
	   (Math.abs(y-(150 - thePoints[theTime][i])) <= yinc)) {
	 queryMouseDown = true;
	 theIndex = i;
       }
     }
     return true;
  }

} // the end