import java.awt.*;
import java.awt.event.*;
import java.lang.*;
import java.lang.Math;
import java.text.*;

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

  Canvas oscillators;
  Label lengthRedLabel, lengthBlueLabel, velRedLabel, velBlueLabel, 
        lengthRedS, lengthBlueS, angleRedS, angleBlueS;
  Thread runner;
  Scrollbar redLscroll, blueLscroll, redAscroll, blueAscroll;
  int redLength, blueLength, redAngle, blueAngle;
  int[] xpos = new int[7];
  int[] ypos = new int[7];
  double[] x = new double[7];
  double[] y = new double[7];
  double rL, bL, rA, bA, gX, gY, rX, rY, bX, bY, gA;
  double pi = 3.141592653589793238468;
  Image offscreenImg;
  Graphics offscreenG;

  boolean startFlag = false;

  void buildConstraints(GridBagConstraints gbc, int gx, int gy, 
      int gw, int gh,
      int wx, int wy) {
	gbc.gridx = gx;
	gbc.gridy = gy;
	gbc.gridwidth = gw;
	gbc.gridheight = gh;
	gbc.weightx = wx;
	gbc.weighty = wy;
  }

  public void init() {
    GridBagLayout gridbag = new GridBagLayout();
    GridBagConstraints constraints = new GridBagConstraints();
    setLayout(gridbag);

    // Red length text
    buildConstraints(constraints, 0, 0, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label lengthRedLabel = new Label("Length of red vector:", Label.CENTER);
    gridbag.setConstraints (lengthRedLabel, constraints);
    add(lengthRedLabel);

    // Red length scrollbar label
    buildConstraints(constraints, 2, 0, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    lengthRedS = new Label("6", Label.LEFT);
    redLength = 6;
    gridbag.setConstraints (lengthRedS, constraints);
    add(lengthRedS);

    // Red length scrollbar
    buildConstraints(constraints, 1, 0, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    redLscroll = new Scrollbar(Scrollbar.HORIZONTAL, 6, 1, 1, 10);
    gridbag.setConstraints (redLscroll, constraints);
    add(redLscroll);

    // Blue length text
    buildConstraints(constraints, 0, 1, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label lengthBlueLabel = new Label("Length of blue vector:", Label.CENTER);
    gridbag.setConstraints (lengthBlueLabel, constraints);
    add(lengthBlueLabel);

    // Blue length scrollbar label
    buildConstraints(constraints, 2, 1, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    lengthBlueS = new Label("8", Label.LEFT);
    blueLength = 8;
    gridbag.setConstraints (lengthBlueS, constraints);
    add(lengthBlueS);

    // Blue length scrollbar
    buildConstraints(constraints, 1, 1, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    blueLscroll = new Scrollbar(Scrollbar.HORIZONTAL, 8, 1, 1, 10);
    gridbag.setConstraints (blueLscroll, constraints);
    add(blueLscroll);

    // Red angle text
    buildConstraints(constraints, 0, 2, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label angleRedLabel = new Label("Angle of red vector:", Label.CENTER);
    gridbag.setConstraints (angleRedLabel, constraints);
    add(angleRedLabel);

    // Red angle scrollbar label
    buildConstraints(constraints, 2, 2, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    angleRedS = new Label("0", Label.LEFT);
    redAngle = 0;
    gridbag.setConstraints (angleRedS, constraints);
    add(angleRedS);

    // Red angle scrollbar
    buildConstraints(constraints, 1, 2, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    redAscroll = new Scrollbar(Scrollbar.HORIZONTAL, 0, 4, 0, 360);
    gridbag.setConstraints (redAscroll, constraints);
    add(redAscroll);

    // Blue angle text
    buildConstraints(constraints, 0, 3, 1, 1, 20, 5);
    constraints.fill = GridBagConstraints.NONE;
    constraints.anchor = GridBagConstraints.EAST;
    Label angleBlueLabel = new Label("Angle of blue vector:", Label.CENTER);
    gridbag.setConstraints (angleBlueLabel, constraints);
    add(angleBlueLabel);

    // Blue angle scrollbar label
    buildConstraints(constraints, 2, 3, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    angleBlueS = new Label("90", Label.LEFT);
    blueAngle = 90;
    gridbag.setConstraints (angleBlueS, constraints);
    add(angleBlueS);

    // Blue angle scrollbar
    buildConstraints(constraints, 1, 3, 1, 1, 20, 0);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    constraints.anchor = GridBagConstraints.WEST;
    blueAscroll = new Scrollbar(Scrollbar.HORIZONTAL, 90, 4, 0, 360);
    gridbag.setConstraints (blueAscroll, constraints);
    add(blueAscroll);

    // canvas
    buildConstraints(constraints, 0, 4, 3, 1, 0, 80);
    constraints.fill = GridBagConstraints.HORIZONTAL;
    oscillators = new Canvas();
    gridbag.setConstraints (oscillators, constraints);
    add(oscillators);

    offscreenImg = createImage(this.size().width, this.size().height);
    offscreenG = offscreenImg.getGraphics();
  }

  public void start() {
    if (runner == null); {
      runner = new Thread(this);
      runner.start();
    }
  }

  public void stop() {
    if (runner != null) {
      runner.stop();
      runner = null;
    }
  }

  public void run() {
    int index, temp;
    double scale, kAngle, arrowScale, tempA;
    scale =7.5;
    arrowScale = 1.2*scale;
    kAngle = pi / 180.0;
    boolean beforeFlag;

    while (true) {
      beforeFlag = true;
      rL = redLength;
      bL = blueLength;
      rA = kAngle*redAngle;
      bA = kAngle*blueAngle;

      rX = rL*Math.cos(rA);
      if (Math.abs(rX)<0.00001) rX = 0;
      rY = rL*Math.sin(rA);
      if (Math.abs(rY)<0.00001) rY = 0;
      bX = bL*Math.cos(bA);
      if (Math.abs(bX)<0.00001) bX = 0;
      bY = bL*Math.sin(bA);
      if (Math.abs(bY)<0.00001) bY = 0;

      x[0] = 200.0;
      x[1] = x[0]+scale*rX;
	temp=180-redAngle-30;
      tempA = kAngle*temp;
      x[2] = x[1]+arrowScale*Math.cos(tempA);
	temp=180-redAngle+30;
      tempA = kAngle*temp;
      x[3] = x[1]+arrowScale*Math.cos(tempA);
      x[4] = x[1]+scale*bX;
	temp=180-blueAngle-30;
      tempA = kAngle*temp;
      x[5] = x[4]+arrowScale*Math.cos(tempA);
	temp=180-blueAngle+30;
      tempA = kAngle*temp;
      x[6] = x[4]+arrowScale*Math.cos(tempA);

      y[0] = 340.0;
      y[1] = y[0]-scale*rY;
	temp=180-redAngle-30;
      tempA = kAngle*temp;
      y[2] = y[1]+arrowScale*Math.sin(tempA);
	temp=180-redAngle+30;
      tempA = kAngle*temp;
      y[3] = y[1]+arrowScale*Math.sin(tempA);
      y[4] = y[1]-scale*bY;
	temp=180-blueAngle-30;
      tempA = kAngle*temp;
      y[5] = y[4]+arrowScale*Math.sin(tempA);
	temp=180-blueAngle+30;
      tempA = kAngle*temp;
      y[6] = y[4]+arrowScale*Math.sin(tempA);

      for (index=0; index <=6; index++) {
           xpos[index] = (int)(x[index]);
           ypos[index] = (int)(y[index]);
      }
      
	gX = rX+bX;
	gY = rY+bY;
      gA = 0.0;
      if (gX != 0.0) {
        gA = (Math.atan(gY/gX))/kAngle;
        if (gX<0.0) {
          gA = gA +180.0;
        }
        else if (gY<0.0) gA = gA + 360.0;
      }
      else if (gY>0.0) {
        gA = 90.0;
      }
      else if (gY<0.0) gA = 270.0;
      while (startFlag) {


        while (startFlag) {     
          repaint();
          try { Thread.sleep(10); }
          catch (InterruptedException e) { }
       } 
     }
     repaint();
     try { Thread.sleep(10); }
     catch (InterruptedException e) { }
     }
  }

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

  public void paint(Graphics g) {

  int i, yVal;

     // Draw background
    offscreenG.setColor(Color.lightGray);
    offscreenG.fillRect(0,0,600,179);
    offscreenG.setColor(Color.white);
    offscreenG.fillRect(0,180,600,500);

   // Draw vectors
    NumberFormat nf = NumberFormat.getInstance();
    nf.setMaximumFractionDigits(4);
    offscreenG.setColor(Color.black);
    offscreenG.drawLine(xpos[0]-150,ypos[0],xpos[0]+150,ypos[0]);
    offscreenG.drawLine(xpos[0],ypos[0]-150,xpos[0],ypos[0]+150);
    offscreenG.setColor(Color.red);
    offscreenG.drawLine(xpos[0],ypos[0],xpos[1],ypos[1]);
    offscreenG.drawLine(xpos[1],ypos[1],xpos[2],ypos[2]);
    offscreenG.drawLine(xpos[1],ypos[1],xpos[3],ypos[3]);
    offscreenG.drawString("Red x-component = " + nf.format(rX), 400, 220);
    offscreenG.drawString("Red y-component = " + nf.format(rY), 400, 240);
    offscreenG.setColor(Color.blue);
    offscreenG.drawLine(xpos[1],ypos[1],xpos[4],ypos[4]);
    offscreenG.drawLine(xpos[4],ypos[4],xpos[5],ypos[5]);
    offscreenG.drawLine(xpos[4],ypos[4],xpos[6],ypos[6]);
    offscreenG.drawString("Blue x-component = " + nf.format(bX), 400, 260);
    offscreenG.drawString("Blue y-component = " + nf.format(bY), 400, 280);
    offscreenG.setColor(Color.green);
    offscreenG.drawLine(xpos[0],ypos[0],xpos[4],ypos[4]);
    offscreenG.drawString("The resultant is green", 400, 300);
    offscreenG.drawString("Green x-component = " + nf.format(gX), 400, 320);
    offscreenG.drawString("Green y-component = " + nf.format(gY), 400, 340);
    offscreenG.drawString("Length of resultant = " + nf.format(Math.sqrt(gX*gX+gY*gY)), 400, 360);
    offscreenG.drawString("Angle = " + nf.format(gA) + " degrees", 400, 380);
   g.drawImage(offscreenImg,0,0,this);
  }

  public void destroy() {
     offscreenG.dispose();
  }

  public boolean action (Event evt, Object arg) {

    if (evt.target instanceof Button) {
    }
    else return super.action(evt, arg);
    return true;
  }

  public boolean handleEvent(Event evt) {

    if (evt.target instanceof Scrollbar) {
      if ((Scrollbar)evt.target == redLscroll) {
        redLength = ((Scrollbar)evt.target).getValue();
        lengthRedS.setText(String.valueOf(redLength));
      }
      else if ((Scrollbar)evt.target == blueLscroll) {
        blueLength = ((Scrollbar)evt.target).getValue();
        lengthBlueS.setText(String.valueOf(blueLength));
      }
      else if ((Scrollbar)evt.target == redAscroll) {
        redAngle = ((Scrollbar)evt.target).getValue();
        angleRedS.setText(String.valueOf(redAngle));
      }
      else if ((Scrollbar)evt.target == blueAscroll) {
        blueAngle = ((Scrollbar)evt.target).getValue();
        angleBlueS.setText(String.valueOf(blueAngle));
      }
	repaint();
    }
    else return super.handleEvent(evt);
    return true;
  }
}