Toolkit class are used to bind the various components
* to particular native toolkit implementations.
* * Many GUI events may be delivered to user * asynchronously, if the opposite is not specified explicitly. * As well as * many GUI operations may be performed asynchronously. * This fact means that if the state of a component is set, and then * the state immediately queried, the returned value may not yet * reflect the requested change. This behavior includes, but is not * limited to: *
ScrollPane.setScrollPosition
* and then getScrollPosition may return an incorrect
* value if the original request has not yet been processed.
* *
*
setVisible(true) on a Window,
* Frame or Dialog may occur
* asynchronously.
* *
setSize, setBounds or
* setLocation on a Window,
* Frame or Dialog are forwarded
* to the underlying window management system and may be
* ignored or modified. See {@link java.awt.Window} for
* more information.
*
* Most applications should not call any of the methods in this
* class directly. The methods defined by Toolkit are
* the "glue" that joins the platform-independent classes in the
* java.awt package with their counterparts in
* java.awt.peer. Some methods defined by
* Toolkit query the native operating system directly.
*
* @author Sami Shaio
* @author Arthur van Hoff
* @author Fred Ecks
* @since JDK1.0
*/
public abstract class Toolkit {
/**
* Creates this toolkit's implementation of the Desktop
* using the specified peer interface.
* @param target the desktop to be implemented
* @return this toolkit's implementation of the Desktop
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Desktop
* @see java.awt.peer.DesktopPeer
* @since 1.6
*/
protected abstract DesktopPeer createDesktopPeer(Desktop target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Button using
* the specified peer interface.
* @param target the button to be implemented.
* @return this toolkit's implementation of Button.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Button
* @see java.awt.peer.ButtonPeer
*/
protected abstract ButtonPeer createButton(Button target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of TextField using
* the specified peer interface.
* @param target the text field to be implemented.
* @return this toolkit's implementation of TextField.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.TextField
* @see java.awt.peer.TextFieldPeer
*/
protected abstract TextFieldPeer createTextField(TextField target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Label using
* the specified peer interface.
* @param target the label to be implemented.
* @return this toolkit's implementation of Label.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Label
* @see java.awt.peer.LabelPeer
*/
protected abstract LabelPeer createLabel(Label target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of List using
* the specified peer interface.
* @param target the list to be implemented.
* @return this toolkit's implementation of List.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.List
* @see java.awt.peer.ListPeer
*/
protected abstract ListPeer createList(java.awt.List target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Checkbox using
* the specified peer interface.
* @param target the check box to be implemented.
* @return this toolkit's implementation of Checkbox.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Checkbox
* @see java.awt.peer.CheckboxPeer
*/
protected abstract CheckboxPeer createCheckbox(Checkbox target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Scrollbar using
* the specified peer interface.
* @param target the scroll bar to be implemented.
* @return this toolkit's implementation of Scrollbar.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Scrollbar
* @see java.awt.peer.ScrollbarPeer
*/
protected abstract ScrollbarPeer createScrollbar(Scrollbar target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of ScrollPane using
* the specified peer interface.
* @param target the scroll pane to be implemented.
* @return this toolkit's implementation of ScrollPane.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.ScrollPane
* @see java.awt.peer.ScrollPanePeer
* @since JDK1.1
*/
protected abstract ScrollPanePeer createScrollPane(ScrollPane target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of TextArea using
* the specified peer interface.
* @param target the text area to be implemented.
* @return this toolkit's implementation of TextArea.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.TextArea
* @see java.awt.peer.TextAreaPeer
*/
protected abstract TextAreaPeer createTextArea(TextArea target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Choice using
* the specified peer interface.
* @param target the choice to be implemented.
* @return this toolkit's implementation of Choice.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Choice
* @see java.awt.peer.ChoicePeer
*/
protected abstract ChoicePeer createChoice(Choice target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Frame using
* the specified peer interface.
* @param target the frame to be implemented.
* @return this toolkit's implementation of Frame.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Frame
* @see java.awt.peer.FramePeer
*/
protected abstract FramePeer createFrame(Frame target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Canvas using
* the specified peer interface.
* @param target the canvas to be implemented.
* @return this toolkit's implementation of Canvas.
* @see java.awt.Canvas
* @see java.awt.peer.CanvasPeer
*/
protected abstract CanvasPeer createCanvas(Canvas target);
/**
* Creates this toolkit's implementation of Panel using
* the specified peer interface.
* @param target the panel to be implemented.
* @return this toolkit's implementation of Panel.
* @see java.awt.Panel
* @see java.awt.peer.PanelPeer
*/
protected abstract PanelPeer createPanel(Panel target);
/**
* Creates this toolkit's implementation of Window using
* the specified peer interface.
* @param target the window to be implemented.
* @return this toolkit's implementation of Window.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Window
* @see java.awt.peer.WindowPeer
*/
protected abstract WindowPeer createWindow(Window target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Dialog using
* the specified peer interface.
* @param target the dialog to be implemented.
* @return this toolkit's implementation of Dialog.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Dialog
* @see java.awt.peer.DialogPeer
*/
protected abstract DialogPeer createDialog(Dialog target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of MenuBar using
* the specified peer interface.
* @param target the menu bar to be implemented.
* @return this toolkit's implementation of MenuBar.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.MenuBar
* @see java.awt.peer.MenuBarPeer
*/
protected abstract MenuBarPeer createMenuBar(MenuBar target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of Menu using
* the specified peer interface.
* @param target the menu to be implemented.
* @return this toolkit's implementation of Menu.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.Menu
* @see java.awt.peer.MenuPeer
*/
protected abstract MenuPeer createMenu(Menu target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of PopupMenu using
* the specified peer interface.
* @param target the popup menu to be implemented.
* @return this toolkit's implementation of PopupMenu.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.PopupMenu
* @see java.awt.peer.PopupMenuPeer
* @since JDK1.1
*/
protected abstract PopupMenuPeer createPopupMenu(PopupMenu target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of MenuItem using
* the specified peer interface.
* @param target the menu item to be implemented.
* @return this toolkit's implementation of MenuItem.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.MenuItem
* @see java.awt.peer.MenuItemPeer
*/
protected abstract MenuItemPeer createMenuItem(MenuItem target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of FileDialog using
* the specified peer interface.
* @param target the file dialog to be implemented.
* @return this toolkit's implementation of FileDialog.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.FileDialog
* @see java.awt.peer.FileDialogPeer
*/
protected abstract FileDialogPeer createFileDialog(FileDialog target)
throws HeadlessException;
/**
* Creates this toolkit's implementation of CheckboxMenuItem using
* the specified peer interface.
* @param target the checkbox menu item to be implemented.
* @return this toolkit's implementation of CheckboxMenuItem.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.CheckboxMenuItem
* @see java.awt.peer.CheckboxMenuItemPeer
*/
protected abstract CheckboxMenuItemPeer createCheckboxMenuItem(
CheckboxMenuItem target) throws HeadlessException;
/**
* Obtains this toolkit's implementation of helper class for
* MouseInfo operations.
* @return this toolkit's implementation of helper for MouseInfo
* @throws UnsupportedOperationException if this operation is not implemented
* @see java.awt.peer.MouseInfoPeer
* @see java.awt.MouseInfo
* @since 1.5
*/
protected MouseInfoPeer getMouseInfoPeer() {
throw new UnsupportedOperationException("Not implemented");
}
private static LightweightPeer lightweightMarker;
/**
* Creates a peer for a component or container. This peer is windowless
* and allows the Component and Container classes to be extended directly
* to create windowless components that are defined entirely in java.
*
* @param target The Component to be created.
*/
protected LightweightPeer createComponent(Component target) {
if (lightweightMarker == null) {
lightweightMarker = new NullComponentPeer();
}
return lightweightMarker;
}
/**
* Creates this toolkit's implementation of Font using
* the specified peer interface.
* @param name the font to be implemented
* @param style the style of the font, such as PLAIN,
* BOLD, ITALIC, or a combination
* @return this toolkit's implementation of Font
* @see java.awt.Font
* @see java.awt.peer.FontPeer
* @see java.awt.GraphicsEnvironment#getAllFonts
* @deprecated see java.awt.GraphicsEnvironment#getAllFonts
*/
@Deprecated
protected abstract FontPeer getFontPeer(String name, int style);
// The following method is called by the private method
// updateSystemColors in SystemColor.
/**
* Fills in the integer array that is supplied as an argument
* with the current system color values.
*
* @param systemColors an integer array.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since JDK1.1
*/
protected void loadSystemColors(int[] systemColors)
throws HeadlessException {
GraphicsEnvironment.checkHeadless();
}
/**
* Controls whether the layout of Containers is validated dynamically
* during resizing, or statically, after resizing is complete.
* Use {@code isDynamicLayoutActive()} to detect if this feature enabled
* in this program and is supported by this operating system
* and/or window manager.
* Note that this feature is supported not on all platforms, and
* conversely, that this feature cannot be turned off on some platforms.
* On these platforms where dynamic layout during resizing is not supported
* (or is always supported), setting this property has no effect.
* Note that this feature can be set or unset as a property of the
* operating system or window manager on some platforms. On such
* platforms, the dynamic resize property must be set at the operating
* system or window manager level before this method can take effect.
* This method does not change support or settings of the underlying
* operating system or
* window manager. The OS/WM support can be
* queried using getDesktopProperty("awt.dynamicLayoutSupported") method.
*
* @param dynamic If true, Containers should re-layout their
* components as the Container is being resized. If false,
* the layout will be validated after resizing is completed.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see #isDynamicLayoutSet()
* @see #isDynamicLayoutActive()
* @see #getDesktopProperty(String propertyName)
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.4
*/
public void setDynamicLayout(boolean dynamic)
throws HeadlessException {
GraphicsEnvironment.checkHeadless();
}
/**
* Returns whether the layout of Containers is validated dynamically
* during resizing, or statically, after resizing is complete.
* Note: this method returns the value that was set programmatically;
* it does not reflect support at the level of the operating system
* or window manager for dynamic layout on resizing, or the current
* operating system or window manager settings. The OS/WM support can
* be queried using getDesktopProperty("awt.dynamicLayoutSupported").
*
* @return true if validation of Containers is done dynamically,
* false if validation is done after resizing is finished.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see #setDynamicLayout(boolean dynamic)
* @see #isDynamicLayoutActive()
* @see #getDesktopProperty(String propertyName)
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.4
*/
protected boolean isDynamicLayoutSet()
throws HeadlessException {
GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().isDynamicLayoutSet();
} else {
return false;
}
}
/**
* Returns whether dynamic layout of Containers on resize is
* currently active (both set in program
*( {@code isDynamicLayoutSet()} )
*, and supported
* by the underlying operating system and/or window manager).
* If dynamic layout is currently inactive then Containers
* re-layout their components when resizing is completed. As a result
* the {@code Component.validate()} method will be invoked only
* once per resize.
* If dynamic layout is currently active then Containers
* re-layout their components on every native resize event and
* the {@code validate()} method will be invoked each time.
* The OS/WM support can be queried using
* the getDesktopProperty("awt.dynamicLayoutSupported") method.
*
* @return true if dynamic layout of Containers on resize is
* currently active, false otherwise.
* @exception HeadlessException if the GraphicsEnvironment.isHeadless()
* method returns true
* @see #setDynamicLayout(boolean dynamic)
* @see #isDynamicLayoutSet()
* @see #getDesktopProperty(String propertyName)
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.4
*/
public boolean isDynamicLayoutActive()
throws HeadlessException {
GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().isDynamicLayoutActive();
} else {
return false;
}
}
/**
* Gets the size of the screen. On systems with multiple displays, the
* primary display is used. Multi-screen aware display dimensions are
* available from GraphicsConfiguration and
* GraphicsDevice.
* @return the size of this toolkit's screen, in pixels.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsConfiguration#getBounds
* @see java.awt.GraphicsDevice#getDisplayMode
* @see java.awt.GraphicsEnvironment#isHeadless
*/
public abstract Dimension getScreenSize()
throws HeadlessException;
/**
* Returns the screen resolution in dots-per-inch.
* @return this toolkit's screen resolution, in dots-per-inch.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
*/
public abstract int getScreenResolution()
throws HeadlessException;
/**
* Gets the insets of the screen.
* @param gc a GraphicsConfiguration
* @return the insets of this toolkit's screen, in pixels.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.4
*/
public Insets getScreenInsets(GraphicsConfiguration gc)
throws HeadlessException {
GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getScreenInsets(gc);
} else {
return new Insets(0, 0, 0, 0);
}
}
/**
* Determines the color model of this toolkit's screen.
*
* ColorModel is an abstract class that
* encapsulates the ability to translate between the
* pixel values of an image and its red, green, blue,
* and alpha components.
*
* This toolkit method is called by the
* getColorModel method
* of the Component class.
* @return the color model of this toolkit's screen.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.image.ColorModel
* @see java.awt.Component#getColorModel
*/
public abstract ColorModel getColorModel()
throws HeadlessException;
/**
* Returns the names of the available fonts in this toolkit.
* For 1.1, the following font names are deprecated (the replacement * name follows): *
* The ZapfDingbats fontname is also deprecated in 1.1 but the characters
* are defined in Unicode starting at 0x2700, and as of 1.1 Java supports
* those characters.
* @return the names of the available fonts in this toolkit.
* @deprecated see {@link java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()}
* @see java.awt.GraphicsEnvironment#getAvailableFontFamilyNames()
*/
@Deprecated
public abstract String[] getFontList();
/**
* Gets the screen device metrics for rendering of the font.
* @param font a font
* @return the screen metrics of the specified font in this toolkit
* @deprecated As of JDK version 1.2, replaced by the Font
* method getLineMetrics.
* @see java.awt.font.LineMetrics
* @see java.awt.Font#getLineMetrics
* @see java.awt.GraphicsEnvironment#getScreenDevices
*/
@Deprecated
public abstract FontMetrics getFontMetrics(Font font);
/**
* Synchronizes this toolkit's graphics state. Some window systems
* may do buffering of graphics events.
*
* This method ensures that the display is up-to-date. It is useful * for animation. */ public abstract void sync(); /** * The default toolkit. */ private static Toolkit toolkit; /** * Used internally by the assistive technologies functions; set at * init time and used at load time */ private static String atNames; /** * Initializes properties related to assistive technologies. * These properties are used both in the loadAssistiveProperties() * function below, as well as other classes in the jdk that depend * on the properties (such as the use of the screen_magnifier_present * property in Java2D hardware acceleration initialization). The * initialization of the properties must be done before the platform- * specific Toolkit class is instantiated so that all necessary * properties are set up properly before any classes dependent upon them * are initialized. */ private static void initAssistiveTechnologies() { // Get accessibility properties final String sep = File.separator; final Properties properties = new Properties(); atNames = (String)java.security.AccessController.doPrivileged( new java.security.PrivilegedAction() { public Object run() { // Try loading the per-user accessibility properties file. try { File propsFile = new File( System.getProperty("user.home") + sep + ".accessibility.properties"); FileInputStream in = new FileInputStream(propsFile); // Inputstream has been buffered in Properties class properties.load(in); in.close(); } catch (Exception e) { // Per-user accessibility properties file does not exist } // Try loading the system-wide accessibility properties // file only if a per-user accessibility properties // file does not exist or is empty. if (properties.size() == 0) { try { File propsFile = new File( System.getProperty("java.home") + sep + "lib" + sep + "accessibility.properties"); FileInputStream in = new FileInputStream(propsFile); // Inputstream has been buffered in Properties class properties.load(in); in.close(); } catch (Exception e) { // System-wide accessibility properties file does // not exist; } } // Get whether a screen magnifier is present. First check // the system property and then check the properties file. String magPresent = System.getProperty("javax.accessibility.screen_magnifier_present"); if (magPresent == null) { magPresent = properties.getProperty("screen_magnifier_present", null); if (magPresent != null) { System.setProperty("javax.accessibility.screen_magnifier_present", magPresent); } } // Get the names of any assistive technolgies to load. First // check the system property and then check the properties // file. String classNames = System.getProperty("javax.accessibility.assistive_technologies"); if (classNames == null) { classNames = properties.getProperty("assistive_technologies", null); if (classNames != null) { System.setProperty("javax.accessibility.assistive_technologies", classNames); } } return classNames; } }); } /** * Loads additional classes into the VM, using the property * 'assistive_technologies' specified in the Sun reference * implementation by a line in the 'accessibility.properties' * file. The form is "assistive_technologies=..." where * the "..." is a comma-separated list of assistive technology * classes to load. Each class is loaded in the order given * and a single instance of each is created using * Class.forName(class).newInstance(). All errors are handled * via an AWTError exception. * *
The assumption is made that assistive technology classes are supplied
* as part of INSTALLED (as opposed to: BUNDLED) extensions or specified
* on the class path
* (and therefore can be loaded using the class loader returned by
* a call to ClassLoader.getSystemClassLoader, whose
* delegation parent is the extension class loader for installed
* extensions).
*/
private static void loadAssistiveTechnologies() {
// Load any assistive technologies
if (atNames != null) {
ClassLoader cl = ClassLoader.getSystemClassLoader();
StringTokenizer parser = new StringTokenizer(atNames," ,");
String atName;
while (parser.hasMoreTokens()) {
atName = parser.nextToken();
try {
Class clazz;
if (cl != null) {
clazz = cl.loadClass(atName);
} else {
clazz = Class.forName(atName);
}
clazz.newInstance();
} catch (ClassNotFoundException e) {
throw new AWTError("Assistive Technology not found: "
+ atName);
} catch (InstantiationException e) {
throw new AWTError("Could not instantiate Assistive"
+ " Technology: " + atName);
} catch (IllegalAccessException e) {
throw new AWTError("Could not access Assistive"
+ " Technology: " + atName);
} catch (Exception e) {
throw new AWTError("Error trying to install Assistive"
+ " Technology: " + atName + " " + e);
}
}
}
}
/**
* Gets the default toolkit.
*
* If a system property named "java.awt.headless" is set
* to true then the headless implementation
* of Toolkit is used.
*
* If there is no "java.awt.headless" or it is set to
* false and there is a system property named
* "awt.toolkit",
* that property is treated as the name of a class that is a subclass
* of Toolkit;
* otherwise the default platform-specific implementation of
* Toolkit is used.
*
* Also loads additional classes into the VM, using the property * 'assistive_technologies' specified in the Sun reference * implementation by a line in the 'accessibility.properties' * file. The form is "assistive_technologies=..." where * the "..." is a comma-separated list of assistive technology * classes to load. Each class is loaded in the order given * and a single instance of each is created using * Class.forName(class).newInstance(). This is done just after * the AWT toolkit is created. All errors are handled via an * AWTError exception. * @return the default toolkit. * @exception AWTError if a toolkit could not be found, or * if one could not be accessed or instantiated. */ public static synchronized Toolkit getDefaultToolkit() { if (toolkit == null) { try { // We disable the JIT during toolkit initialization. This // tends to touch lots of classes that aren't needed again // later and therefore JITing is counter-productiive. java.lang.Compiler.disable(); java.security.AccessController.doPrivileged( new java.security.PrivilegedAction() { public Object run() { String nm = null; Class cls = null; try { nm = System.getProperty("awt.toolkit"); try { cls = Class.forName(nm); } catch (ClassNotFoundException e) { ClassLoader cl = ClassLoader.getSystemClassLoader(); if (cl != null) { try { cls = cl.loadClass(nm); } catch (ClassNotFoundException ee) { throw new AWTError("Toolkit not found: " + nm); } } } if (cls != null) { toolkit = (Toolkit)cls.newInstance(); if (GraphicsEnvironment.isHeadless()) { toolkit = new HeadlessToolkit(toolkit); } } } catch (InstantiationException e) { throw new AWTError("Could not instantiate Toolkit: " + nm); } catch (IllegalAccessException e) { throw new AWTError("Could not access Toolkit: " + nm); } return null; } }); loadAssistiveTechnologies(); } finally { // Make sure to always re-enable the JIT. java.lang.Compiler.enable(); } } return toolkit; } /** * Returns an image which gets pixel data from the specified file, * whose format can be either GIF, JPEG or PNG. * The underlying toolkit attempts to resolve multiple requests * with the same filename to the same returned Image. *
* Since the mechanism required to facilitate this sharing of
* Image objects may continue to hold onto images
* that are no longer in use for an indefinite period of time,
* developers are encouraged to implement their own caching of
* images by using the {@link #createImage(java.lang.String) createImage}
* variant wherever available.
* If the image data contained in the specified file changes,
* the Image object returned from this method may
* still contain stale information which was loaded from the
* file after a prior call.
* Previously loaded image data can be manually discarded by
* calling the {@link Image#flush flush} method on the
* returned Image.
*
* This method first checks if there is a security manager installed.
* If so, the method calls the security manager's
* checkRead method with the file specified to ensure
* that the access to the image is allowed.
* @param filename the name of a file containing pixel data
* in a recognized file format.
* @return an image which gets its pixel data from
* the specified file.
* @throws SecurityException if a security manager exists and its
* checkRead method doesn't allow the operation.
* @see #createImage(java.lang.String)
*/
public abstract Image getImage(String filename);
/**
* Returns an image which gets pixel data from the specified URL.
* The pixel data referenced by the specified URL must be in one
* of the following formats: GIF, JPEG or PNG.
* The underlying toolkit attempts to resolve multiple requests
* with the same URL to the same returned Image.
*
* Since the mechanism required to facilitate this sharing of
* Image objects may continue to hold onto images
* that are no longer in use for an indefinite period of time,
* developers are encouraged to implement their own caching of
* images by using the {@link #createImage(java.net.URL) createImage}
* variant wherever available.
* If the image data stored at the specified URL changes,
* the Image object returned from this method may
* still contain stale information which was fetched from the
* URL after a prior call.
* Previously loaded image data can be manually discarded by
* calling the {@link Image#flush flush} method on the
* returned Image.
*
* This method first checks if there is a security manager installed.
* If so, the method calls the security manager's
* checkPermission method with the
* url.openConnection().getPermission() permission to ensure
* that the access to the image is allowed. For compatibility
* with pre-1.2 security managers, if the access is denied with
* FilePermission or SocketPermission,
* the method throws the SecurityException
* if the corresponding 1.1-style SecurityManager.checkXXX method
* also denies permission.
* @param url the URL to use in fetching the pixel data.
* @return an image which gets its pixel data from
* the specified URL.
* @throws SecurityException if a security manager exists and its
* checkPermission method doesn't allow
* the operation.
* @see #createImage(java.net.URL)
*/
public abstract Image getImage(URL url);
/**
* Returns an image which gets pixel data from the specified file.
* The returned Image is a new object which will not be shared
* with any other caller of this method or its getImage variant.
*
* This method first checks if there is a security manager installed.
* If so, the method calls the security manager's
* checkRead method with the specified file to ensure
* that the image creation is allowed.
* @param filename the name of a file containing pixel data
* in a recognized file format.
* @return an image which gets its pixel data from
* the specified file.
* @throws SecurityException if a security manager exists and its
* checkRead method doesn't allow the operation.
* @see #getImage(java.lang.String)
*/
public abstract Image createImage(String filename);
/**
* Returns an image which gets pixel data from the specified URL.
* The returned Image is a new object which will not be shared
* with any other caller of this method or its getImage variant.
*
* This method first checks if there is a security manager installed.
* If so, the method calls the security manager's
* checkPermission method with the
* url.openConnection().getPermission() permission to ensure
* that the image creation is allowed. For compatibility
* with pre-1.2 security managers, if the access is denied with
* FilePermission or SocketPermission,
* the method throws SecurityException
* if the corresponding 1.1-style SecurityManager.checkXXX method
* also denies permission.
* @param url the URL to use in fetching the pixel data.
* @return an image which gets its pixel data from
* the specified URL.
* @throws SecurityException if a security manager exists and its
* checkPermission method doesn't allow
* the operation.
* @see #getImage(java.net.URL)
*/
public abstract Image createImage(URL url);
/**
* Prepares an image for rendering.
*
* If the values of the width and height arguments are both
* -1, this method prepares the image for rendering
* on the default screen; otherwise, this method prepares an image
* for rendering on the default screen at the specified width and height.
*
* The image data is downloaded asynchronously in another thread, * and an appropriately scaled screen representation of the image is * generated. *
* This method is called by components prepareImage
* methods.
*
* Information on the flags returned by this method can be found
* with the definition of the ImageObserver interface.
* @param image the image for which to prepare a
* screen representation.
* @param width the width of the desired screen
* representation, or -1.
* @param height the height of the desired screen
* representation, or -1.
* @param observer the ImageObserver
* object to be notified as the
* image is being prepared.
* @return true if the image has already been
* fully prepared; false otherwise.
* @see java.awt.Component#prepareImage(java.awt.Image,
* java.awt.image.ImageObserver)
* @see java.awt.Component#prepareImage(java.awt.Image,
* int, int, java.awt.image.ImageObserver)
* @see java.awt.image.ImageObserver
*/
public abstract boolean prepareImage(Image image, int width, int height,
ImageObserver observer);
/**
* Indicates the construction status of a specified image that is
* being prepared for display.
*
* If the values of the width and height arguments are both
* -1, this method returns the construction status of
* a screen representation of the specified image in this toolkit.
* Otherwise, this method returns the construction status of a
* scaled representation of the image at the specified width
* and height.
*
* This method does not cause the image to begin loading.
* An application must call prepareImage to force
* the loading of an image.
*
* This method is called by the component's checkImage
* methods.
*
* Information on the flags returned by this method can be found
* with the definition of the ImageObserver interface.
* @param image the image whose status is being checked.
* @param width the width of the scaled version whose status is
* being checked, or -1.
* @param height the height of the scaled version whose status
* is being checked, or -1.
* @param observer the ImageObserver object to be
* notified as the image is being prepared.
* @return the bitwise inclusive OR of the
* ImageObserver flags for the
* image data that is currently available.
* @see java.awt.Toolkit#prepareImage(java.awt.Image,
* int, int, java.awt.image.ImageObserver)
* @see java.awt.Component#checkImage(java.awt.Image,
* java.awt.image.ImageObserver)
* @see java.awt.Component#checkImage(java.awt.Image,
* int, int, java.awt.image.ImageObserver)
* @see java.awt.image.ImageObserver
*/
public abstract int checkImage(Image image, int width, int height,
ImageObserver observer);
/**
* Creates an image with the specified image producer.
* @param producer the image producer to be used.
* @return an image with the specified image producer.
* @see java.awt.Image
* @see java.awt.image.ImageProducer
* @see java.awt.Component#createImage(java.awt.image.ImageProducer)
*/
public abstract Image createImage(ImageProducer producer);
/**
* Creates an image which decodes the image stored in the specified
* byte array.
*
* The data must be in some image format, such as GIF or JPEG,
* that is supported by this toolkit.
* @param imagedata an array of bytes, representing
* image data in a supported image format.
* @return an image.
* @since JDK1.1
*/
public Image createImage(byte[] imagedata) {
return createImage(imagedata, 0, imagedata.length);
}
/**
* Creates an image which decodes the image stored in the specified
* byte array, and at the specified offset and length.
* The data must be in some image format, such as GIF or JPEG,
* that is supported by this toolkit.
* @param imagedata an array of bytes, representing
* image data in a supported image format.
* @param imageoffset the offset of the beginning
* of the data in the array.
* @param imagelength the length of the data in the array.
* @return an image.
* @since JDK1.1
*/
public abstract Image createImage(byte[] imagedata,
int imageoffset,
int imagelength);
/**
* Gets a PrintJob object which is the result of initiating
* a print operation on the toolkit's platform.
*
* Each actual implementation of this method should first check if there
* is a security manager installed. If there is, the method should call
* the security manager's checkPrintJobAccess method to
* ensure initiation of a print operation is allowed. If the default
* implementation of checkPrintJobAccess is used (that is,
* that method is not overriden), then this results in a call to the
* security manager's checkPermission method with a
* RuntimePermission("queuePrintJob") permission.
*
* @param frame the parent of the print dialog. May not be null.
* @param jobtitle the title of the PrintJob. A null title is equivalent
* to "".
* @param props a Properties object containing zero or more properties.
* Properties are not standardized and are not consistent across
* implementations. Because of this, PrintJobs which require job
* and page control should use the version of this function which
* takes JobAttributes and PageAttributes objects. This object
* may be updated to reflect the user's job choices on exit. May
* be null.
* @return a PrintJob object, or null if the
* user cancelled the print job.
* @throws NullPointerException if frame is null
* @throws SecurityException if this thread is not allowed to initiate a
* print job request
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.PrintJob
* @see java.lang.RuntimePermission
* @since JDK1.1
*/
public abstract PrintJob getPrintJob(Frame frame, String jobtitle,
Properties props);
/**
* Gets a PrintJob object which is the result of initiating
* a print operation on the toolkit's platform.
*
* Each actual implementation of this method should first check if there
* is a security manager installed. If there is, the method should call
* the security manager's checkPrintJobAccess method to
* ensure initiation of a print operation is allowed. If the default
* implementation of checkPrintJobAccess is used (that is,
* that method is not overriden), then this results in a call to the
* security manager's checkPermission method with a
* RuntimePermission("queuePrintJob") permission.
*
* @param frame the parent of the print dialog. May not be null.
* @param jobtitle the title of the PrintJob. A null title is equivalent
* to "".
* @param jobAttributes a set of job attributes which will control the
* PrintJob. The attributes will be updated to reflect the user's
* choices as outlined in the JobAttributes documentation. May be
* null.
* @param pageAttributes a set of page attributes which will control the
* PrintJob. The attributes will be applied to every page in the
* job. The attributes will be updated to reflect the user's
* choices as outlined in the PageAttributes documentation. May be
* null.
* @return a PrintJob object, or null if the
* user cancelled the print job.
* @throws NullPointerException if frame is null
* @throws IllegalArgumentException if pageAttributes specifies differing
* cross feed and feed resolutions. Also if this thread has
* access to the file system and jobAttributes specifies
* print to file, and the specified destination file exists but
* is a directory rather than a regular file, does not exist but
* cannot be created, or cannot be opened for any other reason.
* However in the case of print to file, if a dialog is also
* requested to be displayed then the user will be given an
* opportunity to select a file and proceed with printing.
* The dialog will ensure that the selected output file
* is valid before returning from this method.
* @throws SecurityException if this thread is not allowed to initiate a
* print job request, or if jobAttributes specifies print to file,
* and this thread is not allowed to access the file system
* @see java.awt.PrintJob
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.lang.RuntimePermission
* @see java.awt.JobAttributes
* @see java.awt.PageAttributes
* @since 1.3
*/
public PrintJob getPrintJob(Frame frame, String jobtitle,
JobAttributes jobAttributes,
PageAttributes pageAttributes) {
// Override to add printing support with new job/page control classes
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getPrintJob(frame, jobtitle,
jobAttributes,
pageAttributes);
} else {
return getPrintJob(frame, jobtitle, null);
}
}
/**
* Emits an audio beep.
* @since JDK1.1
*/
public abstract void beep();
/**
* Gets the singleton instance of the system Clipboard which interfaces
* with clipboard facilities provided by the native platform. This
* clipboard enables data transfer between Java programs and native
* applications which use native clipboard facilities.
*
* In addition to any and all formats specified in the flavormap.properties
* file, or other file specified by the AWT.DnD.flavorMapFileURL
* Toolkit property, text returned by the system Clipboard's
* getTransferData() method is available in the following flavors:
*
java.awt.datatransfer.StringSelection, if the
* requested flavor is DataFlavor.plainTextFlavor, or an
* equivalent flavor, a Reader is returned. Note: The behavior of
* the system Clipboard's getTransferData() method for
* DataFlavor.plainTextFlavor, and equivalent DataFlavors, is
* inconsistent with the definition of DataFlavor.plainTextFlavor
* . Because of this, support for
* DataFlavor.plainTextFlavor, and equivalent flavors, is
* deprecated.
*
* Each actual implementation of this method should first check if there
* is a security manager installed. If there is, the method should call
* the security manager's checkSystemClipboardAccess method
* to ensure it's ok to to access the system clipboard. If the default
* implementation of checkSystemClipboardAccess is used (that
* is, that method is not overriden), then this results in a call to the
* security manager's checkPermission method with an
* AWTPermission("accessClipboard") permission.
*
* @return the system Clipboard
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.datatransfer.Clipboard
* @see java.awt.datatransfer.StringSelection
* @see java.awt.datatransfer.DataFlavor#stringFlavor
* @see java.awt.datatransfer.DataFlavor#plainTextFlavor
* @see java.io.Reader
* @see java.awt.AWTPermission
* @since JDK1.1
*/
public abstract Clipboard getSystemClipboard()
throws HeadlessException;
/**
* Gets the singleton instance of the system selection as a
* Clipboard object. This allows an application to read and
* modify the current, system-wide selection.
*
* An application is responsible for updating the system selection whenever
* the user selects text, using either the mouse or the keyboard.
* Typically, this is implemented by installing a
* FocusListener on all Components which support
* text selection, and, between FOCUS_GAINED and
* FOCUS_LOST events delivered to that Component,
* updating the system selection Clipboard when the selection
* changes inside the Component. Properly updating the system
* selection ensures that a Java application will interact correctly with
* native applications and other Java applications running simultaneously
* on the system. Note that java.awt.TextComponent and
* javax.swing.text.JTextComponent already adhere to this
* policy. When using these classes, and their subclasses, developers need
* not write any additional code.
*
* Some platforms do not support a system selection Clipboard.
* On those platforms, this method will return null. In such a
* case, an application is absolved from its responsibility to update the
* system selection Clipboard as described above.
*
* Each actual implementation of this method should first check if there
* is a SecurityManager installed. If there is, the method
* should call the SecurityManager's
* checkSystemClipboardAccess method to ensure that client
* code has access the system selection. If the default implementation of
* checkSystemClipboardAccess is used (that is, if the method
* is not overridden), then this results in a call to the
* SecurityManager's checkPermission method with
* an AWTPermission("accessClipboard") permission.
*
* @return the system selection as a Clipboard, or
* null if the native platform does not support a
* system selection Clipboard
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
*
* @see java.awt.datatransfer.Clipboard
* @see java.awt.event.FocusListener
* @see java.awt.event.FocusEvent#FOCUS_GAINED
* @see java.awt.event.FocusEvent#FOCUS_LOST
* @see TextComponent
* @see javax.swing.text.JTextComponent
* @see AWTPermission
* @see GraphicsEnvironment#isHeadless
* @since 1.4
*/
public Clipboard getSystemSelection() throws HeadlessException {
GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getSystemSelection();
} else {
GraphicsEnvironment.checkHeadless();
return null;
}
}
/**
* Determines which modifier key is the appropriate accelerator
* key for menu shortcuts.
*
* Menu shortcuts, which are embodied in the
* MenuShortcut class, are handled by the
* MenuBar class.
*
* By default, this method returns Event.CTRL_MASK.
* Toolkit implementations should override this method if the
* Control key isn't the correct key for accelerators.
* @return the modifier mask on the Event class
* that is used for menu shortcuts on this toolkit.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @see java.awt.MenuBar
* @see java.awt.MenuShortcut
* @since JDK1.1
*/
public int getMenuShortcutKeyMask() throws HeadlessException {
GraphicsEnvironment.checkHeadless();
return Event.CTRL_MASK;
}
/**
* Returns whether the given locking key on the keyboard is currently in
* its "on" state.
* Valid key codes are
* {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
* {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
* {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
* {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
*
* @exception java.lang.IllegalArgumentException if keyCode
* is not one of the valid key codes
* @exception java.lang.UnsupportedOperationException if the host system doesn't
* allow getting the state of this key programmatically, or if the keyboard
* doesn't have this key
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.3
*/
public boolean getLockingKeyState(int keyCode)
throws UnsupportedOperationException
{
GraphicsEnvironment.checkHeadless();
if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
throw new IllegalArgumentException("invalid key for Toolkit.getLockingKeyState");
}
throw new UnsupportedOperationException("Toolkit.getLockingKeyState");
}
/**
* Sets the state of the given locking key on the keyboard.
* Valid key codes are
* {@link java.awt.event.KeyEvent#VK_CAPS_LOCK VK_CAPS_LOCK},
* {@link java.awt.event.KeyEvent#VK_NUM_LOCK VK_NUM_LOCK},
* {@link java.awt.event.KeyEvent#VK_SCROLL_LOCK VK_SCROLL_LOCK}, and
* {@link java.awt.event.KeyEvent#VK_KANA_LOCK VK_KANA_LOCK}.
*
* Depending on the platform, setting the state of a locking key may
* involve event processing and therefore may not be immediately
* observable through getLockingKeyState.
*
* @exception java.lang.IllegalArgumentException if keyCode
* is not one of the valid key codes
* @exception java.lang.UnsupportedOperationException if the host system doesn't
* allow setting the state of this key programmatically, or if the keyboard
* doesn't have this key
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.3
*/
public void setLockingKeyState(int keyCode, boolean on)
throws UnsupportedOperationException
{
GraphicsEnvironment.checkHeadless();
if (! (keyCode == KeyEvent.VK_CAPS_LOCK || keyCode == KeyEvent.VK_NUM_LOCK ||
keyCode == KeyEvent.VK_SCROLL_LOCK || keyCode == KeyEvent.VK_KANA_LOCK)) {
throw new IllegalArgumentException("invalid key for Toolkit.setLockingKeyState");
}
throw new UnsupportedOperationException("Toolkit.setLockingKeyState");
}
/**
* Give native peers the ability to query the native container
* given a native component (eg the direct parent may be lightweight).
*/
protected static Container getNativeContainer(Component c) {
return c.getNativeContainer();
}
/**
* Creates a new custom cursor object.
* If the image to display is invalid, the cursor will be hidden (made
* completely transparent), and the hotspot will be set to (0, 0).
*
*
Note that multi-frame images are invalid and may cause this
* method to hang.
*
* @param cursor the image to display when the cursor is actived
* @param hotSpot the X and Y of the large cursor's hot spot; the
* hotSpot values must be less than the Dimension returned by
* getBestCursorSize
* @param name a localized description of the cursor, for Java Accessibility use
* @exception IndexOutOfBoundsException if the hotSpot values are outside
* the bounds of the cursor
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.2
*/
public Cursor createCustomCursor(Image cursor, Point hotSpot, String name)
throws IndexOutOfBoundsException, HeadlessException
{
// Override to implement custom cursor support.
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().
createCustomCursor(cursor, hotSpot, name);
} else {
return new Cursor(Cursor.DEFAULT_CURSOR);
}
}
/**
* Returns the supported cursor dimension which is closest to the desired
* sizes. Systems which only support a single cursor size will return that
* size regardless of the desired sizes. Systems which don't support custom
* cursors will return a dimension of 0, 0.
* Note: if an image is used whose dimensions don't match a supported size * (as returned by this method), the Toolkit implementation will attempt to * resize the image to a supported size. * Since converting low-resolution images is difficult, * no guarantees are made as to the quality of a cursor image which isn't a * supported size. It is therefore recommended that this method * be called and an appropriate image used so no image conversion is made. * * @param preferredWidth the preferred cursor width the component would like * to use. * @param preferredHeight the preferred cursor height the component would like * to use. * @return the closest matching supported cursor size, or a dimension of 0,0 if * the Toolkit implementation doesn't support custom cursors. * @exception HeadlessException if GraphicsEnvironment.isHeadless() * returns true * @see java.awt.GraphicsEnvironment#isHeadless * @since 1.2 */ public Dimension getBestCursorSize(int preferredWidth, int preferredHeight) throws HeadlessException { GraphicsEnvironment.checkHeadless(); // Override to implement custom cursor support. if (this != Toolkit.getDefaultToolkit()) { return Toolkit.getDefaultToolkit(). getBestCursorSize(preferredWidth, preferredHeight); } else { return new Dimension(0, 0); } } /** * Returns the maximum number of colors the Toolkit supports in a custom cursor * palette.
* Note: if an image is used which has more colors in its palette than
* the supported maximum, the Toolkit implementation will attempt to flatten the
* palette to the maximum. Since converting low-resolution images is difficult,
* no guarantees are made as to the quality of a cursor image which has more
* colors than the system supports. It is therefore recommended that this method
* be called and an appropriate image used so no image conversion is made.
*
* @return the maximum number of colors, or zero if custom cursors are not
* supported by this Toolkit implementation.
* @exception HeadlessException if GraphicsEnvironment.isHeadless()
* returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.2
*/
public int getMaximumCursorColors() throws HeadlessException {
GraphicsEnvironment.checkHeadless();
// Override to implement custom cursor support.
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().getMaximumCursorColors();
} else {
return 0;
}
}
/**
* Returns whether Toolkit supports this state for
* Frames. This method tells whether the UI
* concept of, say, maximization or iconification is
* supported. It will always return false for "compound" states
* like Frame.ICONIFIED|Frame.MAXIMIZED_VERT.
* In other words, the rule of thumb is that only queries with a
* single frame state constant as an argument are meaningful.
*
Note that supporting a given concept is a platform- * dependent feature. Due to native limitations the Toolkit * object may report a particular state as supported, however at * the same time the Toolkit object will be unable to apply the * state to a given frame. This circumstance has two following * consequences: *
true is this frame state is supported by
* this Toolkit implementation, false otherwise.
* @exception HeadlessException
* if GraphicsEnvironment.isHeadless()
* returns true.
* @see java.awt.Window#addWindowStateListener
* @since 1.4
*/
public boolean isFrameStateSupported(int state)
throws HeadlessException
{
GraphicsEnvironment.checkHeadless();
if (this != Toolkit.getDefaultToolkit()) {
return Toolkit.getDefaultToolkit().
isFrameStateSupported(state);
} else {
return (state == Frame.NORMAL); // others are not guaranteed
}
}
/**
* Support for I18N: any visible strings should be stored in
* sun.awt.resources.awt.properties. The ResourceBundle is stored
* here, so that only one copy is maintained.
*/
private static ResourceBundle resources;
/**
* Initialize JNI field and method ids
*/
private static native void initIDs();
/**
* WARNING: This is a temporary workaround for a problem in the
* way the AWT loads native libraries. A number of classes in the
* AWT package have a native method, initIDs(), which initializes
* the JNI field and method ids used in the native portion of
* their implementation.
*
* Since the use and storage of these ids is done by the
* implementation libraries, the implementation of these method is
* provided by the particular AWT implementations (for example,
* "Toolkit"s/Peer), such as Motif, Microsoft Windows, or Tiny. The
* problem is that this means that the native libraries must be
* loaded by the java.* classes, which do not necessarily know the
* names of the libraries to load. A better way of doing this
* would be to provide a separate library which defines java.awt.*
* initIDs, and exports the relevant symbols out to the
* implementation libraries.
*
* For now, we know it's done by the implementation, and we assume
* that the name of the library is "awt". -br.
*
* If you change loadLibraries(), please add the change to
* java.awt.image.ColorModel.loadLibraries(). Unfortunately,
* classes can be loaded in java.awt.image that depend on
* libawt and there is no way to call Toolkit.loadLibraries()
* directly. -hung
*/
private static boolean loaded = false;
static void loadLibraries() {
if (!loaded) {
java.security.AccessController.doPrivileged(
new sun.security.action.LoadLibraryAction("awt"));
loaded = true;
}
}
static {
java.security.AccessController.doPrivileged(
new java.security.PrivilegedAction() {
public Object run() {
try {
resources =
ResourceBundle.getBundle("sun.awt.resources.awt",
CoreResourceBundleControl.getRBControlInstance());
} catch (MissingResourceException e) {
// No resource file; defaults will be used.
}
return null;
}
});
// ensure that the proper libraries are loaded
loadLibraries();
initAssistiveTechnologies();
if (!GraphicsEnvironment.isHeadless()) {
initIDs();
}
}
/**
* Gets a property with the specified key and default.
* This method returns defaultValue if the property is not found.
*/
public static String getProperty(String key, String defaultValue) {
if (resources != null) {
try {
return resources.getString(key);
}
catch (MissingResourceException e) {}
}
return defaultValue;
}
/**
* Get the application's or applet's EventQueue instance.
* Depending on the Toolkit implementation, different EventQueues
* may be returned for different applets. Applets should
* therefore not assume that the EventQueue instance returned
* by this method will be shared by other applets or the system.
*
* First, if there is a security manager, its
*
* First, if there is a security manager, its
*
* Note: event listener use is not recommended for normal
* application use, but are intended solely to support special
* purpose facilities including support for accessibility,
* event record/playback, and diagnostic tracing.
*
* If listener is null, no exception is thrown and no action is performed.
*
* @param listener the event listener.
* @param eventMask the bitmask of event types to receive
* @throws SecurityException
* if a security manager exists and its
*
* First, if there is a security manager, its
* Note: event listener use is not recommended for normal
* application use, but are intended solely to support special
* purpose facilities including support for accessibility,
* event record/playback, and diagnostic tracing.
*
* If listener is null, no exception is thrown and no action is performed.
*
* @param listener the event listener.
* @throws SecurityException
* if a security manager exists and its
*
* @exception HeadlessException if GraphicsEnvironment.isHeadless() returns true
* @return {@code true} if events from extra mouse buttons are allowed to be processed and posted;
* {@code false} otherwise
* @see System#getProperty(String propertyName)
* @see System#setProperty(String propertyName, String value)
* @see java.awt.EventQueue
* @since 1.7
*/
public boolean areExtraMouseButtonsEnabled() throws HeadlessException {
GraphicsEnvironment.checkHeadless();
return Toolkit.getDefaultToolkit().areExtraMouseButtonsEnabled();
}
}
checkAwtEventQueueAccess
* method is called.
* If the default implementation of checkAwtEventQueueAccess
* is used (that is, that method is not overriden), then this results in
* a call to the security manager's checkPermission method
* with an AWTPermission("accessEventQueue") permission.
*
* @return the EventQueue object
* @throws SecurityException
* if a security manager exists and its {@link
* java.lang.SecurityManager#checkAwtEventQueueAccess}
* method denies access to the EventQueue
* @see java.awt.AWTPermission
*/
public final EventQueue getSystemEventQueue() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkAwtEventQueueAccess();
}
return getSystemEventQueueImpl();
}
/**
* Gets the application's or applet's EventQueue
* instance, without checking access. For security reasons,
* this can only be called from a Toolkit subclass.
* @return the EventQueue object
*/
protected abstract EventQueue getSystemEventQueueImpl();
/* Accessor method for use by AWT package routines. */
static EventQueue getEventQueue() {
return getDefaultToolkit().getSystemEventQueueImpl();
}
/**
* Creates the peer for a DragSourceContext.
* Always throws InvalidDndOperationException if
* GraphicsEnvironment.isHeadless() returns true.
* @see java.awt.GraphicsEnvironment#isHeadless
*/
public abstract DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge) throws InvalidDnDOperationException;
/**
* Creates a concrete, platform dependent, subclass of the abstract
* DragGestureRecognizer class requested, and associates it with the
* DragSource, Component and DragGestureListener specified.
*
* subclasses should override this to provide their own implementation
*
* @param abstractRecognizerClass The abstract class of the required recognizer
* @param ds The DragSource
* @param c The Component target for the DragGestureRecognizer
* @param srcActions The actions permitted for the gesture
* @param dgl The DragGestureListener
*
* @return the new object or null. Always returns null if
* GraphicsEnvironment.isHeadless() returns true.
* @see java.awt.GraphicsEnvironment#isHeadless
*/
public true, if current toolkit supports the always-on-top mode,
* otherwise returns false
* @see Window#isAlwaysOnTopSupported
* @see Window#setAlwaysOnTop(boolean)
* @since 1.6
*/
public boolean isAlwaysOnTopSupported() {
return true;
}
/**
* Returns whether the given modality type is supported by this toolkit. If
* a dialog with unsupported modality type is created, then
* Dialog.ModalityType.MODELESS is used instead.
*
* @param modalityType modality type to be checked for support by this toolkit
*
* @return true, if current toolkit supports given modality
* type, false otherwise
*
* @see java.awt.Dialog.ModalityType
* @see java.awt.Dialog#getModalityType
* @see java.awt.Dialog#setModalityType
*
* @since 1.6
*/
public abstract boolean isModalityTypeSupported(Dialog.ModalityType modalityType);
/**
* Returns whether the given modal exclusion type is supported by this
* toolkit. If an unsupported modal exclusion type property is set on a window,
* then Dialog.ModalExclusionType.NO_EXCLUDE is used instead.
*
* @param modalExclusionType modal exclusion type to be checked for support by this toolkit
*
* @return true, if current toolkit supports given modal exclusion
* type, false otherwise
*
* @see java.awt.Dialog.ModalExclusionType
* @see java.awt.Window#getModalExclusionType
* @see java.awt.Window#setModalExclusionType
*
* @since 1.6
*/
public abstract boolean isModalExclusionTypeSupported(Dialog.ModalExclusionType modalExclusionType);
// 8014736: logging has been removed from Toolkit
private static final int LONG_BITS = 64;
private int[] calls = new int[LONG_BITS];
private static volatile long enabledOnToolkitMask;
private AWTEventListener eventListener = null;
private WeakHashMap listener2SelectiveListener = new WeakHashMap();
/*
* Extracts a "pure" AWTEventListener from a AWTEventListenerProxy,
* if the listener is proxied.
*/
static private AWTEventListener deProxyAWTEventListener(AWTEventListener l)
{
AWTEventListener localL = l;
if (localL == null) {
return null;
}
// if user passed in a AWTEventListenerProxy object, extract
// the listener
if (l instanceof AWTEventListenerProxy) {
localL = ((AWTEventListenerProxy)l).getListener();
}
return localL;
}
/**
* Adds an AWTEventListener to receive all AWTEvents dispatched
* system-wide that conform to the given eventMask.
* checkPermission
* method is called with an
* AWTPermission("listenToAllAWTEvents") permission.
* This may result in a SecurityException.
* eventMask is a bitmask of event types to receive.
* It is constructed by bitwise OR-ing together the event masks
* defined in AWTEvent.
* checkPermission method doesn't allow the operation.
* @see #removeAWTEventListener
* @see #getAWTEventListeners
* @see SecurityManager#checkPermission
* @see java.awt.AWTEvent
* @see java.awt.AWTPermission
* @see java.awt.event.AWTEventListener
* @see java.awt.event.AWTEventListenerProxy
* @since 1.2
*/
public void addAWTEventListener(AWTEventListener listener, long eventMask) {
AWTEventListener localL = deProxyAWTEventListener(listener);
if (localL == null) {
return;
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
}
synchronized (this) {
SelectiveAWTEventListener selectiveListener =
(SelectiveAWTEventListener)listener2SelectiveListener.get(localL);
if (selectiveListener == null) {
// Create a new selectiveListener.
selectiveListener = new SelectiveAWTEventListener(localL,
eventMask);
listener2SelectiveListener.put(localL, selectiveListener);
eventListener = ToolkitEventMulticaster.add(eventListener,
selectiveListener);
}
// OR the eventMask into the selectiveListener's event mask.
selectiveListener.orEventMasks(eventMask);
enabledOnToolkitMask |= eventMask;
long mask = eventMask;
for (int i=0; icheckPermission
* method is called with an
* AWTPermission("listenToAllAWTEvents") permission.
* This may result in a SecurityException.
* checkPermission method doesn't allow the operation.
* @see #addAWTEventListener
* @see #getAWTEventListeners
* @see SecurityManager#checkPermission
* @see java.awt.AWTEvent
* @see java.awt.AWTPermission
* @see java.awt.event.AWTEventListener
* @see java.awt.event.AWTEventListenerProxy
* @since 1.2
*/
public void removeAWTEventListener(AWTEventListener listener) {
AWTEventListener localL = deProxyAWTEventListener(listener);
if (listener == null) {
return;
}
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
}
synchronized (this) {
SelectiveAWTEventListener selectiveListener =
(SelectiveAWTEventListener)listener2SelectiveListener.get(localL);
if (selectiveListener != null) {
listener2SelectiveListener.remove(localL);
int[] listenerCalls = selectiveListener.getCalls();
for (int i=0; iAWTEventListeners
* registered on this toolkit.
* If there is a security manager, its {@code checkPermission}
* method is called with an
* {@code AWTPermission("listenToAllAWTEvents")} permission.
* This may result in a SecurityException.
* Listeners can be returned
* within AWTEventListenerProxy objects, which also contain
* the event mask for the given listener.
* Note that listener objects
* added multiple times appear only once in the returned array.
*
* @return all of the AWTEventListeners or an empty
* array if no listeners are currently registered
* @throws SecurityException
* if a security manager exists and its
* checkPermission method doesn't allow the operation.
* @see #addAWTEventListener
* @see #removeAWTEventListener
* @see SecurityManager#checkPermission
* @see java.awt.AWTEvent
* @see java.awt.AWTPermission
* @see java.awt.event.AWTEventListener
* @see java.awt.event.AWTEventListenerProxy
* @since 1.4
*/
public AWTEventListener[] getAWTEventListeners() {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
}
synchronized (this) {
EventListener[] la = ToolkitEventMulticaster.getListeners(eventListener,AWTEventListener.class);
AWTEventListener[] ret = new AWTEventListener[la.length];
for (int i = 0; i < la.length; i++) {
SelectiveAWTEventListener sael = (SelectiveAWTEventListener)la[i];
AWTEventListener tempL = sael.getListener();
//assert tempL is not an AWTEventListenerProxy - we should
// have weeded them all out
// don't want to wrap a proxy inside a proxy
ret[i] = new AWTEventListenerProxy(sael.getEventMask(), tempL);
}
return ret;
}
}
/**
* Returns an array of all the AWTEventListeners
* registered on this toolkit which listen to all of the event
* types specified in the {@code eventMask} argument.
* If there is a security manager, its {@code checkPermission}
* method is called with an
* {@code AWTPermission("listenToAllAWTEvents")} permission.
* This may result in a SecurityException.
* Listeners can be returned
* within AWTEventListenerProxy objects, which also contain
* the event mask for the given listener.
* Note that listener objects
* added multiple times appear only once in the returned array.
*
* @param eventMask the bitmask of event types to listen for
* @return all of the AWTEventListeners registered
* on this toolkit for the specified
* event types, or an empty array if no such listeners
* are currently registered
* @throws SecurityException
* if a security manager exists and its
* checkPermission method doesn't allow the operation.
* @see #addAWTEventListener
* @see #removeAWTEventListener
* @see SecurityManager#checkPermission
* @see java.awt.AWTEvent
* @see java.awt.AWTPermission
* @see java.awt.event.AWTEventListener
* @see java.awt.event.AWTEventListenerProxy
* @since 1.4
*/
public AWTEventListener[] getAWTEventListeners(long eventMask) {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(SecurityConstants.AWT.ALL_AWT_EVENTS_PERMISSION);
}
synchronized (this) {
EventListener[] la = ToolkitEventMulticaster.getListeners(eventListener,AWTEventListener.class);
java.util.List list = new ArrayList(la.length);
for (int i = 0; i < la.length; i++) {
SelectiveAWTEventListener sael = (SelectiveAWTEventListener)la[i];
if ((sael.getEventMask() & eventMask) == eventMask) {
//AWTEventListener tempL = sael.getListener();
list.add(new AWTEventListenerProxy(sael.getEventMask(),
sael.getListener()));
}
}
return (AWTEventListener[])list.toArray(new AWTEventListener[0]);
}
}
/*
* This method notifies any AWTEventListeners that an event
* is about to be dispatched.
*
* @param theEvent the event which will be dispatched.
*/
void notifyAWTEventListeners(AWTEvent theEvent) {
// This is a workaround for headless toolkits. It would be
// better to override this method but it is declared package private.
// "this instanceof" syntax defeats polymorphism.
// --mm, 03/03/00
if (this instanceof HeadlessToolkit) {
((HeadlessToolkit)this).getUnderlyingToolkit()
.notifyAWTEventListeners(theEvent);
return;
}
AWTEventListener eventListener = this.eventListener;
if (eventListener != null) {
eventListener.eventDispatched(theEvent);
}
}
static private class ToolkitEventMulticaster extends AWTEventMulticaster
implements AWTEventListener {
// Implementation cloned from AWTEventMulticaster.
ToolkitEventMulticaster(AWTEventListener a, AWTEventListener b) {
super(a, b);
}
static AWTEventListener add(AWTEventListener a,
AWTEventListener b) {
if (a == null) return b;
if (b == null) return a;
return new ToolkitEventMulticaster(a, b);
}
static AWTEventListener remove(AWTEventListener l,
AWTEventListener oldl) {
return (AWTEventListener) removeInternal(l, oldl);
}
// #4178589: must overload remove(EventListener) to call our add()
// instead of the static addInternal() so we allocate a
// ToolkitEventMulticaster instead of an AWTEventMulticaster.
// Note: this method is called by AWTEventListener.removeInternal(),
// so its method signature must match AWTEventListener.remove().
protected EventListener remove(EventListener oldl) {
if (oldl == a) return b;
if (oldl == b) return a;
AWTEventListener a2 = (AWTEventListener)removeInternal(a, oldl);
AWTEventListener b2 = (AWTEventListener)removeInternal(b, oldl);
if (a2 == a && b2 == b) {
return this; // it's not here
}
return add(a2, b2);
}
public void eventDispatched(AWTEvent event) {
((AWTEventListener)a).eventDispatched(event);
((AWTEventListener)b).eventDispatched(event);
}
}
private class SelectiveAWTEventListener implements AWTEventListener {
AWTEventListener listener;
private long eventMask;
// This array contains the number of times to call the eventlistener
// for each event type.
int[] calls = new int[Toolkit.LONG_BITS];
public AWTEventListener getListener() {return listener;}
public long getEventMask() {return eventMask;}
public int[] getCalls() {return calls;}
public void orEventMasks(long mask) {
eventMask |= mask;
// For each event bit set in mask, increment its call count.
for (int i=0; iGraphicsEnvironment.isHeadless returns true
* @see java.awt.GraphicsEnvironment#isHeadless
* @since 1.3
*/
public abstract Map
* To change the returned value it is necessary to set the {@code sun.awt.enableExtraMouseButtons}
* property before the {@code Toolkit} class initialization. This setting could be done on the application
* startup by the following command:
*
* java -Dsun.awt.enableExtraMouseButtons=false Application
*
* Alternatively, the property could be set in the application by using the following code:
*
* System.setProperty("sun.awt.enableExtraMouseButtons", "true");
*
* before the {@code Toolkit} class initialization.
* If not set by the time of the {@code Toolkit} class initialization, this property will be
* initialized with {@code true}.
* Changing this value after the {@code Toolkit} class initialization will have no effect.
*