Back to index...

	/*
	* Copyright (c) 1995, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package java.applet;

	import java.awt.*;
	import java.awt.image.ColorModel;
	import java.io.IOException;
	import java.io.ObjectInputStream;
	import java.net.URL;
	import java.net.MalformedURLException;
	import java.util.Hashtable;
	import java.util.Locale;
	import javax.accessibility.*;

	/**
	* An applet is a small program that is intended not to be run on
	* its own, but rather to be embedded inside another application.
	* <p>
	* The <code>Applet</code> class must be the superclass of any
	* applet that is to be embedded in a Web page or viewed by the Java
	* Applet Viewer. The <code>Applet</code> class provides a standard
	* interface between applets and their environment.
	*
	* @author Arthur van Hoff
	* @author Chris Warth
	* @since JDK1.0
	*/
	public class Applet extends Panel {

	/**
	* Constructs a new Applet.
	* <p>
	* Note: Many methods in <code>java.applet.Applet</code>
	* may be invoked by the applet only after the applet is
	* fully constructed; applet should avoid calling methods
	* in <code>java.applet.Applet</code> in the constructor.
	*
	* @exception HeadlessException if GraphicsEnvironment.isHeadless()
	* returns true.
	* @see java.awt.GraphicsEnvironment#isHeadless
	* @since 1.4
	*/
	public Applet() throws HeadlessException {
	if (GraphicsEnvironment.isHeadless()) {
	throw new HeadlessException();
	}
	}

	/**
	* Applets can be serialized but the following conventions MUST be followed:
	*
	* Before Serialization:
	* An applet must be in STOPPED state.
	*
	* After Deserialization:
	* The applet will be restored in STOPPED state (and most clients will
	* likely move it into RUNNING state).
	* The stub field will be restored by the reader.
	*/
	transient private AppletStub stub;

	/* version ID for serialized form. */
	private static final long serialVersionUID = -5836846270535785031L;

	/**
	* Read an applet from an object input stream.
	* @exception HeadlessException if
	* <code>GraphicsEnvironment.isHeadless()</code> returns
	* <code>true</code>
	* @serial
	* @see java.awt.GraphicsEnvironment#isHeadless
	* @since 1.4
	*/
	private void readObject(ObjectInputStream s)
	throws ClassNotFoundException, IOException, HeadlessException {
	if (GraphicsEnvironment.isHeadless()) {
	throw new HeadlessException();
	}
	s.defaultReadObject();
	}

	/**
	* Sets this applet's stub. This is done automatically by the system.
	* <p>If there is a security manager, its <code> checkPermission </code>
	* method is called with the
	* <code>AWTPermission("setAppletStub")</code>
	* permission if a stub has already been set.
	* @param stub the new stub.
	* @exception 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) {
	s.checkPermission(new AWTPermission("setAppletStub"));
	}
	}
	this.stub = stub;
	}

	/**
	* Determines if this applet is active. An applet is marked active
	* just before its <code>start</code> method is called. It becomes
	* inactive just before its <code>stop</code> method is called.
	*
	* @return <code>true</code> if the applet is active;
	* <code>false</code> otherwise.
	* @see java.applet.Applet#start()
	* @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.
	* For example, suppose an applet is contained
	* 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
	* applet.
	* @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.
	*
	* @return the base {@link java.net.URL} of
	* the directory which contains 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
	* example, if this applet is specified as
	* <blockquote><pre>
	* <applet code="Clock" width=50 height=50>
	* <param name=Color value="blue">
	* </applet>
	* </pre></blockquote>
	* <p>
	* then a call to <code>getParameter("Color")</code> returns the
	* value <code>"blue"</code>.
	* <p>
	* The <code>name</code> argument is case insensitive.
	*
	* @param name a parameter name.
	* @return the value of the named parameter,
	* or <code>null</code> if not set.
	*/
	public String getParameter(String name) {
	return stub.getParameter(name);
	}

	/**
	* Determines this applet's context, which allows the applet to
	* query and affect the environment in which it runs.
	* <p>
	* This environment of an applet represents the document that
	* contains the applet.
	*
	* @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 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)) {
	super.resize(width, height);
	if (stub != null) {
	stub.appletResize(width, height);
	}
	}
	}

	/**
	* Requests that this applet be resized.
	*
	* @param d an object giving the new width and height.
	*/
	@SuppressWarnings("deprecation")
	public void resize(Dimension d) {
	resize(d.width, d.height);
	}

	/**
	* Indicates if this container is a validate root.
	* <p>
	* {@code Applet} objects are the validate roots, and, therefore, they
	* override this method to return {@code true}.
	*
	* @return {@code true}
	* @since 1.7
	* @see java.awt.Container#isValidateRoot
	*/
	@Override
	public boolean isValidateRoot() {
	return true;
	}

	/**
	* Requests that the argument string be displayed in the
	* "status window". Many browsers and applet viewers
	* provide such a window, where the application can inform users of
	* its current state.
	*
	* @param msg a string to display in the status window.
	*/
	public void showStatus(String msg) {
	getAppletContext().showStatus(msg);
	}

	/**
	* Returns an <code>Image</code> object that can then be painted on
	* the screen. The <code>url</code> that is passed as an argument
	* must specify an absolute URL.
	* <p>
	* This method always returns immediately, whether or not the image
	* exists. When this applet attempts to draw the image on the screen,
	* the data will be loaded. The graphics primitives that draw the
	* image will incrementally paint on the screen.
	*
	* @param url an absolute URL giving the location of the image.
	* @return the image at the specified URL.
	* @see java.awt.Image
	*/
	public Image getImage(URL url) {
	return getAppletContext().getImage(url);
	}

	/**
	* Returns an <code>Image</code> object that can then be painted on
	* the screen. The <code>url</code> argument must specify an absolute
	* URL. The <code>name</code> argument is a specifier that is
	* relative to the <code>url</code> argument.
	* <p>
	* This method always returns immediately, whether or not the image
	* exists. When this applet attempts to draw the image on the screen,
	* the data will be loaded. The graphics primitives that draw the
	* image will incrementally paint on the screen.
	*
	* @param url an absolute URL giving the base location of the image.
	* @param name the location of the image, relative to the
	* <code>url</code> argument.
	* @return the image at the specified URL.
	* @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.
	*
	* @param url points to the audio clip
	* @return the audio clip at the specified URL.
	*
	* @since 1.2
	*/
	public final static AudioClip newAudioClip(URL url) {
	return new sun.applet.AppletAudioClip(url);
	}

	/**
	* Returns the <code>AudioClip</code> object specified by the
	* <code>URL</code> argument.
	* <p>
	* This method always returns immediately, whether or not the audio
	* clip exists. When this applet attempts to play the audio clip, the
	* data will be loaded.
	*
	* @param url an absolute URL giving the location of the audio clip.
	* @return the audio clip at the specified URL.
	* @see java.applet.AudioClip
	*/
	public AudioClip getAudioClip(URL url) {
	return getAppletContext().getAudioClip(url);
	}

	/**
	* Returns the <code>AudioClip</code> object specified by the
	* <code>URL</code> and <code>name</code> arguments.
	* <p>
	* This method always returns immediately, whether or not the audio
	* clip exists. When this applet attempts to play the audio clip, the
	* data will be loaded.
	*
	* @param url an absolute URL giving the base location of the
	* audio clip.
	* @param name the location of the audio clip, relative to the
	* <code>url</code> argument.
	* @return the audio clip at the specified URL.
	* @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
	* this method to return a <code>String</code> containing information
	* about the author, version, and copyright of the applet.
	* <p>
	* The implementation of this method provided by the
	* <code>Applet</code> class returns <code>null</code>.
	*
	* @return a string containing information about the author, version, and
	* copyright of the applet.
	*/
	public String getAppletInfo() {
	return null;
	}

	/**
	* Gets the locale of the applet. It allows the applet
	* to maintain its own locale separated from the locale
	* of the browser or appletviewer.
	*
	* @return the locale of the applet; if no locale has
	* been set, the default locale is returned.
	* @since JDK1.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
	* this applet. An applet should override this method to return an
	* array of <code>Strings</code> describing these parameters.
	* <p>
	* Each element of the array should be a set of three
	* <code>Strings</code> containing the name, the type, and a
	* 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
	* <code>Applet</code> class returns <code>null</code>.
	*
	* @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
	* happens if the audio clip cannot be found.
	*
	* @param url an absolute 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
	* relative to it. Nothing happens if the audio clip cannot be found.
	*
	* @param url an absolute URL giving the base location of the
	* audio clip.
	* @param name the location of the audio clip, relative to the
	* <code>url</code> 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
	* this applet that it has been loaded into the system. It is always
	* called before the first time that the <code>start</code> method is
	* called.
	* <p>
	* A subclass of <code>Applet</code> should override this method if
	* it has initialization to perform. For example, an applet with
	* threads would use the <code>init</code> method to create the
	* threads and the <code>destroy</code> method to kill them.
	* <p>
	* The implementation of this method provided by the
	* <code>Applet</code> 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</code> method and each time the applet is revisited
	* in a Web page.
	* <p>
	* A subclass of <code>Applet</code> 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</code> method to
	* resume animation, and the <code>stop</code> method to suspend the
	* animation.
	* <p>
	* Note: some methods, such as <code>getLocationOnScreen</code>, can only
	* provide meaningful results if the applet is showing. Because
	* <code>isShowing</code> returns <code>false</code> when the applet's
	* <code>start</code> is first called, methods requiring
	* <code>isShowing</code> to return <code>true</code> should be called from
	* a <code>ComponentListener</code>.
	* <p>
	* The implementation of this method provided by the
	* <code>Applet</code> 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</code> 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</code> method to
	* resume animation, and the <code>stop</code> method to suspend the
	* animation.
	* <p>
	* The implementation of this method provided by the
	* <code>Applet</code> 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</code> method
	* will always be called before <code>destroy</code>.
	* <p>
	* A subclass of <code>Applet</code> 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</code> method to create the threads and the
	* <code>destroy</code> method to kill them.
	* <p>
	* The implementation of this method provided by the
	* <code>Applet</code> class does nothing.
	*
	* @see java.applet.Applet#init()
	* @see java.applet.Applet#start()
	* @see java.applet.Applet#stop()
	*/
	public void destroy() {
	}

	//
	// Accessibility support
	//

	AccessibleContext accessibleContext = null;

	/**
	* Gets the AccessibleContext associated with this Applet.
	* For applets, the AccessibleContext takes the form of an
	* AccessibleApplet.
	* A new AccessibleApplet instance is created if necessary.
	*
	* @return an AccessibleApplet that serves as the
	* AccessibleContext of this Applet
	* @since 1.3
	*/
	public AccessibleContext getAccessibleContext() {
	if (accessibleContext == null) {
	accessibleContext = new AccessibleApplet();
	}
	return accessibleContext;
	}

	/**
	* This class implements accessibility support for the
	* <code>Applet</code> class. It provides an implementation of the
	* Java Accessibility API appropriate to applet user-interface elements.
	* @since 1.3
	*/
	protected class AccessibleApplet extends AccessibleAWTPanel {

	private static final long serialVersionUID = 8127374778187708896L;

	/**
	* Get the role of this object.
	*
	* @return an instance of AccessibleRole describing the role of the
	* object
	*/
	public AccessibleRole getAccessibleRole() {
	return AccessibleRole.FRAME;
	}

	/**
	* Get the state of this object.
	*
	* @return an instance of AccessibleStateSet containing the current
	* state set of the object
	* @see AccessibleState
	*/
	public AccessibleStateSet getAccessibleStateSet() {
	AccessibleStateSet states = super.getAccessibleStateSet();
	states.add(AccessibleState.ACTIVE);
	return states;
	}

	}
	}

Back to index...