| CATEGORII DOCUMENTE |
| Asp | Autocad | C | Dot net | Excel | Fox pro | Html | Java |
| Linux | Mathcad | Photoshop | Php | Sql | Visual studio | Windows | Xml |
Packaging interactive content in small, easily distributed objects was a design feature that had high priority to the developers of Java. To meet this design goal, they created the Applet class, along with several objects and interfaces designed to simplify image and audio processing.
An Applet is a custom interface component object, similar in concept to a Windows custom control, or an X-Windows widget. Applet-aware applications (or 'applet browsers') can load and construct Applet objects from URLs pointing to .CLASS files anywhere on a network, including the Internet, the largest network of them all. The Java Developer Kit's (JDK) HotJava World Wide Web browser is an example of an applet-aware application. Using it, you can access interactive Applets from anywhere on the Internet, or Applets developed on the local file system. Security features of the Java language ensure distributed applets cannot damage or compromise the security of a local system.
Using the graphical capabilities of Java, applets are visually exciting multimedia elements. Through objects of the class java.awt, Graphics applets can create graphical on-screen content. The Graphics class is included in this chapter because of the need for applets to display exciting visuals.
Because of all these features, applets have become the preferred method for distributing interactive content on the World Wide Web. A library of reusable, extensible Applets is one of the cornerstones of an Internet content creator's toolkit.
The project for this chapter is an Applet implementation of
Figure 1-1 illustrates the Applet class hierarchy. Most ancestors of Applet in this hierarchy are Abstract Windows Toolkit (AWT) classes. Through them, the Applet class inherits windowing capabilities. Specifically, the Applets display, surface drawing, and mouse and keyboard event handling functionalities are gained through these ancestors. AWT's windowing capabilities are covered in Chapter 9. All examples and discussions in this chapter stop short of utilizing AWT methods other than those that provide applets with their graphical capabilities. But keep in mind the rich set of facilities the AWT classes have when designing your own custom Applet classes.
Figure 1-1 The Applet class hierarchy
Applet objects are created and controlled by a container application called an applet browser. The applet browser (see Figure 1-2) arranges applet objects visually on the screen and dedicates a rectangle of screen space for the applet to display itself. Most applet browsers can manage more than a single Applet object at a time, and actually provide an interface for the Applet instances to communicate with each other.
Figure 1-2 Example of an applet browser (JDK's AppletViewer)
with a Java Applet running
The actions of a custom Applet object are ruled by four essential methods: Applet.init, Applet.start, Applet.stop, and Applet.destroy. The browser itself invokes these methods at specific points during the applet's lifetime. The java.applet.Applet class declares these methods and provides default implementations for them. The default implementations do nothing. Custom applets override one or more of these methods to perform specific tasks during the lifetime of the custom Applet object. Table 1-1 lists these four methods, details when each is called by the browser, and shows what a custom applet's overriding implementation should do.
|
||||||||||||||
The proper place to allocate objects or load data required by the applet throughout its lifetime is init. This method is called only once during the lifetime of the applet, right after the object is created by the browser. Most custom Applets allocate resources required throughout the lifetime of the Applet object in this method. Another very common operation performed during init is to resize the applet's on-screen display surface using the inherited method Component.resize. Some browsers display applets correctly only if the applet calls resize() in init(). The Component class is described in Chapter 2.
Listing 1-1 defines an applet that plays an audio clip in a continuous loop. This applet could be used to play 'theme music' while a particular Web page was being viewed. Notice that the essential methods init, start, stop, and destroy are given overriding implementations to manage what the applet does in the browser.
Listing 1-1 Example applet
import java.Applet.*;The browser invokes the ThemeMusicApplet's start method when it is time to present information to the user, and ThemeMusicApplet.start begins playing the audio clip loaded in init. You can see why it is necessary for init to be invoked before any call to start: The audio clip must be loaded before it is played. init is always called before the first invocation of start.
When the applet drops from view, for example because it is scrolled off the screen in the browser or the user opens a different document in the browser, the applet's stop method is called. This is the proper time for a custom Applet to cease any processing. In our example, the continuous audio clip started in ThemeMusicApplet.start is halted in stop.
There are two more important technical notes about start and stop:
. Every call to start has a matching subsequent call to stop.
. The start/stop sequence may be repeated more than one time for the same custom Applet object, for example if the applet is scrolled from the user's view and then scrolled back. When it is scrolled from the user's view, stop will be invoked. When it is scrolled back, start will be invoked for the second time.
When the applet is finally and definitely to be unloaded from memory, destroy() is invoked. This is the appropriate time to delete any resources loaded during init(). The above example applet removes its reference to the AudioClip in destroy. The call to destroy is guaranteed to occur after the last call to stop. Note that while any resources allocated by an applet will automatically be cleaned up by Java's garbage collection facilities, it is more efficient to remove references to any allocated objects in destroy. Also note that resources allocated by 'native' methods will not be cleaned up by the garbage collection facilities. Native resources must be explicitly released in destroy. (Native methods are platform-specific, dynamically loadable libraries accessible from within Java code. For the most part, Applet classes do not use native methods because of the severe security constraints placed on Applet objects. Refer to Appendix C for more information about creating and using native methods in Java.) Figure 1-3 illustrates the sequence of calls to init, start, stop, and destroy by an applet browser.
Figure 1-3 Sequence of init, start, stop, and destroy calls
for an Applet
Similar to Java applications, applets can receive and process parameters. Applications receive parameters in the argv[ ] argument to the main method. The elements of argv[ ] are the command line arguments to the application. Analogous to argv[ ], applet parameters are accessed within the applet code by the Applet.getParameter method.
The use of parameters makes applets extensible. ThemeMusicApplet.init has the theme music relative URL 'audio/theme.au' hardcoded into the init method. This listing uses a replacement for init, which makes the ThemeMusicApplet applet play whatever audio file is passed in its 'Theme' parameter:
public void init()Conceptually, the browser maintains an internal listing of all the parameters passed to an embedded Applet object. The getParameter method accesses this internal list and retrieves the values specified for a uniquely named parameter. Our new listing uses the getParameter method to look up the value for the parameter named 'Theme'. If no such parameter was passed, getParameter would return null.
There is a method defined so that Applet objects can publish a list of valid parameter names, valid values, and a description of each. By overriding the Applet.getParameterInfo method, an Applet class can make this information public to any other object. The default implementation of getParameterInfo simply returns null, but an overriding implementation should return a String[n][3] 2-dimensional array where n is the number of unique parameters understood by members of the Applet class. Each row of three strings in this array should be of the format:
There is no strict requirement on the format of any one of these strings. Each one should be suitable for textual display so that someone can read it. For example, the 'valid value range' string could be '0-5', meaning the parameters should be an integer between 0 and 5. Listing 1-2 defines a small Applet class called AppletNames that displays, on System.out, a listing of all other active Applets currently being managed by the browser and a listing of each Applet object's parameter information retrieved using each Applet object's getParameterInfo method. This Applet class uses its AppletContext to access other active Applet instances. A detailed description of the AppleContext interface and methods follows this discussion of Applet parameters.
Listing 1-2 Example using the AppletNames class
import java.applet.*;Different types of browsers use different methods for passing parameters to applets. For example, applet-aware World Wide Web browsers generally use the HTML <APPLET> container tag to refer to applet code and parameters. Between the <APPLET> and </APPLET> container tags, zero or more <PARAM> tags can appear. These tags have the form <PARAM name=[param-name] value=[param-val]>. No matter how parameters are passed into a particular browser, a loaded applet always uses getParameter to retrieve parameter values.
Listing 1-3 is part of an HTML document with the ThemeMusicApplet embedded in it. The <APPLET> container refers to the ThemeMusicApplet's .CLASS file URL. The <PARAM> tag indicates which audio file to use ('audio/GilligansIsland.au').
Listing 1-3 HTML document
Applets obtain information about the state of the browser, what other Applet objects are currently active, what is the current document opened by the browser, and so on, through the java.applet.AppletContext interface. The browser is abstracted by an object implementing this interface.
The browser also exposes some functionalities that an applet can use through this interface. For example, the loading of image and audio files into Java objects is handled transparently through the AppletContext interface. The two overloaded versions of Applet.getAudioClip are actually shallow wrappers around AppletContext.getAudioClip. The full AppletContext interface is detailed in the API descriptions for this chapter.
Between the AppletContext and the Applet is an AppletStub object. Its purpose is to provide a pathway for the exchange of applet-specific data between the AppletContext and the Applet. For example, the parameters for a specific Applet object are accessed by the Applet through AppletStub.getParameter. Applet.getParameter is actually a shallow wrapper around this method. In turn, AppletStub methods are translated into native or custom AppletContext method calls (the implementation of the pathway of data exchange between the AppletStub and AppletContext is left completely up to the browser developers). An Applet's AppletStub is tightly wrapped by the java.applet.Applet implementation. So much so, that all AppletStub functionalities are exposed as wrapper methods in the java.applet.Applet class. Therefore, a custom applet should never need to use its AppletStub directly. Figure 1-4 illustrates the pathways of data exchange between the Applet, the browser (abstracted by the AppletContext interface), and the AppletStub (the Applet's representative to the browser).
Figure 1-4 Pathways of data exchange between the Applet,
AppletContext, and AppletStub objects
Much the same as applications, applets can create Threads to carry on background processing. A typical use of this would be an animation applet. To perform animation, the applet creates a new Thread and starts it running in start. The animation Thread acts as a timer. Every so often, it wakes and draws a new frame in the animation sequence, then suspends itself until the next frame is to be drawn. In the applet's stop method, the animation thread is shutdown. Two versions of this simple animation technique are described in greater detail in the section on the Graphics class and methods. The important point here is that Threads generally are made to begin background processing in an applet's start implementation and either suspended or destroyed in the applet's stop implementation.
You might assume that Threads created by an applet would be automatically halted by the browser when the applet is destroyed, so you wouldn't really need to suspend or destroy a Thread object explicitly in stop. Instead, you could just leave it to Java's garbage collection facilities to destroy your Thread when the Applet object is destroyed. Many browsers, however, do not properly halt secondary applet threads, even after the applet has been destroyed, so the thread continues to execute after the applet has been destroyed. This is a result of applets relying on the Java garbage collection facility to destroy their threads. To ensure your custom applets behave as you want them to, including ceasing when you want them to cease, suspend any secondary threads in Applet.stop, and drop references to them in destroy. As Listing 1-4 shows, the ClockTickApplet demonstrates using this technique in a multithreaded applet.
Listing 1-4 The ClockTickApplet sourcer
import java.applet.*;You can coordinate the activities of several applets by accessing and manipulating other Applet objects from within Applet code. Using inter-applet communications you could, for instance, have a 'gas-gauge' Applet report the status of another Applet, which takes a significant amount of time to initialize.
To obtain references to external Applets from within an applet you use the AppletContext's getApplet and getApplets methods. The AppletNames Applet demonstrates this technique. Once a reference to another Applet is retrieved, your applet code can access any public member variable or method of the external Applet object. This code snippet retrieves an applet named 'MyApplet' and calls one of its custom methods.
Applet applet = getAppletContext().getApplet( 'MyApplet' );getApplet takes an applet 'name' and returns a reference to the associated Applet object. This usage model implies the browser internally stores a unique String name associated with each applet, which can be used to look up the Applet in the internal browser storage.
Similar to defining applet parameters, the method for naming applets depends on the specific browser used. For example, applet-aware World Wide Web browsers generally use a NAME field within the HTML <APPLET> container tag to associate a name with a particular Applet object. This is how an HTML document would embed an applet named 'Minnow' of class ThreeHourTouringBoat:
Applets are capable of displaying exciting and complex graphics and multimedia visuals. This section explains the specifics of graphical drawing, which is done using objects of the Graphics class and associated classes. Important concepts explaining these classes will be discussed, as well as the most common technique for visual animation, double-buffered graphics.
All graphical drawing operations in Java are performed through objects derived from the Graphics class. Whether you are drawing images downloaded from the Internet, drawing graphical primitives such as rectangles and arcs, or rendering text, all graphical operations are done using a Graphics class instance. Use of the Graphics class is not limited to Applets; it is also used for Java applications that employ graphical elements in windows.
For some beginners, the concept of the Graphics class is a little diffucult to grasp. But it doesn't have to be. You can think of a Graphics object as analogous to a graphic artist's drafting table, with its associated drawing tools. It is a station of powerful tools dedicated to creating graphical images.
Each Graphics object is associated with a two-dimensional 'drawing surface,' analogous to the piece of paper on the drafting table. For example, the drawing surface can be a rectangle of a user's on-screen desktop, as is the case when dealing with Applets or Windows. Other drawing surface types could also be associated with a Graphics object. The drawing surface could be a binary image, stored in memory and never directly displayed to the user. It could also be a page in a printer, or a fax machine, or even a PostScript or other graphics-format file stored on a disk.
The 'tools' of a Graphics object, the methods of the Graphics class, are used to draw onto the associated drawing surface. Rectangles, ovals, arcs, polygons, lines, text, and images can all be drawn onto the drawing surface using the various Graphics class methods.
The internal state of a Graphics object can be described by eight state variables, which can be modified using Graphics class methods.
. The foreground color
. The background color
. The current font
. The painting mode
. The origin of the Graphics object
. The horizontal and vertical scaling factors
. The 'clipping' rectangle
. The drawing surface the Graphics object has been associated with
All drawing surfaces use the same two-dimensional coordinate system. The X axis is in the horizontal direction of the drawing surface, and increases from left to right on the drawing surface. The Y axis is in the vertical direction, and increases from top to bottom.
The Graphics object origin defines where its X and Y axes cross, and is identified by the point (0,0). A scaling factor is assigned to both axes, which defines how quickly the coordinates increase along either axis. By default, when the Graphics object is first created, the origin lies in the upper-left corner of the drawing surface, and the scaling factor along both axes is one.
The Graphics object's X and Y axes stretch to what is essentially an infinite distance in all four directions. However, only coordinates within the Graphics object's 'clipping rectangle' are of any interest. That's because graphical operations cannot be performed outside this rectangle. Such operations will not result in any sort of error, but neither will they have any effect on the drawing surface.
The clipping rectangle of a Graphics object represents the physical boundaries of the associated drawing surface. For example, a Graphics object associated with a 100 pixel by 100 pixel rectangle of the on-screen desktop will have a clipping rectangle with a width of 100 and a height of 100. For on-screen desktop and in-memory image drawing surfaces, each Graphics coordinate represents a single pixel of the drawing surface. Hence, a 100 pixel by 100 pixel rectangle is represented by a 100 by 100 clipping rectangle in the associated Graphics object.
A program cannot create its own Graphics objects, but instead must ask the Java runtime system to create them for specific display surfaces. Without using custom classes implementing native methods, only two types of display surfaces can be accessed through Graphics objects:
. Sections of the on-screen desktop surface are accessed through Graphics objects passed to the update and paint methods.
. In-memory Image objects are accessed through Graphics objects created by Image.createGraphics.
Applets inherit the update and paint methods from the Component class, which the Applet class extends. Both of these methods are called automatically by the Java runtime system when it is time to display information to the user on the desktop. (See Chapter 2, The Component Class, for an in-depth discussion of the update and paint methods). This code snippet shows how a custom applet would override the default implementation of paint to control its display surface:
public class MyApplet extends AppletA Graphics object is automatically created by the Java runtime system and passed to paint. This Graphics object has a clipping rectangle set to the exact dimensions of the Applet's display surface. (In the cases where only a portion of the Applet must be redrawn, such as when another window temporarily covers part of the Applet's display surface, the dimensions may be smaller.)
The only other method for obtaining a Graphics object is using Image.createGraphics. An applet or application calls this method directly. The Graphics object that is returned is capable of rendering geometric primitives, text, and other Image objects onto the Image. This is useful for the so-called 'double-buffered' drawing technique, used widely to effect a smooth transition between animation frames. You'll learn more about this technique in the upcoming discussion of animation.
All Graphics objects are able to render several different types of geometric primitive drawing objects on a drawing surface. Table 1-2 lists the various geometric primitives and describes how they are represented by parameters to Graphics rendering methods.
|
||||||||||||||||||||
All primitives can be rendered in either outlined or filled form, except the Line primitive, which cannot be filled. The outlined version of a primitive is rendered using the primitive's 'draw' method. For example, Graphics.drawRect will render a rectangle as two sets of parallel lines using the Graphics object's current foreground color. The 'fill' method is used to render a filled geometric primitive. Graphics.fillRect will render a solid rectangular block on the display surface using the current foreground color. Listing 1-5 is a complete example of the Nautilus applet, which uses a succession of filled and outlined arc segments (using Graphics.fillArc and Graphics.drawArc) to draw a spiral pattern. The spiral looks something like the cross-section of a nautilus shell, hence the applet class' name.
Listing 1-5 Example of the Nautilus applet
import java.applet.Applet;The Nautilus applet requires a single parameter, the 'tightness' parameter, which describes how tightly the spiral is rendered. The 'tightness' parameter's value is a floating point number above 0 and below 1. The closer to 1 this parameter is, the tighter the spiral is. Note that, to preserve code readability, no validation of this parameter has been added. Figure 1-5 is a screenshot of the Nautilus applet run using the JDK's AppletViewer, with a 'tightness' parameter of 0.75.
Figure 1-5 Screenshot of the Nautilus applet
The Nautilus applet illustrates how to use the drawArc and fillArc methods of the Graphics class. Nautilus renders the spiral by drawing successively smaller half-circles made up of alternately colored arc wedges. The code takes advantage of the fact that the sign of the arc length parameter to Graphics.drawArc and Graphics.fillArc defines whether the arc proceeds clockwise or counter-clockwise from the starting angle.
The painting mode of a Graphics object is, by default, set to 'overwrite' mode. In this mode, all graphics are rendered by overwriting the pixels of the display surface using the Graphics object's current foreground color. You can force the Graphics object into overwrite mode using Graphics.setPaintMode. When called, this parameterless method places the Graphics into overwrite mode. Expressed pseudo-mathematically, the color of destination pixels after rendering is
colorDest(x,y) = graphics.foregroundColorThe other method of modifying a Graphics object's painting mode is Graphics.setXORMode. When called, the Graphics object uses XOR mode for rendering geometric primitives, text, or Images on the drawing surface. Three colors are combined mathematically to determine the color of destination pixels after rendering, as follows,
colorAfterRendering(x,y) = colorBeforeRendering(x,y)where the ⊗ symbol represents a bitwise XOR operation. The alternateColor of a Graphics object is specified as the only parameter to Graphics.setXORMode. Listing 1-6 is an example of the Ovals applet, which illustrates XOR painting mode, that can be used to draw contrasting areas of geometric primitives on the drawing surface.
Listing 1-6 Example of the Ovals applet
import java.applet.Applet;Figure 1-6 is a screenshot of Listing 1-6, the Ovals applet, when viewed using the JDK's AppletViewer.
Figure 1-6 Screenshot of Ovals applet, demonstrating the XOR
painting mode of the Graphics class
The Ovals applet uses XOR painting mode to highlight overlapping areas of oval primitives on the drawing surface. The background color of the applet's drawing surface is automatically painted light gray (Color.lightGray or RGB 192, 192, 192) by the Java runtime system.
The foreground color of the Oval's Graphics object is set to Color.black (RGB 0, 0, 0) by default. The XOR alternate color is set to Color.white (RGB 255, 255, 255), the value of the parameter to Graphics.setXORMode. Therefore, the color in which the first oval is rendered can be deduced using the formula presented earlier.
colorAfterRendering(x,y) = colorBeforeRendering(x,y)When a new oval is rendered so that it intersects an oval that has already been drawn, the intersecting area of these two ovals will be drawn with the color obtained as follows:
colorAfterRendering(x,y) = colorBeforeRendering(x,y)In this case the result is Color.lightGray.
It is simple to show that all areas painted with the XOR painting mode using these colors an odd number of times will have the RGB values (63, 63, 63), which is Color.darkGray. All areas painted an even number of times will have the RGB values (192, 192, 192), or Color.lightGray.
Table 1-3 lists the classes and interfaces necessary for developing custom Applet objects in Java. The following sections describe each Class' methods in more detail.
|
||||||||||||
AppletContext
Purpose
An interface which abstracts the browser to an Applet. Methods for testing and modifying the current state of the browser are provided as public members of this interface.
Syntax
interface AppletContext
Description
A running Applet gets its AppletContext using Applet.getAppletContext. Using this interface, the Applet can get and set some parameters of the browser's current state. An Applet can get references to other Applets currently running in the browser, download images and audio clips, and load a new document into the browser through the AppletContext interface.
PackageName
java.applet
Imports
java.awt.Image, java.awt.Graphics, java.awt.image.ColorModel, java.net.URL, java.util.Enumeration
Constructors
None.
Parameters
None.
getApplet
Interface
AppletContext
Purpose
Used to facilitate inter-applet communications within a browser.
Syntax
public Applet getApplet( String strName );
Parameters
None.
String strName
This interface method implies the browser stores, with each loaded applet, a unique string to identify that applet. It passes to getApplet one of these unique applet identifiers to gain access to the associated Applet object.
Description
Multiple Applet objects can be simultaneously loaded and run by the same browser. Each applet runs within its own Thread. Use this method to access other applets running concurrently. It is completely up to a particular browser how to associate a particular string with an Applet object. For example, most commercial-grade World Wide Web browsers which are applet-aware use the NAME tag in the <APPLET> container tag to associate a name string with a particular applet, as in the HTML snippet below.
Imports
None.
Returns
The Applet object associated with the unique String strName. If no applet is associated with strName, null is returned or if the applet browser does not provide facilities for inter-applet communications.
See Also
The getApplets method of the AppletContext interface
Example
The following example tries to find a set of other applets loaded by the browser. A report is written out to System.out indicating whether or not each applet could be found. The 'applet-list' parameter contains a comma-separated list of applet names to look for. Only up to ten applets will be searched.
import java.applet.*;getApplets
Interface
AppletContext
Purpose
Used to facilitate inter-applet communications within a browser.
Syntax
public Enumeration getApplets();
Parameters
None.
Description
This method allows you to look up all applets currently running in the browser. The browser which implements this method will give you access to all Applet objects currently running in the browser.
Imports
None.
Returns
An Enumeration object is returned. Each element in the Enumeration is an Applet currently active in the browser. Note that an empty Enumeration, or a return of null, could be interpreted in two ways: Either getApplets() is not fully implemented by the browser, or no other applets are active in the browser.
No exact specification currently exists describing what getApplets should return in either of these situations.
See Also
The getApplet method of the AppletContext interface
Example
The following example uses getApplets and a custom interface, named Namable, to implement an applet-identification facility more complete than the AppletContext facility provided by getApplet and getApplets.
interface NamableHere are the contents of FindNamableApplet.java:
public class FindNamableApplet extends Applet implements NamablegetAudioClip
Interface
AppletContext
Purpose
Loads an audio file and readies it to be played by the browser.
Syntax
public AudioClip getAudioClip( URL url );
Parameters
URL url
Points to an audio data file to be loaded by the browser.
Description
Commercial-grade browsers, especially World Wide Web browsers, have built-in facilities for loading and playing audio files. Applets use the getAudioClip method to load audio files from any URL the browser can understand. Applets should use one of the overloaded Applet.getAudioClip methods to access AudioClips instead of AppletContext.getAudioClip. This method is rarely called by an Applet directly.
Imports
java.net.URL
Returns
The object returned by this function implements the AudioClip interface. If the URL is not understood by the browser, null will be returned or if the browser does not provide this functionality to applets.
Example
See the Applet.getAudioClip code example. Applet.getAudioClip is implemented as a simple pass-through to AppletContext.getAudioClip, similar to this code sample:
public Applet extends Panel|
getImage Interface AppletContext Purpose To load an image from a URL and prepare it for rendering on a display surface. Syntax public Image getImage( URL url ); Parameters URL url Points to an image file to be loaded by the browser. Description Java applications must implement methods for reading and interpreting image files, and converting the image data into Image objects. Applets may have this functionality exposed to them by the browser through the AppletContext.getImage method. Browsers that can load and interpret various image formats, such as GIF, JPEG or TIFF, can provide that capability to applets. Applets simply provide a URL pointing to an image file in a recognized format. No methods are provided for an applet to query which image formats are supported by a browser. Therefore, it is usually a good idea to only try to load images in very common graphics formats, such as GIF or JPEG. Imports java.awt.Image Returns An Image object will be returned by this object, or null if this facility is not supported by the browser. The reaction of this method when the URL refers to an unsupported protocol, or when the image file format is unrecognized, is unspecified. Generally, it can be assumed that null will be returned if this capability it not provided by the browser. See Also The Image class Example The following sample applet loads and displays an image. A relative URL to the image to be loaded is passed to the applet as the 'image' parameter. That parameter will be interpreted relative to the URL returned by Applet.getDocumentBase. An object of the MyImageObserver class is needed to receive an error message if there is a problem with loading or displaying the image. import java.applet.*;import java.awt.*; class MyImageObserver implements ImageObserver public class ImageApplet extends Applet // Load the image. image = getAppletContext().getImage( getDocumentBase(), strRelativeURL ); if( null == image ) System.out.println( 'Unable to load image.' ); } public void destroy() public void paint( Graphics g ) showDocument Interface AppletContext Purpose Opens a new document in the browser. An overloaded version exists to specify the name of the target browser frame. Syntax public void showDocument( URL url ); public void showDocument( URL url, String target ); Parameters URL url Points to the document to be opened by the browser. If the protocol referred to by the URL is not recognized by the browser, this call will be ignored. If the document format implied by the URL's file name is not recognized by the browser, this call will be ignored. String target You may specify a named browser-frame for the new document to appear in. Table 1-4 lists the valid values for this parameter
Description In the abstract, Applets are seen as being embedded in distributed 'documents,' such as World Wide Web pages. When implemented, this method allows the applet to force the browser to open a particular document pointed to by a URL. Like all other methods in this interface, a particular browser may not implement this method, in which case the browser will simply ignore a call to this method. If the second overloaded version of this method is used, then the document will be opened in a browser frame with the same name as the target parameter. Imports java.net.URL Returns The Applet object associated with the unique String strName. If no applet is associated with strName, null is returned or if the applet browser does not provide facilities for inter-applet communications. See Also The getDocumentBase method of the Applet class Example This applet asks the browser to reload the current document whenever the Applet's stop method is invoked. (Not generally a very nice thing to do.) public class RestartingApplet extends Applet
|
|||||||||||||||||||||
|
|
Products | Contact Us |
About Us | Privacy | Ad Info | Home
|
Graphics
Purpose
An AWT Component (such as an Applet) uses a Graphics object to draw on a display surface.
Syntax
public class Graphics
Description
A Graphics object is always associated with a 'display surface.' The display surface can be a rectangle of the on-screen desktop, an Image in memory, or potentially any rectangular area that can be drawn on. You use the Graphics class methods to render graphics and text on the display surface assoicated with the Graphics object. Figure 1-7 shows the class diagram for the Graphics class.
PackageName
java.awt
Imports
java.awt.*, java.image.ImageObserver
Constructors
None. You cannot create Graphics objects directly, but instead get them from other Java API methods. For example, Image.getGraphics returns a Graphics object, which uses the Image as its drawing surface.
Parameters
None.
Figure 1-7 Class diagram for the Graphics class
clearRect
ClassName
Graphics
Purpose
To erase the specified rectangle using the background color of the display surface associated with the Graphics object.
Syntax
public abstract void clearRect(int x, int y, int width, int height);
Parameters
int x, int y, int width, int height
These four parameters define the rectangle to be erased on the display surface.
Description
This method is used to erase a rectangle from the display surface. The associated display surface's background color is used to fill the specified rectangle. This is a legacy method which was never removed from the alpha release of Java. Use of this method is not advised. Instead, use Graphics.fillRect, specifying the color you want to use to erase the rectangle. It is an unfortunate but true fact that the Java API does not specify an overloaded version of this method which takes a Rect object as a parameter. The origin and extent of the rectangle must be explicitly provided in the four parameters to this method.
Imports
None.
Returns
None.
See Also
The fillRect method of the Graphics class
Example
Use of this method is not advised, so an example is not provided.
clipRect
ClassName
Graphics
Purpose
To shrink the clipping rectangle of the Graphics object.
Syntax
public abstract void clipRect(int x, int y, int width, int height);
Parameters
int x, int y
These four parameters define the new clipping rectangle for the Graphics object.
int width
int height
Description
Use this method to modify the clipping rectangle of the Graphics object. The clipping rectangle restricts drawing on the drawing surface to within the rect. The resultant clipping rectangle is the intersection of the current clipping rect and the new one defined by the parameters passed to this method. That is, the clipping rectangle can never be made larger, only smaller. This is to prevent ill-behaved Components from enlarging their clipping rectangles to include the entire desktop and then drawing all over the desktop. The clipping rectangle is one of the internal state variables of all Graphics objects.
Imports
None.
Returns
None.
See Also
The create method of the Graphics class
Example
public class MyApplet extends AppletcopyArea
ClassName
Graphics
Purpose
Copies a rectangle of the display surface to a new location on the display surface.
Syntax
public abstract void copyArea(int x, int y, int width, int height, int dx, int dy);
Parameters
int x, int y, int width, int height
These four parameters define the source rectangle to copy from.
int dx
The origin of the target rectangle.
int dy
Description
Copies the pixels of a rectangle of the display surface to another rectangle of the same display surface. Note that the source rectangle may reside outside the clipping rectangle of the Graphics object.
Imports
None.
Returns
None.
See Also
The drawImage method of the Graphics class
Example
This example clears the target area by using the XOR drawing mode of the Graphics object. The target rectangle will be painted with the alternate XOR color after the operation is complete.
public void paint(Graphics g)create
ClassName
Graphics
Purpose
Creates a copy of this Graphics object.
Syntax
public abstract Graphics create();
public abstract Graphics create(int x, int y, int width, int height );
Parameters
int x, int y, int width, int height
These parameters define the display surface of the returned Graphics object. The resultant clipping rectangle will be equal to the intersection of the original Graphics object's clipping rectangle and the rectangle defined by these parameters.
Description
Creates a clone of the original Graphics object, attached to the same display surface and with the same internal state as the original Graphics object. The second overloaded version makes a new Graphics object attached to a specific rectangle of the original Graphics object's display surface. As the example below illustrates, the create method is most useful when you want to shrink the clipping rectangle, but get the original, larger clipping rectangle back later.
Imports
None.
Returns
A Graphics object is returned which is a clone of the original. If the second overloaded version of this method is used, then the clipping rectangle of the resultant Graphics object will be equal to the intersection of the clipping rectangle of the original Graphics and the rectangle defined by the parameters to this method. Also, the origin of the resultant Graphics object will be at the point defined by the x and y parameters to this method.
See Also
The clipRect method of the Graphics class
Example
This example uses the create method to temporarily shrink the clipping rectangle of a Graphics object.
public void paint(Graphics g)translate
ClassName
Graphics
Purpose
Moves the origin of the Graphics' coordinate system.
Syntax
public abstract void translate(int x, int y);
Parameters
int x, int y
These two parameters define a point which is the new origin of the display surface. The parameters are offsets from the original Graphics object's origin.
Description
Modifies the origin of the Graphics object. The origin is one of the internal state variables of Graphics objects.
Imports
None.
Returns
None.
Example
public void paint(Graphics g)draw3DRect
ClassName
Graphics
Purpose
Renders a raised or depressed rectangle on the Graphics' display surface.
Syntax
public void draw3DRect(int x, int y, int width, int height, boolean raised);
Parameters
int x, int y, int width, int height
The dimensions of the rectangle to be rendered on the display surface
boolean raised
This parameter tells whether the beveling should imply a raised or depressed effect for the 3D rectangle.
Description
Renders a rectangle with beveled edges to create a 3D visual effect. The beveling can either imply a raised or depressed 3D rectangle. The shades of the beveling are choosen based on the current drawing color of the Graphics object. The darker shading will be roughly 70 percent as bright as the current drawing color. The lighter color will be roughly 140 percent as bright as the current drawing color. The beveling will be exactly one pixel wide.
Imports
None.
Returns
None.
See Also
The fill3DRect and drawRect methods of the Graphics class
Example
public void paint(Graphics g)drawArc
ClassName
Graphics
Purpose
Renders the arc of an oval's wedge on the Graphics' display surface.
Syntax
public abstract drawArc(int x, int y, int width, int height, int startAngle, int arcAngle);
Parameters
int x, int y, int width, int height
The dimensions of the rectangle bounding an oval. The arc is taken as part of the circumference of this oval.
int startAngle
Measured in degrees, this defines the start of the arc. Zero degrees lies in the '3 o'clock' position.
int arcAngle
Measured in degrees, the distance of the arc around the oval. A positive value indicates a counter-clockwise direction around the oval. Negative indicates clockwise.
Description
Renders an arc of an oval on the display surface. The oval is defined by a bounding rectangle, and the arc is described by a starting and stopping angle in degrees.
Imports
None.
Returns
None.
See Also
The fillArc method of the Graphics class
Example
See the Nautilus example applet earlier in the chapter.
drawBytes
ClassName
Graphics
Purpose
Renders an array (or subarray) of bytes that are interpreted as ASCII character values, on the Graphics' display surface.
Syntax
public abstract void drawBytes(byte data[ ], int offset, int length, int x, int y);
Parameters
byte data[ ]
The array of byte data of ASCII characters to render on the display surface.
int offset
The zero-based index of the first character to render.
int length
The number of ASCII characters to render.
int x
The horizontal offset from the origin to render the characters on the drawing surface.
int y
The vertical offset of the baseline where the text is to be rendered. This is measured from the current origin of the Graphics context.
Description
drawBytes renders text on the drawing surface taken from a subarray of an array of bytes. The bytes are interpreted as 8-bit ASCII character values. The current font and drawing color of the Graphics is used to render the text.
Imports
None.
Returns
None.
See Also
The drawString, drawChars, and setFont methods of the Graphics class
Example
public void paint(Graphics g)drawChars
ClassName
Graphics
Purpose
Renders an array of ASCII characters on the drawing surface. The array can be a subarray of a larger set of characters.
Syntax
public abstract void drawChars(char data[ ], int offset, int length, int x, int y);
Parameters
char data[ ]
The array of ASCII characters to render on the display surface.
int offset
The zero-based index of the first character to render.
int length
The number of ASCII characters to render.
int x
The horizontal offset from the origin to render the characters on the drawing surface.
int y
The vertical offset of the baseline where the text is to be rendered. This is measured from the current origin of the Graphics context.
Description
drawChars renders text on the drawing surface taken from a subarray of an array of characters. The array values are interpreted as ASCII character values. The Graphics object's current font and drawing color are used to render the characters on the Graphics' display surface.
Imports
None.
Returns
None.
See Also
The drawBytes, drawString, and setFont methods of the Graphics class
Example
public void paint(Graphics g)drawImage
ClassName
Graphics
Purpose
Renders an Image on the Graphics object's display surface.
Syntax
public abstract boolean drawImage(Image img, int x, int y, ImageObserver observer);
public abstract boolean drawImage(Image img, int x, int y, int width, int height, ImageObserver observer);
Parameters
Image img
The Image object to be displayed.
int x, int y
The coordinate of the upper-left corner of the image on the drawing surface
int width, int height
Using the second overloaded version of this method, you can specify the size of the target rectangle to copy the Image to. By using a different size than the original Image object, you can stretch/shrink the Image on the drawing surface.
ImageObserver observe
Notifies whether the image is complete or not. (See comments)
Description
The passed Image is copied to the drawing surface. The second overloaded version of this method allows you to stretch/shrink the Image on the drawing surface. The ImageObserver is notified about progress of copying the image to the drawing surface. This is useful especially if the Image object is created from a URL pointing to a .GIF or other graphics-format on the network. If, for example, the URL does not actually point to an image, or to an incomplete image file, the ImageObserver object is notified. This results in a little more overhead in coding, but the increase in coding results in more robust applets and applications. Note that all Components, including all Applets, automatically implement the ImageObserver interface. The default implementation of this interface causes the Component to be repainted whenever an update of the image is read in.
Imports
None.
Returns
None.
See Also
The getImage method of the Applet class; the getImage method of the Toolkit class; the ImageObserver interface; and the MediaTracker class
Example
This applet creates an image from a URL in its init implementation. In paint, that image is rendered twice on the applet's display surface, once at the Image's default size, and a second time stretched to fit the entire surface of the Applet.
public class MyApplet extends AppletdrawLine
ClassName
Graphics
Purpose
Renders a line between two points on the Graphics object's display surface.
Syntax
public abstract void drawLine(int x1, int y1, int x2, int y2);
Parameters
int x1
One endpoint of the line segment to render on the drawing surface.
int y1
int x2
Other endpoint of the line segment to render on the drawing surface.
int y2
Description
Renders a line between the two points on the drawing surface. The current drawing color is used to render the line. Note that there is no way, using the Java API, to specify lines with a width greater than one pixel. To achieve wide lines, you must render multiple side-by-side lines on the display surface.
Imports
None.
Returns
None.
Example
The example uses the current drawing color to render a 5x5 grid on the Graphics' clipping rectangle.
public void paint(Graphics g)drawOval
ClassName
Graphics
Purpose
Renders an oval defined by a bounding rectangle.
Syntax
public abstract void drawOval(int x, int y, int width, int height);
Parameters
int x, int y, int width, int height
These parameters define the bounding rectangle of the oval.
Description
Renders an oval on the display surface. The oval is defined as being bound by the four sides of the rectangle described by the input parameters to this method. The color of the resulting oval is the current drawing color of the Graphics object.
Imports
None.
Returns
None.
See Also
The fillOval method of the Graphics class
Example
See the Ovals example applet earlier in this chapter.
drawPolygon
ClassName
Graphics
Purpose
Renders a polygon on the Graphics object's display surface.
Syntax
public abstract void drawPolygon(int xPoints[ ], int yPoints[ ], int nPoints);
public void drawPolygon(Polygon p);
Parameters
int xPoints[ ], int yPoints[ ]
These two arrays describe an ordered set of points which define the vertices of a polygon to be rendered on the drawing surface.
int nPoints
The number of vertices of the polygon to be rendered. This is also the number of elements in both the xPoints[ ] and yPoints[ ] arrays.
Polygon p
A Polygon object which describes the polygon to be rendered on the drawing surface
Description
Two overloaded versions of this method, both allow you to render a multisided polygon on the drawing surface. The logic of the rendering algorithm automatically closes the polygon by connecting the last point of the polygon to the first.
Imports
None.
Returns
None.
See Also
The fillPolygon method of the Graphics class; the Polygon class
Example
public void paint(Graphics g)drawRect
ClassName
Graphics
Purpose
Renders a simple rectangle on the drawing surface.
Syntax
public abstract void drawRect(int x, int y, int width, int height);
Parameters
int x, int y, int width, int height
These parameters define the rectangle to be rendered on the drawing surface.
Description
Renders the rectangle defined by the four parameters on the Graphics' display surface. Use drawRect(rect.x, rect.y, rect.width-1, rect.height-2) to render the outline of a particular Rect object. The rectangle is rendered using the Graphics' current drawing color.
Imports
None.
Returns
None.
See Also
The fillRect method of the Graphics class
Example
public void paint(Graphics g)|
drawRoundRect ClassName Graphics Purpose Renders a rectangle with rounded corners on the Graphics' display surface. Syntax public abstract void drawRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight); Parameters int x, int y, int width, int height These parameters define the rectangle to be rendered on the drawing surface. int arcWidth, int arcHeight These two parameters define the width and height of the arcs that are each of the rounded corners. These number are both interpreted as the diameters of the arc at the four corners. So the width and height of the arc at each corner are 1/2 of the arcWidth and arcHeight parameters, respectively. Description Renders a rectangle with rounded corners on the drawing surface. Through the parameters to this method, both the width and height of the corner arcs can be defined. The outline of the rectangle is rendered using the current drawing color of the Graphics object. Imports None. Returns None. See Also The fillRoundRect method of the Graphics class Example public void paint(Graphics g)drawString ClassName Graphics Purpose Renders a string of text on a drawing surface using the Graphics' current font and drawing color. Syntax public abstract void drawString(String str, int x, int y); Parameters String str String containing the text to be rendered on the drawing surface. The entire string will be rendered. To render a substring of a String object, use either the drawBytes or drawChars Graphics methods. int x The horizontal offset from the origin to render the String on the drawing surface. int y The vertical offset of the baseline where the text is to be rendered. This is measured from the current origin of the Graphics context. Description Draws the full String using the current font and drawing color. The left-most point of the baseline is indicated by the x and y parameters. Imports None. Returns None. See Also The drawBytes, drawChars, and setFont methods of the Graphics class fill3DRect ClassName Graphics Purpose Renders a filled, raised, or depressed rectangle on the Graphics' display surface. Syntax public void fill3DRect(int x, int y, int width, int height, boolean raised); Parameters int x, int y, int width, int height These parameters define the dimensions of the rectangle to draw on the display surface. boolean raised This parameter tells whether the beveling should imply a raised or depressed effect for the 3D rectangle. Description Renders a rectangle with beveled edges to create a 3D visual effect. The beveling can either imply a raised or depressed 3D rectangle. The shades of the beveling are choosen based on the current drawing color of the Graphics object. The darker shading will be roughly 70 percent as bright as the current drawing color. The lighter color will be roughly 140 percent as bright as the current drawing color. The beveling will be exactly one pixel wide. The inside of the rectangle will be filled using the current drawing color of the Graphics object. Imports None. Returns None. See Also The draw3DRect and fillRect methods of the Graphics class Example public void paint(Graphics g)fillArc ClassName Graphics Purpose Renders a wedge of an oval on the Graphics' display surface. Syntax public abstract fillArc(int x, int y, int width, int height, int startAngle, int arcAngle); Parameters int x,int width, int height The dimensions of the rectangle bounding an oval. The arc is a wedge of int y this oval. int startAngle Measured in degrees, this defines the start of the arc. 0 degrees lies in the '3 o'clock' position. int arcAngle Measured in degrees, the distance of the arc around the oval. A positive value indicates a counter-clockwise direction around the oval. Negative value indicates a clockwise direction. Description Draws a wedge of an oval. The oval is defined by a bounding rectangle, and the wedge is described by a starting and stopping angle in degrees. Imports None. Returns None. See Also The drawArc method of the Graphics class Example See the Nautilus example Applet earlier in the chapter.
|
|
|
Products | Contact Us |
About Us | Privacy | Ad Info | Home
|
fillOval
ClassName
Graphics
Purpose
Renders a filled oval defined by a bounding rectangle.
Syntax
public abstract void fillOval(int x, int y, int width, int height);
Parameters
int x, int y, int width
These parameters define the bounding rectangle of the oval to be rendered.
int height
Description
Renders a filled oval on the display surface. The oval is defined as being bound by the four sides of the rectangle described by the input parameters to this method. The color of the resulting oval is the current drawing color of the Graphics object.
Imports
None.
Returns
None.
See Also
The drawOval method of the Graphics class
Example
See the Ovals example Applet earlier in this chapter.
fillPolygon
ClassName
Graphics
Purpose
Renders a filled polygon on the Graphics object's display surface.
Syntax
public abstract void fillPolygon(int xPoints[ ], int yPoints[ ], int nPoints); public void fillPolygon(Polygon p);
Parameters
int xPoints[ ], int nPoints, int yPoints[ ]
These two arrays describe an ordered set of points which define the vertices of a polygon to render on the drawing surface.
The number of vertices of the polygon to be rendered. This is also the number of elements in both the xPoints[ ] and yPoints[ ] arrays.
Polygon p
A Polygon object which describes the polygon to render on the drawing surface.
Description
Two overloaded versions of this method both allow you to render a multisided polygon on the drawing surface. The logic of the rendering algorithm automatically closes the polygon by connecting the last point of the polygon to the first. The odd-even filling algorithm is used to fill polygons. So for complex polygons, internal areas may or may not get filled. The general rule of thumb is that an area will be filled if a line segment drawn from outside the polygon to the area within the polygon crosses an odd number of the polygon's line segments. If an even number is crossed, then the area will not be filled. For example, the center of a pentagram would not get filled, while each of the five arms of the pentagram would get filled.
Imports
None.
Returns
None.
See Also
The drawPolygon method of the Graphics class, the Polygon class
Example
public void paint(Graphics g)fillRect
ClassName
Graphics
Purpose
Renders a simple filled rectangle on the drawing surface.
Syntax
public abstract void fillRect(int x, int y, int width, int height);
Parameters
int x, int y, int width, int height
These parameters define the rectangle to render on the drawing surface.
Description
Renders the filled rectangle described by the four parameters on the Graphics' display surface. Use drawRect(rect.x, rect.y, rect.width-1, rect.height-2) to render a particular Rect object. The rectangle is rendered using the Graphics' current drawing color.
Imports
None.
Returns
None.
See Also
The drawRect method of the Graphics class
Example
public void paint(Graphics g)fillRoundRect
ClassName
Graphics
Purpose
Renders a filled rectangle with rounded corners on the Graphics' display surface.
Syntax
public abstract void fillRoundRect(int x, int y, int width, int height, int arcWidth, int arcHeight);
Parameters
int x, int y, int width, int height
These parameters define the rectangle to render on the drawing surface.
int arcWidth, int arcHeight
These two parameters define the width and height of the arcs that are each of the rounded corners. These numbers are both interpreted as the diameters of the arc at the four corners. So the width and height of the arc at each corner is 1/2 of the arcWidth and arcHeight parameters, respectively.
Description
Renders a filled rectangle with rounded corners on the drawing surface. Through the parameters to this method, both the width and height of the corner arcs can be defined. The rectangle is rendered using the current drawing color of the Graphics object.
Imports
None.
Returns
None.
See Also
The drawRoundRect method of the Graphics class
Example
public void paint(Graphics g)getClipRect
ClassName
Graphics
Purpose
Returns a Rect whose members are set to the origin and dimensions of the current clipping rectangle for this Graphics object.
Syntax
public abstract Rectangle getClipRect();
Parameters
None.
Description
Allows you access to the clipping rectangle dimensions and placement, which is one of the internal state variables of the Graphics object. Drawing operations are only valid within the clipping rectangle. Graphics-intensive applet or applications are easily optimized in the paint method by performing only those operations valid within the clipping rectangle. For example, an application which renders lots of images to the drawing surface would see vast improvements in speed by only drawing those images which overlap with the clipping rectangle, since any drawing outside the clipping rectangle is ignored anyway.
Imports
None.
Returns
A Rectangle object which represents the position and size of the clipping rectangle relative to the origin of the Graphics object.
See Also
The clipRect and create methods of the Graphics class
Example
This paint method is responsible for rendering a 100x100 grid of Images on the drawing surface. The method is optimized by only rendering those Images which fall within the Graphics' clipping rectangle.
// Assume a 100x100 array of Images has been initializedgetColor
ClassName
Graphics
Purpose
Gets the current rendering color of the Graphics object.
Syntax
public abstract Color getColor();
Parameters
None.
Description
Accesses the current foreground color of the graphics object, which is one of the internal state variables of the Graphics object. All graphical primitive and text rendering operations are done using the foreground color.
Imports
java.awt.Color
Returns
A Color object containing the relative RGB (Red/Green/Blue) values of the current foreground color of the Graphics object.
See Also
The setColor method of the Graphics class; the Color class
Example
This example uses both getColor and setColor to modify the Graphics' current rendering color.
public void paint(Graphics g)getFont
ClassName
Graphics
Purpose
Gets the current font of the Graphics object.
Syntax
public abstract Font getFont();
Parameters
None.
Description
Accesses the current font of the Graphics object The current font is one of the internal state variables defining the current state of a Graphics object. All text rendering operations are done using the currentFont.
Imports
java.awt.Font
Returns
A Font object describing the current font in use by the Graphics object.
See Also
The setFont method of the Graphics class; the Font class
Example
This example uses getFont and setFont to make the current font for rendering text boldface.
public void paint(Graphics g)getFontMetrics
ClassName
Graphics
Purpose
Returns a FontMetrics object for the Font and the display surface associated with this Graphics object.
Syntax
public abstract FontMetrics
getFontMetrics();
public abstract FontMetrics getFontMetrics(Font f);
Parameters
Font f
A specific Font to get a FontMetrics for. The resultant FontMetrics represents the metrics of text rendered on the display surface associated with this Graphics object using Font f.
Description
The same font can actually render differently on different display surfaces, especially if those display surfaces represent very dissimilar graphical devices. A FontMetrics object describes how the font will render on a particular Graphics object's display surface. The first overloaded version of this method will generate a FontMetrics describing how the Graphics object's current font, one of the variables of the Graphic's internal state, will display on the drawing surface. The other overloaded version allows you to pass in a Font object.
Returns
A FontMetrics object describing how the specified font, defined by a Font object, will be displayed on the Graphic's drawing surface.
See Also
The getFont and setFont methods of the Graphics class
Example
public void paint(Graphics g)scale
ClassName
Graphics
Purpose
Changes the scale of the X and Y axes of this Graphics object's coordinate system.
Syntax
public abstract void scale(float xScale, float yScale);
Parameters
float xScale
The new ratio of physical device units of the display surface to logical units of the Graphics object in the horizontal direction.
float yScale
The new ratio of physical device units of the display surface to logical units of the Graphics object in the vertical direction.
Description
This method allows you to modify the
ratio of physical device units to logical device units in both the horizontal
and vertical directions. The scale of the Graphics object is one of the
internal state variables that can affect the appearance of rendered geometric
primitives, text, and images on the display surface.
The physical device units of a display surface are an atomic measure of the
smallest addressable surface element. For example, the physical device units of
the on-screen desktop are pixels. Pixels are also the physical device units of
Image objects in memory.
Changing the scale of a Graphics object attached to the on-screen desktop to,
say, two would mean that every pixel on the display surface was represented by
two logical units of the Graphics object. In that case, a reference to the
point (10,10) in a Graphics method would actually map to a physical point 5
pixels to the right and 5 pixels below the origin on the screen.
Different graphical devices have different physical device units. The physical
device units of a laser printer probably would be much smaller than those of a
dot-matrix printer.
Imports
None.
Returns
None.
setColor
ClassName
Graphics
Purpose
Modifies the current rendering color of this Graphics object.
Syntax
public abstract void setColor(Color c);
Parameters
Color c
A Color object containing the RGB (Red/Green/Blue) values of the color to use for the new foreground color of the Graphics object.
Description
Changes the current foreground color used by the Graphics object when rendering geometric primitives or text on the display surface. The current foreground color is one of the internal state variables that defines the current state of a Graphics object.
Imports
None.
Returns
None.
See Also
The getColor method of the Graphics class; the Color class
Example
See the example for the getColor method of the Graphics class.
setFont
ClassName
Graphics
Purpose
Modifies the font used for rendering text by this Graphics object.
Syntax
public abstract void setFont(Font f);
Parameters
Font f
A Font object describing the font to use when rendering text on the display surface using any of the Graphics class' text rendering methods.
Description
Changes the current font used by the Graphics object when rendering text on the display surface. The current font is one of the internal state variables that defines the current state of a Graphics object.
Imports
None.
Returns
None.
See Also
The getFont method of the Graphics class; the Font class
Example
See the example for the getFont method of the Graphics class.
setPaintMode
ClassName
Graphics
Purpose
Sets the painting mode of this Graphics object to 'overwrite', as opposed to XOR mode.
Syntax
public abstract void setPaintMode();
Parameters
None.
Description
Changes the current painting mode used by the Graphics object when rendering geometric primitives or text on the display surface to 'overwrite'. When using this mode, all rendering overwrites the current display surface contents using the current foreground color. The current painting mode is one of the internal state variables that defines the internal state of a Graphics object.
Imports
None.
Returns
None.
See Also
The setXORmode method for the Graphics class
Example
This example uses both the overwrite and XOR painting modes in the same custom paint method implementation.
public void paint(Graphics g)setXORMode
ClassName
Graphics
Purpose
Changes the Graphics object's painting mode to XOR mode, as opposed to overwrite mode.
Syntax
public abstract void setXORMode(Color c);
Parameters
Color c
A Color object containing the RGB (Red/Green/Blue) values of the color to use for the alternate to the foreground.
Description
Changes the current painting mode used by the Graphics object when rendering geometric primitives or text on the display surface to 'XOR' mode. In XOR mode, the color value of a pixel, after a rendering operation, can be determined by this formula:
outColor(x, y) = inColor(x, y) ⊗ drawingColor ⊗ alternateColor
where the ⊗ symbol denotes the bitwise XOR operation.
Imports
None.
Returns
None.
See Also
The setPaintingMode method of the Graphics class
Example
See the Ovals Applet example earlier in this chapter.
Applet
Purpose
An embeddable interactive Component, suitable for embedding in World Wide Web pages using special HTML tags.
Syntax
public class Applet extends Panel
Description
A Java Applet is an interactive Component specially designed for use across the World Wide Web. The Applet class defines methods for controlling the lifetime of an Applet object, for which your applets provide custom implementations. Each applet running in an applet-aware browser has its own Thread, which uses the Applet methods init, start, stop and destroy to control the applet's lifetime. The Applet communicates with the browser through AppletContext and AppletStub objects. Figure 1-8 illustrates the inheritance relationship of the Applet class.
Figure 1-8 Class diagram of the Applet class
PackageName
java.applet
Imports
java.awt.*
Constructors
None.
Parameters
None.
isActive
ClassName
Applet
Purpose
Indicates whether or not the Applet has been started.
Syntax
public boolean isActive();
Parameters
None.
Description
Just before the Applet's start method is called, the Applet is marked as 'active'. At that point, all calls to this method return true. Before that time and just before destroy is called, the Applet is marked as not active.
Imports
None.
Returns
True is returned if this method is called at any time from just before the Applet's start method is called to just before the Applet's destroy method is called.
Example
Check to see if Applet 'Professor' is active.
getDocumentBase
ClassName
Applet
Purpose
Gets the URL for the document this Applet is embedded in.
Syntax
public URL getDocumentBase();
Parameters
None.
Description
The URL for the document this Applet is embedded in is returned. This method is a shallow wrapper around AppletStub.getDocumentBase, so if the AppletStub is not implemented then, a call to this method will cause a NullPointerException to be thrown.
Imports
java.net.URL
Returns
The URL pointing to the document this Applet is embedded in.
See Also
The getCodeBase method of the Applet class.
Example
getCodeBase
ClassName
Applet
Purpose
Gets the URL for this Applet's .CLASS file.
Syntax
public URL getCodeBase();
Parameters
None.
Description
The URL for the this Applet's .CLASS file is returned. This method is a shallow wrapper around AppletStub.getCodeBase, so if the AppletStub is not implemented, then a call to this method will cause a NullPointerException to be thrown.
Imports
java.awt.URL
Returns
The URL pointing to this Applet's .CLASS file.
See Also
The getDocumentBase method of the Applet class
Example
getParameter
ClassName
Applet
Purpose
Gets the string value of a particular Applet parameter.
Syntax
public String getParameter(String name);
Parameters
String name
Name of the parameter to retrieve. This is the value of the 'name' tag within the HTML <PARAM> field which defines the Applet.
Description
This method returns one of the parameters to this Applet. Parameters are declared between the <APPLET>..</APPLET> delimiters in HTML files. The <PARAM> tag has two possible fields: 'name' and 'value'. By indicating one of the valid names for this Applet, the corresponding 'value' field string will be returned.
Imports
None.
Returns
The String associated with the parameter whose 'name' field value is the name parameter. If no such parameter exists, then null is returned.
See Also
The getParameters method of the Applet class
Example
getAppletContext
ClassName
Applet
Purpose
Retrieves the AppletConext for this Applet.
Syntax
public AppletContext getAppletContext();
Parameters
None.
Description
The AppletContext represents the browser this Applet is being displayed on. To retrieve a reference to an Applet's AppletContext, use this method.
Imports
java.applet.AppletContext
Returns
A reference to this Applet's AppletContext is returned. Note that if the Applet is not instantiated within a proper browser, then this method will return null. That is, if you have an application which simply creates an Applet instance, then that Applet's AppletContext will be null.
See Also
The getAppletStub method of the Applet class
Example
This example uses the AppletContext to get an array of all the applets running within the browser.
showStatus
ClassName
Applet
Purpose
Displays a message on the browser's status bar.
Syntax
public void showStatus(String msg);
Parameters
String msg
Message to be displayed on the browser's status bar.
Description
Browsers generally have a status bar below the main display window. Use this method to place a message within that status bar. This method is a shallow wrapper around AppletContext.showStatus. If the Applet is not created within the context of a browser which implements AppletContext, then a call to this method will throw a NullPointerException.
Imports
None.
Returns
None.
See Also
The showStatus method of the AppletContext class
Example
play
ClassName
Applet
Purpose
Downloads and plays an AudioClip from an audio data file.
Syntax
public void play(URL url); public void play(URL url, String str);
Parameters
URL url
URL or base of a relative URL to the audio data file for the AudioClip you want to play.
String str
Relative URL to the URL you want to play.
Description
This method is a simple shorthand for getting an AudioClip and playing it. Use of this method saves about three lines of explicit coding.
Imports
java.applet.AudioClip, java.net.URL
Returns
None.
See Also
The getAudioClip method of the Applet class; the AppletContext class; the AudioClip interface
Example
This example reproduces the code of the ThemeMusicApplet, provided earlier in this chapter.
import java.Applet.*;init()
ClassName
Applet
Purpose
Called by the Applet's Thread to allow it to initialize itself.
Syntax
public void init();
Parameters
None.
Description
The init() method is one of the four methods which define an Applet's action during its lifetime. In your custom applet, implement this method to allocate any resources you will need for your applet to run. The init() method is called only once, and always before this first invocation of the applet's start() method.
Imports
None.
Returns
None.
See Also
The start(), stop(), and destroy() methods of the Applet class
Example
See the project for this chapter, which makes extensive use of the Applet's init(), start(), stop(), and destroy() methods.
start()
ClassName
Applet
Purpose
Called by the Applet's Thread to start it running.
Syntax
public void start();
Parameters
None.
Description
The start() method is one of the four methods which define an Applet's action during its lifetime. In your custom applet, implement this method to actually perform the applet's behavior. The start() method is potentially called several times during the lifetime of the applet. Each call to start() is matched by exactly one subsequent call to stop(), sometime in the future. A typical operation performed in the start() method is kick-starting the applet's background Threads.
Imports
None.
Returns
None.
See Also
The init(), stop(), and destroy() methods of the Applet class
Example
See the project for this chapter, which makes extensive use of the Applet's init(), start(), stop(), and destroy() methods.
stop()
ClassName
Applet
Purpose
Called by the Applet's Thread to stop it running.
Syntax
public void stop();
Parameters
None.
Description
The stop() method is one of the four methods which define an Applet's action during its lifetime. In your custom applet, implement this method to gracefully shut down the applet. The stop() method is potentially called several times during the lifetime of the applet. Each call to stop() is matched by exactly one prior call to start(). Stop any background Threads from processing before returning from your custom implementation of this method.
Imports
None.
Returns
None.
See Also
The init(), start(), and destroy() methods of the Applet class
Example
See the project for this chapter, which makes extensive use of the Applet's init(), start(), stop(), and destroy() methods.
destroy()
ClassName
Applet
Purpose
Called by the Applet's Thread to allow it to perform final clean-up.
Syntax
public void destroy();
Parameters
None.
Description
The destroy() method is one of the four methods which define an applet's action during its lifetime. In your custom applet, implement this method to deallocate any resources allocated during the applet's lifetime. The destroy() method is called exactly once, just before the Applet object is destroyed.
Imports
None.
Returns
None.
See Also
The init(), start(), and stop() methods of the Applet class
Example
See the project for this chapter, which makes extensive use of the Applet's init(), start(), stop(), and destroy() methods.
The Applet and Graphics class project demonstrates a non-trivial applet, suitable for embedding in a World Wide Web page and viewing with an applet-enabled Web browser. This project illustrates animation using double-buffered screen updating to minimize 'flicker', and background Thread processing to create successive animation images. As with several of the Applet code samples provided in this chapter, the Life applet uses custom implementations of the essential Applet methods init(), start(), stop(), and destroy() to manage resources and processing during the lifetime of the Life applet object.
'The Game of Life' is a simple example of artificial life on the
computer, introduced by
. An alive cell remains alive in the next turn if there are exactly two or three adjacent alive cells. This is termed the 'loneliness rule'.
. A dead cell becomes alive in the next turn if there are exactly three adjacent alive cells. This is termed the 'reproduction rule'.
. All other cells, whether alive or dead, will be dead the next turn.
It is fun and interesting to watch this program build cell colonies through turn-by-turn application of the above rules. Huge clusters of cells can die out from over-population, while small clusters of five or six cells can grow into mammoth cell structures. Figures 1-9, 1-10, and 1-11 present screenshots from three successive turns, or 'generations,' of a particular run through the Game of Life using the Life applet built in this project.
Figure 1-9 Turn or generation of the Game of Life
Figure 1-10 Turn or generation of the Game of Life
Figure 1-11 Turn or generation of the Game of Life
Note that in the Life.java code, an underscore character '_' is prepended to all class member variables to distinguish them from function names, local variables, etc. This is to improve the readability of the code.
1. Begin the file named Life.java by declaring the Life Applet with its necessary member variables and object instances:
import java.applet.*;3. Life's init implementation reads in the applet parameters, allocates and fills in the initial generation game grid, resizes the display area of the applet, and loads the 'alive' and 'not-alive' images.
public void init() catch (Exception e)4. Life's start method creates the Calc Thread, using this object's run() method to do the successive game grid generation.
public synchronized void start()5. The Calc Thread, created and started in Life's start() method implementation, is made to halt in stop(). The run() method (below) is written so that the Calc Thread will stop running when the _threadNextGen member variable is null. Note that both the start() and stop() methods are synchronized to prevent simultaneous execution by more than one Thread.
public synchronized void stop()6. Life's Calc Thread, which calculates successive generations of the game grid, executes the run() method. The Calc Thread drops out of the continuous loop when _threadNextGen is set to null in Life.stop(). Once a new game grid is created, Life's setGameGrid() method is called to update the display.
public void run() catch (Exception e)7. Paint() is called by the Java system asynchronously whenever the Life Applet must be updated on screen. This can be in response to an explicit call to Life.repaint() (done in setGameGrid()), or in response to a windowing event such as the Life applet being scrolled off and then back on screen. This implementation of paint uses the current game grid to place multiple copies of the 'alive' and 'not-alive' images to an in-memory Image. When the in-memory Image has been updated, it is copied to the screen. The update() method is overriden to call paint() without doing anything else.
public synchronized void paint(Graphics g)8. setGameGrid() is called by the Calc Thread after it has completed calculating the next generation. This is synchronized so paint(), start(), or stop() cannot be entered while the current game grid is being updated.
private synchronized boolean setGameGrid(9. Life implements several utility methods to make the code in the previous steps more readable.
/* ********10. Enter the following HTML code into a file named EXAMPLE1.HTML in the same directory as Life.java:
<HTML>Table 1-5 lists the applet parameters, both required and optional, used by the Life applet.
|
|||||||||||||||||||||||||||
Three important techniques are used by the Game of Life applet:
. Double-buffering to ensure smooth visual transition between successively displayed frames.
. Overriding Component.update() to avoid 'flicker'.
. Background processing to generate successive animation frames.
Life's paint method has the responsibility of displaying a grid of MxN cells. One way this could be accomplished is by simply rendering each cell on the applet's drawing surface is a nested for loop:
public void paint(Graphics g)The big problem with this method of display is that, especially for large M and N, the user will see each individual row of the display surface get updated. For less jerky animation, the successive frames should simply 'pop' onto the screen, fully rendered. That's what 'double-buffered rendering' does: It allows you to update the display surface all at once, instead of little-by-little.
In double-buffered rendering, an Image object is created in memory with the exact same dimensions as the applet's display surface. All rendering is done to a Graphics object attached to that in-memory Image object. When all rendering is completed, the Image object is copied to the display surface all at once. This has the practical effect of having the on-screen display updated instantaneously, instead of little-by-little.
In the Life applet, an in-memory Image, _image2ndSurface, is created during init with the same dimensions as the applet's display surface. A Graphics object, _gc2ndSurface, is created attached to the in-memory Image, like this:
public void init()In paint(), the individual Life generations (each generation is an animation frame) are rendered to the _gc2ndSurface Graphics object. When the rendering is complete, the entire _image2ndSurface is copied to the applet's display surface.
As hinted earlier in this chapter, the Java runtime system will automatically erase an applet's drawing surface before paint() is called. For nonanimation sequences, this might not be a bad thing to do, but for fast screen updating it can prove to be quite annoying to look at. Between each two frames appears a brief 'flicker' when the background is erased. The code for the default implementation of Component.update, which is responsible for the 'flicker' problem, looks like this:
public void update(Graphics g)To reduce this flicker problem, the Life applet implements its own update method to override the default implementation it inherits from Component. The overriding implementation does not call fillRect, so the background is not erased. The custom implementation looks like this:
public void update(Graphics g)Two different animation techniques are the opposite poles of a continuum of implementations for animation in Java:
. Timesliced animation
. Computed frame animation
The simplest animation technique using Java timeslice animation, involves creating a background Thread to 'timeslice', or sleep for some quanta of time before waking up and repainting the drawing surface. This is the 'simplest' method because it involves the least amount of coding. To implement this animation technique, you need:
. An ordered Vector or array of Image objects, each one a frame to display.
. A 'current Image object' variable, which keeps track of which frame is currently being displayed.
. A background Thread object which wakes up periodically, advances the 'current Image object' indicator to the next frame, and forces the applet to repaint itself.
The JDK includes a generic Animator applet which uses the timeslicing technique to perform animation. Through its parameters, you can customize the Animator applet to display any number of frames, in any order, and even sequence sound with each frame.
The drawback of this animation technique is that it requires all frames of the animation sequence to have already been rendered onto Image objects in memory. For applets or applications which must compute and render each frame separately, such as the Life applet, the timeslicing technique is inadequate. Life uses the 'computed frame' technique of animation.
The computed frame technique works by using a background Thread to compute sufficient information to render each frame 'on the fly'. In a continuous loop, the animation Thread computes a frame, and tells the drawing surface to display it, computes a frame, displays it, etc. In this technique, the time between the display of each frame is not necessarily constant, as in timesliced animation. Instead, the time between successive frames is dependent on how long it takes to compute and render each frame.
It is in Life's run method that each successive generation of the Life game is computed. The actual computation involves keeping an accumulated sum for each cell in the target generation grid. For each generation, run adds values to this accumulator using these two rules:
. One is added to the accumulator of each cell adjacent to an 'alive' cell.
. Nine is added to the accumulator of each 'alive' cell.
Based on the rules of the Game of Life presented above, only cells with an accumulated value of 2, 3, or 12 will be alive in the next generation.
The most important aspect of the run method, however, is how it is sychronized with the rendering. The synchronization is necessary to prevent a newly computed Life generation, stored in a 2D grid of boolean values, from overwriting the grid currently being rendered by the paint method.
It is conceivable under the computed frame technique for there to be a backlog of unrendered frames. This will occur if the time it takes the background Thread to compute new frames is less than the time it takes to actually render frames. In such a case, the background Thread will generate more frames than can be rendered in the same amount of time. Without proper synchronization, this could lead to frames being skipped, or other problems.
The Life applet ensures these problems won't occur by synchronizing access to the current generation grid. The background Thread will automatically suspend itself if it attempts to overwrite the current generation grid before it has been rendered on the drawing surface. A more sophisticated animation applet would utilize a synchronized storage device for storing any backlog of unrendered grids.
|
Politica de confidentialitate | Termeni si conditii de utilizare |
Vizualizari: 909
Importanta: 
Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved
