import java.awt.*;

/**
    Program:  SmMovie7
    Purpose:  
    @author:  Paul Garrett, garrett@math.umn.edu
    @version: 7, Sun Jan 26 16:22:12 CST 1997
*/

/* 
 * For efficiency, two arrays are kept, which _alternate_ (depending upon
 * parity of the time, between being the _actual_ wave and being
 * the _previous_ state
 */

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

  final Color bgColor = Color.darkGray;
  final Color fgColor = Color.white;  
  final int totalTime = 300;
  final int waveSpeed = 1;
  final int numberIntervals = 100;
  final double theFrac = 0.45; // = wave height / half of theHeight

  final double m = 0.005; // change: edit
  final double b = 0.005; // ad hoc

  Thread timerThread;
  int theTime;
  boolean queryMouseDown, queryRunMovie;
  double[][] theWave; // the native numbers
  int timeParity; // for evolving wave...

  int[][] theFrames; // to screen: [time][space]
  int[] xs;
  Image offScreenImage;
  Graphics offScreenGraphics;
  Button runButton, rewindButton; // first is Run/Freeze/Continue
  Label theLabel; // for warning about computational delay
  int theWidth, theHeight;
  //  double maxValue, minValue;

  // u_tt - u_xx + m^2u + bu^3 =0 is Klein-Gordon...
  // and \int_x (1/2)(u_t^2 + u_x^2) + m^2 u^2/2 + b u^4/4 dx is conserved

  public void init() {    
    initConstants();
    initWave();
    initFrame();
    repaint();
  }

  final void initConstants() {
    theTime=0;
    runButton = new Button("Run");
    add(runButton);
    theLabel = new Label("After hitting \"run\", please allow time for the initial computation");
    add(theLabel);
    queryMouseDown = false;
    queryRunMovie = false;
    theHeight = this.size().height; // to save time...
    theWidth = this.size().width;
    offScreenImage = createImage(theWidth, theHeight);
    offScreenGraphics = offScreenImage.getGraphics();
    initXs(); // after get theWidth, theHeight
    theWave = new double[2][numberIntervals + 1];
    theFrames = new int[totalTime+1][numberIntervals + 1];
  }    
  
  final void initWave() {
    int w = numberIntervals/4;
    for (int i=1; i < 2 * w; i++) {
      theWave[0][i] = theWave[1][i+1] = Math.exp(-   ((float)((i-w)*(i-w)) * .02 )    );
    } // sets up pseudo-travelling wave to right
  }

  public synchronized void paint(Graphics g) {
    drawOneFrame();
    g.drawImage(offScreenImage, 0, 0, this);
  }

  final void drawOneFrame() {
    offScreenGraphics.setColor(bgColor);
    offScreenGraphics.fillRect(0, 0, theWidth, theHeight);
    offScreenGraphics.setColor(fgColor);
    for (int i=0; i<numberIntervals ; i++) {
      offScreenGraphics.drawLine(xs[i], theFrames[theTime][i],
				 xs[i+1], theFrames[theTime][i+1]);
    }
    offScreenGraphics.drawString("Time is " + theTime, 10, theHeight - 3);
    offScreenGraphics.drawString(" garrett@math.umn.edu ", theWidth -200, theHeight - 3);
  }

  final void evolveWave() { // must have "b", "m", and "waveSpeed" initialized
    // uses instance variable "timeParity", also
   double[] tmpWave = new double[numberIntervals +1];
   for (int x=1; x < numberIntervals; x++) {
     tmpWave[x] = - b * theWave[(timeParity+1)%2][x] * theWave[(timeParity+1)%2][x] * 
       theWave[(timeParity+1)%2][x];
     tmpWave[x] += - m * m * theWave[(timeParity+1)%2][x];
     tmpWave[x] += theWave[(timeParity+1)%2][x+1] + theWave[(timeParity+1)%2][x-1] - 
       theWave[timeParity][x];
   }
    theWave[timeParity] = tmpWave;
  }

  final void initXs() {
    xs = new int[numberIntervals + 1];
    for (int i=0; i <= numberIntervals; i++) {
      xs[i] = (int) ((float) theWidth * .05 + (float) i * (float) .9 * 
		     (float) theWidth / numberIntervals);
    }
  }
  /*
   * Gotta compute the first frame()
   * just to have a picture on the screen...
   * prior to attempting normalization!
   */

  final void initFrame() {
    for (int x=0; x<= numberIntervals; x++) {
      theFrames[0][x] = (int) ((float)(theHeight/2) - 
			       ((float)(theHeight/2)) * theFrac * theWave[0][x]);
    }
  }

  final void computeFrames() {
    for (int x=0; x<=numberIntervals; x++) {
	theFrames[0][x] = (int)( ((float) theHeight/2) * (1.0 - theFrac * theWave[0][x]) );
	theFrames[1][x] = (int)( ((float) theHeight/2) * (1.0 - theFrac * theWave[1][x]) );
      }
    for (int t=2; t<=totalTime; t++) {
      timeParity = t%2; // this is an instance variable
      evolveWave();
      for (int x=0; x<=numberIntervals; x++) {
	theFrames[t][x] = 
	  (int)( ((float) theHeight/2) * (1.0 - theFrac * theWave[timeParity][x]) );
      }
    }
  }

  public void start() {
    if (timerThread == null && queryRunMovie) {
      timerThread = new Thread(this);
      timerThread.start();
    }
    repaint();
  }

  public void stop() {
    if (timerThread != null) {
      timerThread.stop();
      try {
	timerThread.join();
      }
      catch (InterruptedException e) { }
      timerThread = null;
    }
  }
  void pause(int time) {
    try { Thread.sleep(time); }
    catch ( InterruptedException e) { }
  }

  public void run() {
    while (theTime < totalTime) {
      repaint();
      theTime++;
      pause(50);
    }
  }

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

  public boolean action(Event e, Object buttonName) {
    if (e.target instanceof Button) {
      if ((String) buttonName == "Run") { // at very beginning...
	runButtonAction();
      }
      else if ((String) buttonName == "Freeze") { 
	freezeButtonAction();
      }
      else if ((String) buttonName == "Continue") { 
	continueButtonAction();
      }
       else if ((String) buttonName == "Rewind") { 
	rewindButtonAction();
      }
    }
    return true;
  }

    final void continueButtonAction() {
      queryRunMovie = true;
      runButton.setLabel("Freeze"); // for subsequent restart
      remove(rewindButton); // removes Rewind button
      runButton.getParent().invalidate();
      runButton.getParent().validate();
      start();
    }

    final void runButtonAction() {
      queryRunMovie = true;
      runButton.setLabel("Freeze"); 
      remove(theLabel);
      runButton.getParent().invalidate();
      runButton.getParent().validate(); // all these buttons have the same parent
      repaint();
      computeFrames();
      start(); // does nothing without queryRunMovie = true
    }
    
    final void freezeButtonAction() {
      stop();
      queryRunMovie = false;
      runButton.setLabel("Continue"); // for subsequent restart
      rewindButton = new Button("Rewind");
      add(rewindButton);
      runButton.getParent().invalidate();
      runButton.getParent().validate();
      repaint();
    } 

   final void rewindButtonAction() {
      theTime = 0;
      runButton.setLabel("Continue"); // for subsequent restart
      remove(rewindButton);
      runButton.getParent().invalidate();
      runButton.getParent().validate();
      queryRunMovie = false;
      repaint();
      start();
    } 

} // the end of the class