Making the Interface Functional for the Planet Applet

Click here to skip to the explanation.

The numbers to the far left are only for reference, the lines labeled with purple line numbers has already been explained as part of the interface, and the lines labeled with green line numbers are the extra code needed to make the interface functional.

1.  	import java.awt.*;
2.	import java.applet.Applet;

3.	public class Planet extends Applet implements Runnable{	
4.		Thread displayer;		//declare the thread
5.		Panel dataPanel;
6.		Button controlButton;
7.		boolean doSuspend;
8.		TextField inputxcoord, inputycoord, inputxvel, inputyvel;  //declare variables
9.		int centerx, centery;
								
10.		double[] pos = new double[2];		//declare arrays for position, velocity, and acceleration
11.		double[] vel = new double[2];	
12.		double[] accel = new double[2];	
13.		double dt = 0.01;	//declare and initialize some variables
14.		double GM = 4pi2;

15.	public void init() {
16.		setBackground(Color.white);
17.		dataPanel = new Panel(); 
18.		dataPanel.setLayout(new GridLayout (5,2,5,5));
19.		dataPanel.add(new Label("x-coordinate"));
20.		inputxcoord = new TextField("50");
21.		dataPanel.add(inputxcoord);
22.		dataPanel.add(new Label("y-coordinate"));
23.		inputycoord = new TextField("50");
24.		dataPanel.add(new Label("x-velocity"));
25.		inputxvel = new TextField("50");
26.		dataPanel.add(inputxvel);
27.		dataPanel.add(new Label("y-velocity"));
28.		inputyvel = new TextField("50");
29.		dataPanel.add(inputyvel);
30.		dataPanel.add(new Button("Start"));

31.		setLayout(new BorderLayout(10,10));
32.		add("East",dataPanel);
33.		setBackground(Color.black);
34.	}

35.	public void paint (Graphics g) {	
36.		g.setColor(Color.yellow);		//sun is yellow
37.		g.fillOval(50,50,8,8);			//paint sun
38.		g.setColor(Color.green);		//planet is green
39.		g.fillOval(50,100,4,4);			//paint planet
40.	}

								
41.	public void update (Graphics g) {			//update the picture
42.		g.setColor(Color.blue);    //planet is blue
43.		g.fillOval(centerx+(int)pos[0],centery+(int)pos[1],4,4);  //paint planet
44.		inputxcoord.setText(Double.toString(pos[0]));
45.		inputycoord.setText(Double.toString(pos[1]));
46.		inputxvel.setText(Double.toString(vel[0]));
47.		inputyvel.setText(Double.toString(vel[1]));
48.	}

49.	public void start() {		//start the thread running
50. 		if (displayer == null) {
51.   			displayer = new Thread(this);
52.		} 
52.	}

53.	public void stop() {			//stop the thread
54. 		if (displayer != null) {
55.     		displayer.stop();
56.		} 
57.	}
														
58.	public void run() {		//run the Euler() method
59.		while (true) {
60.     		Euler();
61.     		if (doSuspend) {
62.        		displayer.suspend();
63.        		doSuspend = false;
64.     		}
65.     		try {displayer.sleep(10);}
66.     		catch (InterruptedException e){};
67.		} 
68.	}

69.	void resume(){			//resume the applet after being paused
70.		try {
71.			pos[0] = Integer.parseInt(inputxcoord.getText());}
72.			catch (NumberFormatException e) {
73.			inputxcoord.setText(Double.toString(pos[0])); }
74.		try {
75.			pos[1] = Integer.parseInt(inputycoord.getText());}
76.			catch (NumberFormatException e) {
77.			inputycoord.setText(Double.toString(pos[1])); }
78.		try {
79.			vel[0] = Integer.parseInt(inputxvel.getText());}
80.			catch (NumberFormatException e) {
81.			inputxvel.setText(Double.toString(vel[0])); }
82.		try {
83.			vel[1] = Integer.parseInt(inputyvel.getText());}
84.			catch (NumberFormatException e) {
85.			inputyvel.setText(Double.toString(vel[1])); }
86.			displayer.resume();
87.	}

88.	public boolean action (Event evt, Object arg)	{		//event handling
89.		if (evt.target instanceof Button) {
90.	    	System.out.println(" Button "+arg+" pressed");
91.			if ("Start".equals(arg)) {
92.		    	controlButton.setLabel("Pause");
93.		   		displayer.start();	
94.			} else if ("Pause".equals(arg)) {
95.		    	controlButton.setLabel("Resume");
96.		    	doSuspend = true;
97.			} else if ("Resume".equals(arg)) {
98.		    	controlButton.setLabel("Pause");
99.		    	resume();
100.			}
101.			return true;
102.		}
103.		if (evt.target instanceof TextField) {
104.	    	System.out.println(" TextField "+evt.target+" arg="+arg);
105.			return true;
106.		}
107.		return false;
108.	}

109.	public void Euler() {		//simple physics of planetary motion
110.		double r,r2,r3;
111.    	r2 = pos[0]*pos[0] + pos[1]*pos[1];  		//r^2 = x^2 + y^2
112.		r3 = r2*Math.sqrt(r2);					 //r = sqrt(x^2 + y^2)	
113.		for (int i=0;i<=1;i++) {
114.			accel[i] = -G*M*pos[i]/r3;
115.			vel[i] = vel[i] + accel[i]*dt;
116.			pos[i] = pos[i] + vel[i]*dt;
117.		}
118.	}
119.	}

Here's the explanation:

• Because this applet implements a thread, Line 3 is changed to include the words "implement Runnable." The Runnable interface includes the behavior your applet needs to run a thread, and gives a default definition for the run() method.

• Line 4 creates a variable called "displayer" which holds this applet's thread.

• Line 6 creates a variable called "controlButton". This is the variable name for the button which is responsible for controlling the applet. I decided that it would be easier to have one button which starts, pauses, and resumes the execution of the applet, rather than having separate buttons (as I had in the earlier code for the interface).

• Line 7 creates a boolean variable whose purpose will be described later on.

• Line 9 creates two instance variables that define the location of the sun.

• Lines 10-12 create two element arrays to store the x and y components of the planet's position, velocity and acceleration.

• Lines 13 and 14 declare and initialize constants which will be used in the Euler() method.

• Lines 41-48 update the planet's position on the screen by using the updated position calculated in the Euler() method.

• Lines 49-52 create a new thread and start it running by overriding the default start() method.

• In Line 53 the stop() method is overridden, and Lines 55-57 stop the thread from running and also set the thread's variable (displayer) to null. The thread is stopped when the user leaves a page; if the user comes back to the page containing the applet, the start() method creates a new thread and starts the applets execution once again.

• Lines 58-68 define the run() method. Line 58 overrides the default run() method. In lines 59-60 Within an infinite loop, the Euler() method is called to update the position, velocity and acceleration of the planet.

• Lines 61-63 use the instance variable (doSuspend) declared on line 7 to suspend the execution of the thread. This is necessary because in Lines 65-67 I tell the thread to sleep for 10 milliseconds before it gets updated. If I simply try to suspend the thread and it happens to be sleeping, the suspend method never gets called. So it is necessary to use the boolean variable (doSuspend) to suspend thread execution.

• Lines 69-87 make up the resume() method. Below, in the action() method, if the "Resume" button is pressed, it calls the resume() method. In Lines 70-85, the resume() method tries to parse the textfields for numbers and store the numbers in the position and velocity arrays. Since there are four textfields, it tries to parse each one. If a textfield cannot be parsed, it "catches" the error and introduces an exception handling block of code. In this case, if a textfield can not be parsed, it is given the default value assigned in init().

• Lines 88-108 define the action() method. Our applet interface has one button whose initial label is "Start". If the Start button is pressed, the button label is changed to "Pause", so that it becomes a pause button. At the same time the label is changed from "Start" to "Pause", the start() method is called which starts the displayer thread running.

  If the user pushes the Pause button, the label is changed to "Resume" and the boolean variable (doSuspend) is given the value true. This in turn, causes the thread's execution to be suspended in the suspend() method (a predefined thread method), which is called in the run() method (Line 62).

  If the Resume button is pressed, the button label is changed back to "Pause" and the thread method resume() is called.

• Finally, in Lines 109-119, the Euler() method is defined. It takes the input from the textfields which has been stored in the position and velocity arrays and recalculates the position and velocity of the planet using Newton's law of gravitation.