jdk-sandbox: comparison src/java.desktop/share/classes/java/applet/Applet.java

equal deleted inserted replaced

-:7199c4da1a6f
+:52ea97fb80b0
 import java.awt.Dimension;
 import java.awt.GraphicsEnvironment;
 import java.awt.HeadlessException;
 import java.awt.Image;
 import java.awt.Panel;
+import java.awt.event.ComponentEvent;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.util.Locale;
 import javax.accessibility.AccessibleStateSet;
 import com.sun.media.sound.JavaSoundAudioClip;
 /**
-* An applet is a small program that is intended not to be run on
+* An applet is a small program that is intended not to be run on its own, but
-* its own, but rather to be embedded inside another application.
+* rather to be embedded inside another application.
 * <p>
-* The {@code Applet} class must be the superclass of any
+* The {@code Applet} class must be the superclass of any applet that is to be
-* applet that is to be embedded in a Web page or viewed by the Java
+* embedded in a Web page or viewed by the Java Applet Viewer. The
-* Applet Viewer. The {@code Applet} class provides a standard
+* {@code Applet} class provides a standard interface between applets and their
-* interface between applets and their environment.
+* environment.
 *
-* @author      Arthur van Hoff
+* @author Arthur van Hoff
-* @author      Chris Warth
+* @author Chris Warth
-* @since       1.0
+* @since 1.0
-*
 * @deprecated The Applet API is deprecated, no replacement.
 */
 @Deprecated(since = "9")
 public class Applet extends Panel {
 /**
 * Constructs a new Applet.
 * <p>
-* Note: Many methods in {@code java.applet.Applet}
+* Note: Many methods in {@code java.applet.Applet} may be invoked by the
-* may be invoked by the applet only after the applet is
+* applet only after the applet is fully constructed; applet should avoid
-* fully constructed; applet should avoid calling methods
+* calling methods in {@code java.applet.Applet} in the constructor.
-* in {@code java.applet.Applet} in the constructor.
+*
-*
+* @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
-* @exception HeadlessException if GraphicsEnvironment.isHeadless()
+*         returns {@code true}
-* returns true.
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @since 1.4
 */
 public Applet() throws HeadlessException {
 if (GraphicsEnvironment.isHeadless()) {
 }
 }
 /**
 * Applets can be serialized but the following conventions MUST be followed:
-*
+* <p>
-* Before Serialization:
+* Before Serialization: An applet must be in STOPPED state.
-* An applet must be in STOPPED state.
+* <p>
-*
+* After Deserialization: The applet will be restored in STOPPED state (and
-* After Deserialization:
+* most clients will likely move it into RUNNING state). The stub field will
-* The applet will be restored in STOPPED state (and most clients will
+* be restored by the reader.
-* likely move it into RUNNING state).
-* The stub field will be restored by the reader.
 */
 private transient AppletStub stub;
-/* version ID for serialized form. */
+/**
+* Use serialVersionUID from JDK 1.0 for interoperability.
+*/
 private static final long serialVersionUID = -5836846270535785031L;
 /**
 * Read an applet from an object input stream.
-* @param  s  an object input stream.
+*
-* @exception HeadlessException if
+* @param  s an object input stream
-* {@code GraphicsEnvironment.isHeadless()} returns
+* @throws HeadlessException if {@code GraphicsEnvironment.isHeadless()}
-* {@code true}
+*         returns {@code true}
 * @serial
 * @see java.awt.GraphicsEnvironment#isHeadless
 * @since 1.4
 */
 private void readObject(ObjectInputStream s)
 s.defaultReadObject();
 }
 /**
 * Sets this applet's stub. This is done automatically by the system.
-* <p>If there is a security manager, its {@code checkPermission}
+* <p>
-* method is called with the
+* If there is a security manager, its {@code checkPermission} method is
-* {@code AWTPermission("setAppletStub")}
+* called with the {@code AWTPermission("setAppletStub")} permission if a
-* permission if a stub has already been set.
+* stub has already been set.
-* @param   stub   the new stub.
+*
-* @exception SecurityException if the caller cannot set the stub
+* @param  stub the new stub
+* @throws SecurityException if the caller cannot set the stub
 */
 public final void setStub(AppletStub stub) {
 if (this.stub != null) {
 SecurityManager s = System.getSecurityManager();
 if (s != null) {
 }
 this.stub = stub;
 }
 /**
-* Determines if this applet is active. An applet is marked active
+* Determines if this applet is active. An applet is marked active just
-* just before its {@code start} method is called. It becomes
+* before its {@code start} method is called. It becomes inactive just
-* inactive just before its {@code stop} method is called.
+* before its {@code stop} method is called.
 *
-* @return  {@code true} if the applet is active;
+* @return {@code true} if the applet is active; {@code false} otherwise
-*          {@code false} otherwise.
+* @see java.applet.Applet#start()
-* @see     java.applet.Applet#start()
+* @see java.applet.Applet#stop()
-* @see     java.applet.Applet#stop()
 */
 public boolean isActive() {
 if (stub != null) {
 return stub.isActive();
 } else {        // If stub field not filled in, applet never active
 return false;
 }
 }
 /**
-* Gets the URL of the document in which this applet is embedded.
+* Gets the {@code URL} of the document in which this applet is embedded.
-* For example, suppose an applet is contained
+* For example, suppose an applet is contained within the document:
-* within the document:
 * <blockquote><pre>
 *    http://www.oracle.com/technetwork/java/index.html
 * </pre></blockquote>
 * The document base is:
 * <blockquote><pre>
 *    http://www.oracle.com/technetwork/java/index.html
 * </pre></blockquote>
 *
-* @return  the {@link java.net.URL} of the document that contains this
+* @return the {@link java.net.URL} of the document that contains this
-*          applet.
+*         applet
-* @see     java.applet.Applet#getCodeBase()
+* @see java.applet.Applet#getCodeBase()
 */
 public URL getDocumentBase() {
 return stub.getDocumentBase();
 }
 /**
-* Gets the base URL. This is the URL of the directory which contains this applet.
+* Gets the base {@code URL}. This is the {@code URL} of the directory which
-*
+* contains this applet.
-* @return  the base {@link java.net.URL} of
+*
-*          the directory which contains this applet.
+* @return the base {@link java.net.URL} of the directory which contains
-* @see     java.applet.Applet#getDocumentBase()
+*         this applet
+* @see java.applet.Applet#getDocumentBase()
 */
 public URL getCodeBase() {
 return stub.getCodeBase();
 }
 /**
-* Returns the value of the named parameter in the HTML tag. For
+* Returns the value of the named parameter in the HTML tag. For example, if
-* example, if this applet is specified as
+* this applet is specified as
 * <blockquote><pre>
 * &lt;applet code="Clock" width=50 height=50&gt;
 * &lt;param name=Color value="blue"&gt;
 * &lt;/applet&gt;
 * </pre></blockquote>
 * <p>
-* then a call to {@code getParameter("Color")} returns the
+* then a call to {@code getParameter("Color")} returns the value
-* value {@code "blue"}.
+* {@code "blue"}.
 * <p>
 * The {@code name} argument is case insensitive.
 *
-* @param   name   a parameter name.
+* @param  name a parameter name
-* @return  the value of the named parameter,
+* @return the value of the named parameter, or {@code null} if not set
-*          or {@code null} if not set.
+*/
-*/
+public String getParameter(String name) {
-public String getParameter(String name) {
+return stub.getParameter(name);
-return stub.getParameter(name);
+}
-}
+/**
-/**
+* Determines this applet's context, which allows the applet to query and
-* Determines this applet's context, which allows the applet to
+* affect the environment in which it runs.
-* query and affect the environment in which it runs.
+* <p>
-* <p>
+* This environment of an applet represents the document that contains the
-* This environment of an applet represents the document that
+* applet.
-* contains the applet.
+*
-*
+* @return the applet's context
-* @return  the applet's context.
 */
 public AppletContext getAppletContext() {
 return stub.getAppletContext();
 }
 /**
 * Requests that this applet be resized.
 *
-* @param   width    the new requested width for the applet.
+* @param  width the new requested width for the applet
-* @param   height   the new requested height for the applet.
+* @param  height the new requested height for the applet
 */
 @SuppressWarnings("deprecation")
 public void resize(int width, int height) {
 Dimension d = size();
 if ((d.width != width) || (d.height != height)) {
 }
 /**
 * Requests that this applet be resized.
 *
-* @param   d   an object giving the new width and height.
+* @param  d an object giving the new width and height
 */
 @SuppressWarnings("deprecation")
 public void resize(Dimension d) {
 resize(d.width, d.height);
 }
 * <p>
 * {@code Applet} objects are the validate roots, and, therefore, they
 * override this method to return {@code true}.
 *
 * @return {@code true}
+* @see java.awt.Container#isValidateRoot
 * @since 1.7
-* @see java.awt.Container#isValidateRoot
 */
 @Override
 public boolean isValidateRoot() {
 return true;
 }
 /**
-* Requests that the argument string be displayed in the
+* Requests that the argument string be displayed in the "status window".
-* "status window". Many browsers and applet viewers
+* Many browsers and applet viewers provide such a window, where the
-* provide such a window, where the application can inform users of
+* application can inform users of its current state.
-* its current state.
+*
-*
+* @param  msg a string to display in the status window
-* @param   msg   a string to display in the status window.
 */
 public void showStatus(String msg) {
 getAppletContext().showStatus(msg);
 }
 /**
-* Returns an {@code Image} object that can then be painted on
+* Returns an {@code Image} object that can then be painted on the screen.
-* the screen. The {@code url} that is passed as an argument
+* The {@code url} that is passed as an argument must specify an absolute
-* must specify an absolute URL.
+* {@code URL}.
 * <p>
-* This method always returns immediately, whether or not the image
+* This method always returns immediately, whether or not the image exists.
-* exists. When this applet attempts to draw the image on the screen,
+* When this applet attempts to draw the image on the screen, the data will
-* the data will be loaded. The graphics primitives that draw the
+* be loaded. The graphics primitives that draw the image will incrementally
-* image will incrementally paint on the screen.
+* paint on the screen.
 *
-* @param   url   an absolute URL giving the location of the image.
+* @param  url an absolute {@code URL} giving the location of the image
-* @return  the image at the specified URL.
+* @return the image at the specified {@code URL}
-* @see     java.awt.Image
+* @see java.awt.Image
 */
 public Image getImage(URL url) {
 return getAppletContext().getImage(url);
 }
 /**
-* Returns an {@code Image} object that can then be painted on
+* Returns an {@code Image} object that can then be painted on the screen.
-* the screen. The {@code url} argument must specify an absolute
+* The {@code url} argument must specify an absolute {@code URL}. The
-* URL. The {@code name} argument is a specifier that is
+* {@code name} argument is a specifier that is relative to the {@code url}
-* relative to the {@code url} argument.
+* argument.
 * <p>
-* This method always returns immediately, whether or not the image
+* This method always returns immediately, whether or not the image exists.
-* exists. When this applet attempts to draw the image on the screen,
+* When this applet attempts to draw the image on the screen, the data will
-* the data will be loaded. The graphics primitives that draw the
+* be loaded. The graphics primitives that draw the image will incrementally
-* image will incrementally paint on the screen.
+* paint on the screen.
 *
-* @param   url    an absolute URL giving the base location of the image.
+* @param  url an absolute URL giving the base location of the image
-* @param   name   the location of the image, relative to the
+* @param  name the location of the image, relative to the {@code url}
-*                 {@code url} argument.
+*         argument
-* @return  the image at the specified URL.
+* @return the image at the specified {@code URL}
-* @see     java.awt.Image
+* @see java.awt.Image
 */
 public Image getImage(URL url, String name) {
 try {
 return getImage(new URL(url, name));
 } catch (MalformedURLException e) {
 return null;
 }
 }
 /**
-* Get an audio clip from the given URL.
+* Get an audio clip from the given {@code URL}.
 *
-* @param url points to the audio clip
+* @param  url points to the audio clip
-* @return the audio clip at the specified URL.
+* @return the audio clip at the specified {@code URL}
-*
+* @since 1.2
-* @since       1.2
 */
 public static final AudioClip newAudioClip(URL url) {
 return JavaSoundAudioClip.create(url);
 }
 /**
-* Returns the {@code AudioClip} object specified by the
+* Returns the {@code AudioClip} object specified by the {@code URL}
-* {@code URL} argument.
+* argument.
 * <p>
-* This method always returns immediately, whether or not the audio
+* This method always returns immediately, whether or not the audio clip
-* clip exists. When this applet attempts to play the audio clip, the
+* exists. When this applet attempts to play the audio clip, the data will
-* data will be loaded.
+* be loaded.
 *
-* @param   url  an absolute URL giving the location of the audio clip.
+* @param  url an absolute {@code URL} giving the location of the audio clip
-* @return  the audio clip at the specified URL.
+* @return the audio clip at the specified {@code URL}
-* @see     java.applet.AudioClip
+* @see java.applet.AudioClip
 */
 public AudioClip getAudioClip(URL url) {
 return getAppletContext().getAudioClip(url);
 }
 /**
-* Returns the {@code AudioClip} object specified by the
+* Returns the {@code AudioClip} object specified by the {@code URL} and
-* {@code URL} and {@code name} arguments.
+* {@code name} arguments.
 * <p>
-* This method always returns immediately, whether or not the audio
+* This method always returns immediately, whether or not the audio clip
-* clip exists. When this applet attempts to play the audio clip, the
+* exists. When this applet attempts to play the audio clip, the data will
-* data will be loaded.
+* be loaded.
 *
-* @param   url    an absolute URL giving the base location of the
+* @param  url an absolute {@code URL} giving the base location of the audio
-*                 audio clip.
+*         clip
-* @param   name   the location of the audio clip, relative to the
+* @param  name the location of the audio clip, relative to the {@code url}
-*                 {@code url} argument.
+*         argument
-* @return  the audio clip at the specified URL.
+* @return the audio clip at the specified {@code URL}
-* @see     java.applet.AudioClip
+* @see java.applet.AudioClip
 */
 public AudioClip getAudioClip(URL url, String name) {
 try {
 return getAudioClip(new URL(url, name));
 } catch (MalformedURLException e) {
 return null;
 }
 }
 /**
-* Returns information about this applet. An applet should override
+* Returns information about this applet. An applet should override this
-* this method to return a {@code String} containing information
+* method to return a {@code String} containing information about the
-* about the author, version, and copyright of the applet.
+* author, version, and copyright of the applet.
 * <p>
-* The implementation of this method provided by the
+* The implementation of this method provided by the {@code Applet} class
-* {@code Applet} class returns {@code null}.
+* returns {@code null}.
 *
-* @return  a string containing information about the author, version, and
+* @return a string containing information about the author, version, and
-*          copyright of the applet.
+*         copyright of the applet
 */
 public String getAppletInfo() {
 return null;
 }
 /**
-* Gets the locale of the applet. It allows the applet
+* Gets the locale of the applet. It allows the applet to maintain its own
-* to maintain its own locale separated from the locale
+* locale separated from the locale of the browser or appletviewer.
-* of the browser or appletviewer.
+*
-*
+* @return the locale of the applet; if no locale has been set, the default
-* @return  the locale of the applet; if no locale has
+*         locale is returned
-*          been set, the default locale is returned.
+* @since 1.1
-* @since   1.1
 */
 public Locale getLocale() {
 Locale locale = super.getLocale();
 if (locale == null) {
 return Locale.getDefault();
 }
 return locale;
 }
 /**
-* Returns information about the parameters that are understood by
+* Returns information about the parameters that are understood by this
-* this applet. An applet should override this method to return an
+* applet. An applet should override this method to return an array of
-* array of {@code Strings} describing these parameters.
+* strings describing these parameters.
 * <p>
-* Each element of the array should be a set of three
+* Each element of the array should be a set of three strings containing the
-* {@code Strings} containing the name, the type, and a
+* name, the type, and a description. For example:
-* description. For example:
 * <blockquote><pre>
 * String pinfo[][] = {
 *   {"fps",    "1-10",    "frames per second"},
 *   {"repeat", "boolean", "repeat image loop"},
 *   {"imgs",   "url",     "images directory"}
 * };
 * </pre></blockquote>
 * <p>
-* The implementation of this method provided by the
+* The implementation of this method provided by the {@code Applet} class
-* {@code Applet} class returns {@code null}.
+* returns {@code null}.
 *
-* @return  an array describing the parameters this applet looks for.
+* @return an array describing the parameters this applet looks for
 */
 public String[][] getParameterInfo() {
 return null;
 }
 /**
-* Plays the audio clip at the specified absolute URL. Nothing
+* Plays the audio clip at the specified absolute {@code URL}. Nothing
 * happens if the audio clip cannot be found.
 *
-* @param   url   an absolute URL giving the location of the audio clip.
+* @param  url an absolute {@code URL} giving the location of the audio clip
 */
 public void play(URL url) {
 AudioClip clip = getAudioClip(url);
 if (clip != null) {
 clip.play();
 }
 }
 /**
-* Plays the audio clip given the URL and a specifier that is
+* Plays the audio clip given the {@code URL} and a specifier that is
 * relative to it. Nothing happens if the audio clip cannot be found.
 *
-* @param   url    an absolute URL giving the base location of the
+* @param  url an absolute {@code URL} giving the base location of the audio
-*                 audio clip.
+*         clip
-* @param   name   the location of the audio clip, relative to the
+* @param  name the location of the audio clip, relative to the {@code url}
-*                 {@code url} argument.
+*         argument
 */
 public void play(URL url, String name) {
 AudioClip clip = getAudioClip(url, name);
 if (clip != null) {
 clip.play();
 }
 }
 /**
-* Called by the browser or applet viewer to inform
+* Called by the browser or applet viewer to inform this applet that it has
-* this applet that it has been loaded into the system. It is always
+* been loaded into the system. It is always called before the first time
-* called before the first time that the {@code start} method is
+* that the {@code start} method is called.
-* called.
+* <p>
-* <p>
+* A subclass of {@code Applet} should override this method if it has
-* A subclass of {@code Applet} should override this method if
+* initialization to perform. For example, an applet with threads would use
-* it has initialization to perform. For example, an applet with
+* the {@code init} method to create the threads and the {@code destroy}
-* threads would use the {@code init} method to create the
+* method to kill them.
+* <p>
+* The implementation of this method provided by the {@code Applet} class
+* does nothing.
+*
+* @see java.applet.Applet#destroy()
+* @see java.applet.Applet#start()
+* @see java.applet.Applet#stop()
+*/
+public void init() {
+}
+/**
+* Called by the browser or applet viewer to inform this applet that it
+* should start its execution. It is called after the {@code init} method
+* and each time the applet is revisited in a Web page.
+* <p>
+* A subclass of {@code Applet} should override this method if it has any
+* operation that it wants to perform each time the Web page containing it
+* is visited. For example, an applet with animation might want to use the
+* {@code start} method to resume animation, and the {@code stop} method to
+* suspend the animation.
+* <p>
+* Note: some methods, such as {@code getLocationOnScreen}, can only provide
+* meaningful results if the applet is showing. Because {@code isShowing}
+* returns {@code false} when the applet's {@code start} is first called,
+* methods requiring {@code isShowing} to return {@code true} should be
+* called from a {@code ComponentListener}.
+* <p>
+* The implementation of this method provided by the {@code Applet} class
+* does nothing.
+*
+* @see java.applet.Applet#destroy()
+* @see java.applet.Applet#init()
+* @see java.applet.Applet#stop()
+* @see java.awt.Component#isShowing()
+* @see java.awt.event.ComponentListener#componentShown(ComponentEvent)
+*/
+public void start() {
+}
+/**
+* Called by the browser or applet viewer to inform this applet that it
+* should stop its execution. It is called when the Web page that contains
+* this applet has been replaced by another page, and also just before the
+* applet is to be destroyed.
+* <p>
+* A subclass of {@code Applet} should override this method if it has any
+* operation that it wants to perform each time the Web page containing it
+* is no longer visible. For example, an applet with animation might want to
+* use the {@code start} method to resume animation, and the {@code stop}
+* method to suspend the animation.
+* <p>
+* The implementation of this method provided by the {@code Applet} class
+* does nothing.
+*
+* @see java.applet.Applet#destroy()
+* @see java.applet.Applet#init()
+*/
+public void stop() {
+}
+/**
+* Called by the browser or applet viewer to inform this applet that it is
+* being reclaimed and that it should destroy any resources that it has
+* allocated. The {@code stop} method will always be called before
+* {@code destroy}.
+* <p>
+* A subclass of {@code Applet} should override this method if it has any
+* operation that it wants to perform before it is destroyed. For example,
+* an applet with threads would use the {@code init} method to create the
 * threads and the {@code destroy} method to kill them.
 * <p>
-* The implementation of this method provided by the
+* The implementation of this method provided by the {@code Applet} class
-* {@code Applet} class does nothing.
+* does nothing.
 *
-* @see     java.applet.Applet#destroy()
+* @see java.applet.Applet#init()
-* @see     java.applet.Applet#start()
+* @see java.applet.Applet#start()
-* @see     java.applet.Applet#stop()
+* @see java.applet.Applet#stop()
-*/
-public void init() {
-}
-/**
-* Called by the browser or applet viewer to inform
-* this applet that it should start its execution. It is called after
-* the {@code init} method and each time the applet is revisited
-* in a Web page.
-* <p>
-* A subclass of {@code Applet} should override this method if
-* it has any operation that it wants to perform each time the Web
-* page containing it is visited. For example, an applet with
-* animation might want to use the {@code start} method to
-* resume animation, and the {@code stop} method to suspend the
-* animation.
-* <p>
-* Note: some methods, such as {@code getLocationOnScreen}, can only
-* provide meaningful results if the applet is showing.  Because
-* {@code isShowing} returns {@code false} when the applet's
-* {@code start} is first called, methods requiring
-* {@code isShowing} to return {@code true} should be called from
-* a {@code ComponentListener}.
-* <p>
-* The implementation of this method provided by the
-* {@code Applet} class does nothing.
-*
-* @see     java.applet.Applet#destroy()
-* @see     java.applet.Applet#init()
-* @see     java.applet.Applet#stop()
-* @see     java.awt.Component#isShowing()
-* @see     java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)
-*/
-public void start() {
-}
-/**
-* Called by the browser or applet viewer to inform
-* this applet that it should stop its execution. It is called when
-* the Web page that contains this applet has been replaced by
-* another page, and also just before the applet is to be destroyed.
-* <p>
-* A subclass of {@code Applet} should override this method if
-* it has any operation that it wants to perform each time the Web
-* page containing it is no longer visible. For example, an applet
-* with animation might want to use the {@code start} method to
-* resume animation, and the {@code stop} method to suspend the
-* animation.
-* <p>
-* The implementation of this method provided by the
-* {@code Applet} class does nothing.
-*
-* @see     java.applet.Applet#destroy()
-* @see     java.applet.Applet#init()
-*/
-public void stop() {
-}
-/**
-* Called by the browser or applet viewer to inform
-* this applet that it is being reclaimed and that it should destroy
-* any resources that it has allocated. The {@code stop} method
-* will always be called before {@code destroy}.
-* <p>
-* A subclass of {@code Applet} should override this method if
-* it has any operation that it wants to perform before it is
-* destroyed. For example, an applet with threads would use the
-* {@code init} method to create the threads and the
-* {@code destroy} method to kill them.
-* <p>
-* The implementation of this method provided by the
-* {@code Applet} class does nothing.
-*
-* @see     java.applet.Applet#init()
-* @see     java.applet.Applet#start()
-* @see     java.applet.Applet#stop()
 */
 public void destroy() {
 }
 //
 // Accessibility support
 //
+/**
+* The accessible context associated with this {@code Applet}.
+*/
 AccessibleContext accessibleContext = null;
 /**
-* Gets the AccessibleContext associated with this Applet.
+* Gets the {@code AccessibleContext} associated with this {@code Applet}.
-* For applets, the AccessibleContext takes the form of an
+* For applets, the {@code AccessibleContext} takes the form of an
-* AccessibleApplet.
+* {@code AccessibleApplet}. A new {@code AccessibleApplet} instance is
-* A new AccessibleApplet instance is created if necessary.
+* created if necessary.
 *
-* @return an AccessibleApplet that serves as the
+* @return an {@code AccessibleApplet} that serves as the
-*         AccessibleContext of this Applet
+*         {@code AccessibleContext} of this {@code Applet}
 * @since 1.3
 */
 public AccessibleContext getAccessibleContext() {
 if (accessibleContext == null) {
 accessibleContext = new AccessibleApplet();
 }
 return accessibleContext;
 }
 /**
-* This class implements accessibility support for the
+* This class implements accessibility support for the {@code Applet} class.
-* {@code Applet} class.  It provides an implementation of the
+* It provides an implementation of the Java Accessibility API appropriate
-* Java Accessibility API appropriate to applet user-interface elements.
+* to applet user-interface elements.
+*
 * @since 1.3
 */
 protected class AccessibleApplet extends AccessibleAWTPanel {
+/**
+* Use serialVersionUID from JDK 1.3 for interoperability.
+*/
 private static final long serialVersionUID = 8127374778187708896L;
 /**
 * Get the role of this object.
 *
-* @return an instance of AccessibleRole describing the role of the
+* @return an instance of {@code AccessibleRole} describing the role of
-* object
+*         the object
 */
 public AccessibleRole getAccessibleRole() {
 return AccessibleRole.FRAME;
 }
 /**
 * Get the state of this object.
 *
-* @return an instance of AccessibleStateSet containing the current
+* @return an instance of {@code AccessibleStateSet} containing the
-* state set of the object
+*         current state set of the object
 * @see AccessibleState
 */
 public AccessibleStateSet getAccessibleStateSet() {
 AccessibleStateSet states = super.getAccessibleStateSet();
 states.add(AccessibleState.ACTIVE);
 return states;
 }
 }
 }

changeset 52740	52ea97fb80b0
parent 50652	11f36b771afd
child 58309	c6f8b2c3dc66