The nice thing about applets is that they run on the client side. The browser downloads the applet to your local machine and runs it there. The speed with which an applet is run, is relatively high, as it will be running in your browser.
An applet exists as compiled bytecode (mostly) on some computer connected to a network anywhere in the world. As soon as your browser downloads the applet, the browser's Java interpreter interprets the bytecode and executes the bytecode instructions.
Bytecodes are the compiled source code of a Java program and they can't run on any machine directly, but have to be further verified and intrepreted by each computer.
As a simple illustration, taken from Latha Ramasamy's Project
Server side:
java code (*.java) -->|Compiler|--> Compiled Bytecodes (*.class file)
The Bytecodes travels across the network to the client:
Client side:
Bytecodes-->|Verifier|-->Verified code-->|Intrepreter|->Run applet
The code that you need to put in your HTML file is pretty short, and the syntax is as follows:
<APPLET> [CODEBASE = applet-url] CODE = applet-filename WIDTH = pixel-width HEIGHT = pixel-height [ALT = alternate-text] [NAME = applet-name] [ALIGN = alignment] [VSPACE = vertical-pixel-space] [HSPACE = horizontal-pixel-space] > [<PARAM NAME=parameter VALUE=value>] [<PARAM NAME=parameter VALUE=value>] .... [alternate-html] </APPLET>The following is an example of an HTML fragment that displays a text string:
<APPLET codebase="./textdir" code="MyTextApplet.class" width=300 height=200> <PARAM name=message value="Electronic Documents Course"> <PARAM name=font value=Courier> <PARAM name=point size value=25> </APPLET>The browser will find the applet with name "MyTextApplet", download it, and run it in the browser. It will show it in a 300 by 200 window and display the string "Electronic Documents Course" in a Courier font of point size 25.
Parameters are very handy, because they allow you to change the appearance of the applet without having to change and recompile the Java code, e.g. you can easily change the string that the MyTextApplet is displaying by changing the message parameter.
int point_size;
public void init() {
String ps;
ps = getParameter("point size");
if (ps == null) {
point_size = 12;
}
else {
point_size = Integer.parseInt(ps);
}
}
The method init() is the method that gets called first for an applet, so you do your initializations
here. This includes reading of parameter tags. The getParameter() method gets the value of the
point size and stores it in ps. Then ps is checked if it is null. This is done in case there
is no parameter called "point size" (remember parameters are optional). If
ps is null then the
point size is set to a default value (here 12), else the String is "parsed"
to get an Integer value.
The java.awt package provides an integrated set of classes to manage user interface components such as windows, dialog boxes, buttons, checkboxes, lists, menus, scrollbars, and text fields (AWT stands for Abstract Window Toolkit). The package's classes can be divided into three groups:
We will learn how the GUI components work in lecture 3. The Graphics class contains methods for basic drawing like drawLine, fillRect, drawString, and also methods for image retrieval and display. The graphics context is owned by the browser and passed to the applet in the paint() method.
Lets extend out HelloWorld example and draw an oval around the text: draw ovals around text.
Java supports GIF and JPEG image formats. The following code fragment reads in an image called "imagename.gif" and draws the image at location (x,y) on the screen:
Image img;
public void init() {
img = getImage(getDocumentBase(), "imagename.gif");
}
public void paint(Graphics g) {
g.drawImage(img, x, y, this);
}
The call to getImage, an Applet method, automatically creates an image. Thus, you need to
import the java.awt.Image class.
Double buffering is the technique of doing all your drawing into an offscreen buffer, and then copying the contents of the buffer to the screen all at once. This prevents flickering that would otherwise result from erasing and redrawing the figure. The buffer is an offscreen Image created with the createImage method from the java.awt package. To draw an image offscreen, you simply use its Graphics object, which is obtained with the getGraphics method of the java.awt.Graphics class. Once the drawing is complete in the offscreen image, the applet can draw it in its screen.
Compare the next two applets that just display an image (notice the flickering in the first applet): Without Double Buffering and With Double Buffering.
Clipping is the second important technique for smoother graphics. It often happens that only a small region of a larger area has to be erased and redrawn. However, the paint method only knows how to redraw the entire applet window, not small regions of it. We can set a small rectangular clipping region in the Graphics object we use. This would tell the system that it only needs to draw within the specified rectangle and that it can ignore any drawing outside of this rectangle. When we know the area of an applet that needs to be redrawn, we can specify a clip rectangle that surrounds the area and do a full redraw, knowing that the applet will only redraw the portion inside the clipping rectangle. This method of drawing leads to much faster and less flickering redrawing.
g.clipRect(r.x, r.y, r.width, r.height); g.drawImage(background, 0, 0, this);
As we have seen, within a Java applet you may find an init and a start function. Java calls the init function first and when init is done, Java calls start. When the applet uses Thread objects, the applet must call the Thread object's start function, which in turn will call the Thread object's run function. Unlike Java applets, Thread objects do not have an init function that executes first.
The applet's start method creates this animation thread and starts it by calling the thread's start() method. The stop() method stops the thread by calling stop() on it. The thread is created by passing the Applet object (i.e. this) to the thread constructor. This creates a thread that, when started, executes code in the run() method of the applet. The run() method is the method that performs the actual animation. For example, it draws an image, goes to sleep for a while by calling Thread.sleep(), and then loops to draw the next image. To create a thread which runs the applet's run function, the applet must support the Runnable interface. When you use the Runnable interface for a class, you tell Java that the class contains a run() function:
public class HelloAnim extends Applet implements Runnable {
Let's try to animate our HelloWorld example: HelloWorld animated.
The next applet is an example of animation with images: Image animation.
The way to solve these problems is to use a MediaTracker object, which is part of the java.awt package. The MediaTracker class is a utility class to trace the status of a number of media objects. Media objects could include images as well as audio clips (currently only images are supported). This class lets you register images and then call a method that blocks until they have completed loading. It also allows you to check for errors in the loading process. The drawback is that sometimes there is a significant wait.
Let's remove the flickering from our image animation example: ImageTracker.
For example, you want to draw a line, but are not sure what parameters it takes. Then go to this site, follow the java.awt package link, since drawLine is part of the java.awt.Graphics class. Once there follow the 1.20 Graphics Class link, and you will find the drawLine routine in there, and you will see that it takes four parameters. If you are still in doubt and want to know what the parameters mean, then follow the link off the drawLine method, which is labeled §1.20.16 for detailed explanation of what the parameters mean.
 |
 |
 |
|||