/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package java.awt;
import java.awt.event.AWTEventListener;
import java.awt.event.AWTEventListenerProxy;
import java.awt.event.InputEvent;
import java.awt.im.InputMethodHighlight;
import java.awt.image.ColorModel;
import java.awt.image.ImageObserver;
import java.awt.image.ImageProducer;
import java.awt.peer.FontPeer;
import java.beans.PropertyChangeListener;
import java.beans.PropertyChangeSupport;
import java.lang.reflect.InvocationTargetException;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Collections;
import java.util.EventListener;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.MissingResourceException;
import java.util.Properties;
import java.util.ResourceBundle;
import org.apache.harmony.awt.ChoiceStyle;
import org.apache.harmony.awt.ComponentInternals;
import org.apache.harmony.awt.ContextStorage;
import org.apache.harmony.awt.ReadOnlyIterator;
import org.apache.harmony.awt.internal.nls.Messages;
import org.apache.harmony.awt.wtk.CreationParams;
import org.apache.harmony.awt.wtk.GraphicsFactory;
import org.apache.harmony.awt.wtk.NativeCursor;
import org.apache.harmony.awt.wtk.NativeEventQueue;
import org.apache.harmony.awt.wtk.NativeEventThread;
import org.apache.harmony.awt.wtk.ShutdownWatchdog;
import org.apache.harmony.awt.wtk.Synchronizer;
import org.apache.harmony.awt.wtk.WTK;
import org.apache.harmony.luni.util.NotImplementedException;
/**
* The Toolkit class is the representation of the platform-specific Abstract
* Window Toolkit implementation. Toolkit's subclasses are used to bind the
* various components to particular native toolkit implementations.
*
* @since Android 1.0
*/
public abstract class Toolkit {
/**
* The Constant RECOURCE_PATH.
*/
private static final String RECOURCE_PATH = "org.apache.harmony.awt.resources.AWTProperties"; //$NON-NLS-1$
/**
* The Constant properties.
*/
private static final ResourceBundle properties = loadResources(RECOURCE_PATH);
/**
* The dispatcher.
*/
Dispatcher dispatcher;
/**
* The system event queue core.
*/
private EventQueueCore systemEventQueueCore;
/**
* The dispatch thread.
*/
EventDispatchThread dispatchThread;
/**
* The native thread.
*/
NativeEventThread nativeThread;
/**
* The AWT events manager.
*/
protected AWTEventsManager awtEventsManager;
/**
* The Class AWTTreeLock.
*/
private class AWTTreeLock {
}
/**
* The AWT tree lock.
*/
final Object awtTreeLock = new AWTTreeLock();
/**
* The synchronizer.
*/
private final Synchronizer synchronizer = ContextStorage.getSynchronizer();
/**
* The shutdown watchdog.
*/
final ShutdownWatchdog shutdownWatchdog = new ShutdownWatchdog();
/**
* The auto number.
*/
final AutoNumber autoNumber = new AutoNumber();
/**
* The event type lookup.
*/
final AWTEvent.EventTypeLookup eventTypeLookup = new AWTEvent.EventTypeLookup();
/**
* The b dynamic layout set.
*/
private boolean bDynamicLayoutSet = true;
/**
* The set of desktop properties that user set directly.
*/
private final HashSet<String> userPropSet = new HashSet<String>();
/**
* The desktop properties.
*/
protected Map<String, Object> desktopProperties;
/**
* The desktop props support.
*/
protected PropertyChangeSupport desktopPropsSupport;
/**
* For this component the native window is being created It is used in the
* callback-driven window creation (e.g. on Windows in the handler of
* WM_CREATE event) to establish the connection between this component and
* its native window.
*/
private Object recentNativeWindowComponent;
/**
* The wtk.
*/
private WTK wtk;
/**
* The Class ComponentInternalsImpl.
*
* @since Android 1.0
*/
protected final class ComponentInternalsImpl extends ComponentInternals {
/**
* Shutdown.
*/
@Override
public void shutdown() {
dispatchThread.shutdown();
}
/**
* Sets the desktop property to the specified value and fires a property
* change event.
*
* @param name
* the name of property.
* @param value
* the new value of property.
*/
@Override
public void setDesktopProperty(String name, Object value) {
Toolkit.this.setDesktopProperty(name, value);
}
}
/**
* A lot of methods must throw HeadlessException if
* <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>.
*
* @throws HeadlessException
* the headless exception.
*/
static void checkHeadless() throws HeadlessException {
if (GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance())
throw new HeadlessException();
}
/**
* Lock AWT.
*/
final void lockAWT() {
synchronizer.lock();
}
/**
* Static lock AWT.
*/
static final void staticLockAWT() {
ContextStorage.getSynchronizer().lock();
}
/**
* Unlock AWT.
*/
final void unlockAWT() {
synchronizer.unlock();
}
/**
* Static unlock AWT.
*/
static final void staticUnlockAWT() {
ContextStorage.getSynchronizer().unlock();
}
/**
* InvokeAndWait under AWT lock. W/o this method system can hang up. Added
* to support modality (Dialog.show() & PopupMenu.show()) from not event
* dispatch thread. Use in other cases is not recommended. Still can be
* called only for whole API methods that cannot be called from other
* classes API methods. Examples: show() for modal dialogs - correct, only
* user can call it, directly or through setVisible(true) setBounds() for
* components - incorrect, setBounds() can be called from layoutContainer()
* for layout managers
*
* @param runnable
* the runnable.
* @throws InterruptedException
* the interrupted exception.
* @throws InvocationTargetException
* the invocation target exception.
*/
final void unsafeInvokeAndWait(Runnable runnable) throws InterruptedException,
InvocationTargetException {
synchronizer.storeStateAndFree();
try {
EventQueue.invokeAndWait(runnable);
} finally {
synchronizer.lockAndRestoreState();
}
}
/**
* Gets the synchronizer.
*
* @return the synchronizer.
*/
final Synchronizer getSynchronizer() {
return synchronizer;
}
/**
* Gets the wTK.
*
* @return the wTK.
*/
final WTK getWTK() {
return wtk;
}
/**
* Gets the property with the specified key and default value. This method
* returns the defValue if the property is not found.
*
* @param propName
* the name of property.
* @param defVal
* the default value.
* @return the property value.
*/
public static String getProperty(String propName, String defVal) {
if (propName == null) {
// awt.7D=Property name is null
throw new NullPointerException(Messages.getString("awt.7D")); //$NON-NLS-1$
}
staticLockAWT();
try {
String retVal = null;
if (properties != null) {
try {
retVal = properties.getString(propName);
} catch (MissingResourceException e) {
} catch (ClassCastException e) {
}
}
return (retVal == null) ? defVal : retVal;
} finally {
staticUnlockAWT();
}
}
/**
* Gets the default Toolkit.
*
* @return the default Toolkit.
*/
public static Toolkit getDefaultToolkit() {
synchronized (ContextStorage.getContextLock()) {
if (ContextStorage.shutdownPending()) {
return null;
}
Toolkit defToolkit = ContextStorage.getDefaultToolkit();
if (defToolkit != null) {
return defToolkit;
}
staticLockAWT();
try {
defToolkit = GraphicsEnvironment.isHeadless() ? new HeadlessToolkit()
: new ToolkitImpl();
ContextStorage.setDefaultToolkit(defToolkit);
return defToolkit;
} finally {
staticUnlockAWT();
}
// TODO: read system property named awt.toolkit
// and create an instance of the specified class,
// by default use ToolkitImpl
}
}
/**
* Gets the default Font.
*
* @return the default Font for Toolkit.
*/
Font getDefaultFont() {
return wtk.getSystemProperties().getDefaultFont();
}
/**
* Load resources.
*
* @param path
* the path.
* @return the resource bundle.
*/
private static ResourceBundle loadResources(String path) {
try {
return ResourceBundle.getBundle(path);
} catch (MissingResourceException e) {
return null;
}
}
/**
* Gets the wTK class name.
*
* @return the wTK class name.
*/
private static String getWTKClassName() {
return "com.android.internal.awt.AndroidWTK";
}
/**
* Gets the component by id.
*
* @param id
* the id.
* @return the component by id.
*/
Component getComponentById(long id) {
if (id == 0) {
return null;
}
return null;
}
/**
* Gets the GraphicsFactory.
*
* @return the GraphicsFactory object.
*/
public GraphicsFactory getGraphicsFactory() {
return wtk.getGraphicsFactory();
}
/**
* Instantiates a new toolkit.
*/
public Toolkit() {
init();
}
/**
* Initiates AWT.
*/
protected void init() {
lockAWT();
try {
ComponentInternals.setComponentInternals(new ComponentInternalsImpl());
new EventQueue(this); // create the system EventQueue
dispatcher = new Dispatcher(this);
final String className = getWTKClassName();
desktopProperties = new HashMap<String, Object>();
desktopPropsSupport = new PropertyChangeSupport(this);
awtEventsManager = new AWTEventsManager();
dispatchThread = new EventDispatchThread(this, dispatcher);
nativeThread = new NativeEventThread();
NativeEventThread.Init init = new NativeEventThread.Init() {
public WTK init() {
wtk = createWTK(className);
wtk.getNativeEventQueue().setShutdownWatchdog(shutdownWatchdog);
synchronizer.setEnvironment(wtk, dispatchThread);
ContextStorage.setWTK(wtk);
return wtk;
}
};
nativeThread.start(init);
dispatchThread.start();
wtk.getNativeEventQueue().awake();
} finally {
unlockAWT();
}
}
/**
* Synchronizes this toolkit's graphics.
*/
public abstract void sync();
/**
* Returns the construction status of a specified image that is being
* created.
*
* @param a0
* the image to be checked.
* @param a1
* the width of scaled image for which the status is being
* checked or -1.
* @param a2
* the height of scaled image for which the status is being
* checked or -1.
* @param a3
* the ImageObserver object to be notified while the image is
* being prepared.
* @return the ImageObserver flags which give the current state of the image
* data.
*/
public abstract int checkImage(Image a0, int a1, int a2, ImageObserver a3);
/**
* Creates the image with the specified ImageProducer.
*
* @param a0
* the ImageProducer to be used for image creation.
* @return the image with the specified ImageProducer.
*/
public abstract Image createImage(ImageProducer a0);
/**
* Creates the image from the specified byte array, offset and length. The
* byte array should contain data with image format supported by Toolkit
* such as JPEG, GIF, or PNG.
*
* @param a0
* the byte array with the image data.
* @param a1
* the offset of the beginning the image data in the byte array.
* @param a2
* the length of the image data in the byte array.
* @return the created Image.
*/
public abstract Image createImage(byte[] a0, int a1, int a2);
/**
* Creates the image using image data from the specified URL.
*
* @param a0
* the URL for extracting image data.
* @return the Image.
*/
public abstract Image createImage(URL a0);
/**
* Creates the image using image data from the specified file.
*
* @param a0
* the file name which contains image data of supported format.
* @return the Image.
*/
public abstract Image createImage(String a0);
/**
* Gets the color model.
*
* @return the ColorModel of Toolkit's screen.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public abstract ColorModel getColorModel() throws HeadlessException;
/**
* Gets the screen device metrics for the specified font.
*
* @param font
* the Font.
* @return the FontMetrics for the specified Font.
* @deprecated Use getLineMetrics method from Font class.
*/
@Deprecated
public abstract FontMetrics getFontMetrics(Font font);
/**
* Prepares the specified image for rendering on the screen with the
* specified size.
*
* @param a0
* the Image to be prepared.
* @param a1
* the width of the screen representation or -1 for the current
* screen.
* @param a2
* the height of the screen representation or -1 for the current
* screen.
* @param a3
* the ImageObserver object to be notified as soon as the image
* is prepared.
* @return true, if image is fully prepared, false otherwise.
*/
public abstract boolean prepareImage(Image a0, int a1, int a2, ImageObserver a3);
/**
* Creates an audio beep.
*/
public abstract void beep();
/**
* Returns the array of font names which are available in this Toolkit.
*
* @return the array of font names which are available in this Toolkit.
* @deprecated use GraphicsEnvironment.getAvailableFontFamilyNames() method.
*/
@Deprecated
public abstract String[] getFontList();
/**
* Gets the the Font implementation using the specified peer interface.
*
* @param a0
* the Font name to be implemented.
* @param a1
* the the font style: PLAIN, BOLD, ITALIC.
* @return the FontPeer implementation of the specified Font.
* @deprecated use java.awt.GraphicsEnvironment.getAllFonts method.
*/
@Deprecated
protected abstract FontPeer getFontPeer(String a0, int a1);
/**
* Gets the image from the specified file which contains image data in a
* supported image format (such as JPEG, GIF, or PNG); this method should
* return the same Image for multiple calls of this method with the same
* image file name.
*
* @param a0
* the file name which contains image data in a supported image
* format (such as JPEG, GIF, or PNG).
* @return the Image.
*/
public abstract Image getImage(String a0);
/**
* Gets the image from the specified URL which contains image data in a
* supported image format (such as JPEG, GIF, or PNG); this method should
* return the same Image for multiple calls of this method with the same
* image URL.
*
* @param a0
* the URL which contains image data in a supported image format
* (such as JPEG, GIF, or PNG).
* @return the Image.
*/
public abstract Image getImage(URL a0);
/**
* Gets the screen resolution.
*
* @return the screen resolution.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public abstract int getScreenResolution() throws HeadlessException;
/**
* Gets the screen size.
*
* @return a Dimension object containing the width and height of the screen.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public abstract Dimension getScreenSize() throws HeadlessException;
/**
* Gets the EventQueue instance without checking access.
*
* @return the system EventQueue.
*/
protected abstract EventQueue getSystemEventQueueImpl();
/**
* Returns a map of text attributes for the abstract level description of
* the specified input method highlight, or null if no mapping is found.
*
* @param highlight
* the InputMethodHighlight.
* @return the Map<java.awt.font. text attribute,?>.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public abstract Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlight(
InputMethodHighlight highlight) throws HeadlessException;
/**
* Map input method highlight impl.
*
* @param highlight
* the highlight.
* @return the map<java.awt.font. text attribute,?>.
* @throws HeadlessException
* the headless exception.
*/
Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlightImpl(InputMethodHighlight highlight)
throws HeadlessException {
HashMap<java.awt.font.TextAttribute, ?> map = new HashMap<java.awt.font.TextAttribute, Object>();
wtk.getSystemProperties().mapInputMethodHighlight(highlight, map);
return Collections.<java.awt.font.TextAttribute, Object> unmodifiableMap(map);
}
/**
* Adds the specified PropertyChangeListener listener for the specified
* property.
*
* @param propName
* the property name for which the specified
* PropertyChangeListener will be added.
* @param l
* the PropertyChangeListener object.
*/
public void addPropertyChangeListener(String propName, PropertyChangeListener l) {
lockAWT();
try {
if (desktopProperties.isEmpty()) {
initializeDesktopProperties();
}
} finally {
unlockAWT();
}
if (l != null) { // there is no guarantee that null listener will not be
// added
desktopPropsSupport.addPropertyChangeListener(propName, l);
}
}
/**
* Returns an array of the property change listeners registered with this
* Toolkit.
*
* @return an array of the property change listeners registered with this
* Toolkit.
*/
public PropertyChangeListener[] getPropertyChangeListeners() {
return desktopPropsSupport.getPropertyChangeListeners();
}
/**
* Returns an array of the property change listeners registered with this
* Toolkit for notification regarding the specified property.
*
* @param propName
* the property name for which the PropertyChangeListener was
* registered.
* @return the array of PropertyChangeListeners registered for the specified
* property name.
*/
public PropertyChangeListener[] getPropertyChangeListeners(String propName) {
return desktopPropsSupport.getPropertyChangeListeners(propName);
}
/**
* Removes the specified property change listener registered for the
* specified property name.
*
* @param propName
* the property name.
* @param l
* the PropertyChangeListener registered for the specified
* property name.
*/
public void removePropertyChangeListener(String propName, PropertyChangeListener l) {
desktopPropsSupport.removePropertyChangeListener(propName, l);
}
/**
* Creates a custom cursor with the specified Image, hot spot, and cursor
* description.
*
* @param img
* the image of activated cursor.
* @param hotSpot
* the Point giving the coordinates of the cursor's hot spot.
* @param name
* the cursor description.
* @return the cursor with the specified Image, hot spot, and cursor
* description.
* @throws IndexOutOfBoundsException
* if the hot spot values are outside the bounds of the cursor.
* @throws HeadlessException
* if isHeadless() method of GraphicsEnvironment class returns
* true.
*/
public Cursor createCustomCursor(Image img, Point hotSpot, String name)
throws IndexOutOfBoundsException, HeadlessException {
lockAWT();
try {
int w = img.getWidth(null), x = hotSpot.x;
int h = img.getHeight(null), y = hotSpot.y;
if (x < 0 || x >= w || y < 0 || y >= h) {
// awt.7E=invalid hotSpot
throw new IndexOutOfBoundsException(Messages.getString("awt.7E")); //$NON-NLS-1$
}
return new Cursor(name, img, hotSpot);
} finally {
unlockAWT();
}
}
/**
* Returns the supported cursor dimension which is closest to the specified
* width and height. If the Toolkit only supports a single cursor size, this
* method should return the supported cursor size. If custom cursor is not
* supported, a dimension of 0, 0 should be returned.
*
* @param prefWidth
* the preferred cursor width.
* @param prefHeight
* the preferred cursor height.
* @return the supported cursor dimension which is closest to the specified
* width and height.
* @throws HeadlessException
* if GraphicsEnvironment.isHeadless() returns true.
*/
public Dimension getBestCursorSize(int prefWidth, int prefHeight) throws HeadlessException {
lockAWT();
try {
return wtk.getCursorFactory().getBestCursorSize(prefWidth, prefHeight);
} finally {
unlockAWT();
}
}
/**
* Gets the value for the specified desktop property.
*
* @param propName
* the property name.
* @return the Object that is the property's value.
*/
public final Object getDesktopProperty(String propName) {
lockAWT();
try {
if (desktopProperties.isEmpty()) {
initializeDesktopProperties();
}
if (propName.equals("awt.dynamicLayoutSupported")) { //$NON-NLS-1$
// dynamicLayoutSupported is special case
return Boolean.valueOf(isDynamicLayoutActive());
}
Object val = desktopProperties.get(propName);
if (val == null) {
// try to lazily load prop value
// just for compatibility, our lazilyLoad is empty
val = lazilyLoadDesktopProperty(propName);
}
return val;
} finally {
unlockAWT();
}
}
/**
* Returns the locking key state for the specified key.
*
* @param a0
* the key code: VK_CAPS_LOCK, VK_NUM_LOCK, VK_SCROLL_LOCK, or
* VK_KANA_LOCK.
* @return true if the specified key code is in the locked state, false
* otherwise.
* @throws UnsupportedOperationException
* if the state of this key can't be retrieved, or if the
* keyboard doesn't have this key.
* @throws NotImplementedException
* if this method is not implemented.
*/
public boolean getLockingKeyState(int a0) throws UnsupportedOperationException,
org.apache.harmony.luni.util.NotImplementedException {
lockAWT();
try {
} finally {
unlockAWT();
}
if (true) {
throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
}
return true;
}
/**
* Returns the maximum number of colors which the Toolkit supports for
* custom cursor.
*
* @return the maximum cursor colors.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public int getMaximumCursorColors() throws HeadlessException {
lockAWT();
try {
return wtk.getCursorFactory().getMaximumCursorColors();
} finally {
unlockAWT();
}
}
/**
* Gets the menu shortcut key mask.
*
* @return the menu shortcut key mask.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public int getMenuShortcutKeyMask() throws HeadlessException {
lockAWT();
try {
return InputEvent.CTRL_MASK;
} finally {
unlockAWT();
}
}
/**
* Gets the screen insets.
*
* @param gc
* the GraphicsConfiguration.
* @return the insets of this toolkit.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public Insets getScreenInsets(GraphicsConfiguration gc) throws HeadlessException {
if (gc == null) {
throw new NullPointerException();
}
lockAWT();
try {
return new Insets(0, 0, 0, 0); // TODO: get real screen insets
} finally {
unlockAWT();
}
}
/**
* Gets the system EventQueue instance. If the default implementation of
* checkAwtEventQueueAccess is used, then this results of a call to the
* security manager's checkPermission method with an
* AWTPermission("accessEventQueue") permission.
*
* @return the system EventQueue instance.
*/
public final EventQueue getSystemEventQueue() {
SecurityManager sm = System.getSecurityManager();
if (sm != null) {
sm.checkAwtEventQueueAccess();
}
return getSystemEventQueueImpl();
}
/**
* Gets the system event queue core.
*
* @return the system event queue core.
*/
EventQueueCore getSystemEventQueueCore() {
return systemEventQueueCore;
}
/**
* Sets the system event queue core.
*
* @param core
* the new system event queue core.
*/
void setSystemEventQueueCore(EventQueueCore core) {
systemEventQueueCore = core;
}
/**
* Initialize the desktop properties.
*/
protected void initializeDesktopProperties() {
lockAWT();
try {
wtk.getSystemProperties().init(desktopProperties);
} finally {
unlockAWT();
}
}
/**
* Checks if dynamic layout of Containers is active or not.
*
* @return true, if is dynamic layout of Containers is active, false
* otherwise.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public boolean isDynamicLayoutActive() throws HeadlessException {
lockAWT();
try {
// always return true
return true;
} finally {
unlockAWT();
}
}
/**
* Returns if the layout of Containers is checked dynamically during
* resizing, or statically after resizing is completed.
*
* @return true, if if the layout of Containers is checked dynamically
* during resizing; false, if the layout of Containers is checked
* statically after resizing is completed.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
protected boolean isDynamicLayoutSet() throws HeadlessException {
lockAWT();
try {
return bDynamicLayoutSet;
} finally {
unlockAWT();
}
}
/**
* Checks if the specified frame state is supported by Toolkit or not.
*
* @param state
* the frame state.
* @return true, if frame state is supported, false otherwise.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public boolean isFrameStateSupported(int state) throws HeadlessException {
lockAWT();
try {
return wtk.getWindowFactory().isWindowStateSupported(state);
} finally {
unlockAWT();
}
}
/**
* Loads the value of the desktop property with the specified property name.
*
* @param propName
* the property name.
* @return the desktop property values.
*/
protected Object lazilyLoadDesktopProperty(String propName) {
return null;
}
/**
* Loads the current system color values to the specified array.
*
* @param colors
* the array where the current system color values are written by
* this method.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
protected void loadSystemColors(int[] colors) throws HeadlessException {
lockAWT();
try {
} finally {
unlockAWT();
}
}
/**
* Sets the value of the desktop property with the specified name.
*
* @param propName
* the property's name.
* @param value
* the property's value.
*/
protected final void setDesktopProperty(String propName, Object value) {
Object oldVal;
lockAWT();
try {
oldVal = getDesktopProperty(propName);
userPropSet.add(propName);
desktopProperties.put(propName, value);
} finally {
unlockAWT();
}
desktopPropsSupport.firePropertyChange(propName, oldVal, value);
}
/**
* Sets the layout state, whether the Container layout is checked
* dynamically during resizing, or statically after resizing is completed.
*
* @param dynamic
* the new dynamic layout state - if true the layout of
* Containers is checked dynamically during resizing, if false -
* statically after resizing is completed.
* @throws HeadlessException
* if the GraphicsEnvironment.isHeadless() method returns true.
*/
public void setDynamicLayout(boolean dynamic) throws HeadlessException {
lockAWT();
try {
bDynamicLayoutSet = dynamic;
} finally {
unlockAWT();
}
}
/**
* Sets the locking key state for the specified key code.
*
* @param a0
* the key code: VK_CAPS_LOCK, VK_NUM_LOCK, VK_SCROLL_LOCK, or
* VK_KANA_LOCK.
* @param a1
* the state - true to set the specified key code to the locked
* state, false - to unlock it.
* @throws UnsupportedOperationException
* if the state of this key can't be set, or if the keyboard
* doesn't have this key.
* @throws NotImplementedException
* if this method is not implemented.
*/
public void setLockingKeyState(int a0, boolean a1) throws UnsupportedOperationException,
org.apache.harmony.luni.util.NotImplementedException {
lockAWT();
try {
} finally {
unlockAWT();
}
if (true) {
throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
}
return;
}
/**
* On queue empty.
*/
void onQueueEmpty() {
throw new RuntimeException("Not implemented!");
}
/**
* Creates the wtk.
*
* @param clsName
* the cls name.
* @return the wTK.
*/
private WTK createWTK(String clsName) {
WTK newWTK = null;
try {
newWTK = (WTK)Class.forName(clsName).newInstance();
} catch (Exception e) {
throw new RuntimeException(e);
}
return newWTK;
}
/**
* Connect the component to its native window
*
* @param winId
* the id of native window just created.
*/
boolean onWindowCreated(long winId) {
return false;
}
/**
* Gets the native event queue.
*
* @return the native event queue.
*/
NativeEventQueue getNativeEventQueue() {
return wtk.getNativeEventQueue();
}
/**
* Returns a shared instance of implementation of
* org.apache.harmony.awt.wtk.NativeCursor for current platform for.
*
* @param type
* the Java Cursor type.
* @return new instance of implementation of NativeCursor.
*/
NativeCursor createNativeCursor(int type) {
return wtk.getCursorFactory().getCursor(type);
}
/**
* Returns a shared instance of implementation of
* org.apache.harmony.awt.wtk.NativeCursor for current platform for custom
* cursor
*
* @param img
* the img.
* @param hotSpot
* the hot spot.
* @param name
* the name.
* @return new instance of implementation of NativeCursor.
*/
NativeCursor createCustomNativeCursor(Image img, Point hotSpot, String name) {
return wtk.getCursorFactory().createCustomCursor(img, hotSpot.x, hotSpot.y);
}
/**
* Adds an AWTEventListener to the Toolkit to listen for events of types
* corresponding to bits in the specified event mask. Event masks are
* defined in AWTEvent class.
*
* @param listener
* the AWTEventListener.
* @param eventMask
* the bitmask of event types.
*/
public void addAWTEventListener(AWTEventListener listener, long eventMask) {
lockAWT();
try {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(awtEventsManager.permission);
}
awtEventsManager.addAWTEventListener(listener, eventMask);
} finally {
unlockAWT();
}
}
/**
* Removes the specified AWT event listener.
*
* @param listener
* the AWTEventListener to be removed.
*/
public void removeAWTEventListener(AWTEventListener listener) {
lockAWT();
try {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(awtEventsManager.permission);
}
awtEventsManager.removeAWTEventListener(listener);
} finally {
unlockAWT();
}
}
/**
* Gets the array of all AWT event listeners registered with this Toolkit.
*
* @return the array of all AWT event listeners registered with this
* Toolkit.
*/
public AWTEventListener[] getAWTEventListeners() {
lockAWT();
try {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(awtEventsManager.permission);
}
return awtEventsManager.getAWTEventListeners();
} finally {
unlockAWT();
}
}
/**
* Returns the array of the AWT event listeners registered with this Toolkit
* for the event types corresponding to the specified event mask.
*
* @param eventMask
* the bit mask of event type.
* @return the array of the AWT event listeners registered in this Toolkit
* for the event types corresponding to the specified event mask.
*/
public AWTEventListener[] getAWTEventListeners(long eventMask) {
lockAWT();
try {
SecurityManager security = System.getSecurityManager();
if (security != null) {
security.checkPermission(awtEventsManager.permission);
}
return awtEventsManager.getAWTEventListeners(eventMask);
} finally {
unlockAWT();
}
}
/**
* Dispatch AWT event.
*
* @param event
* the event.
*/
void dispatchAWTEvent(AWTEvent event) {
awtEventsManager.dispatchAWTEvent(event);
}
/**
* The Class AWTEventsManager.
*/
final class AWTEventsManager {
/**
* The permission.
*/
AWTPermission permission = new AWTPermission("listenToAllAWTEvents"); //$NON-NLS-1$
/**
* The listeners.
*/
private final AWTListenerList<AWTEventListenerProxy> listeners = new AWTListenerList<AWTEventListenerProxy>();
/**
* Adds the AWT event listener.
*
* @param listener
* the listener.
* @param eventMask
* the event mask.
*/
void addAWTEventListener(AWTEventListener listener, long eventMask) {
if (listener != null) {
listeners.addUserListener(new AWTEventListenerProxy(eventMask, listener));
}
}
/**
* Removes the AWT event listener.
*
* @param listener
* the listener.
*/
void removeAWTEventListener(AWTEventListener listener) {
if (listener != null) {
for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
if (listener == proxy.getListener()) {
listeners.removeUserListener(proxy);
return;
}
}
}
}
/**
* Gets the AWT event listeners.
*
* @return the AWT event listeners.
*/
AWTEventListener[] getAWTEventListeners() {
HashSet<EventListener> listenersSet = new HashSet<EventListener>();
for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
listenersSet.add(proxy.getListener());
}
return listenersSet.toArray(new AWTEventListener[listenersSet.size()]);
}
/**
* Gets the AWT event listeners.
*
* @param eventMask
* the event mask.
* @return the AWT event listeners.
*/
AWTEventListener[] getAWTEventListeners(long eventMask) {
HashSet<EventListener> listenersSet = new HashSet<EventListener>();
for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
if ((proxy.getEventMask() & eventMask) == eventMask) {
listenersSet.add(proxy.getListener());
}
}
return listenersSet.toArray(new AWTEventListener[listenersSet.size()]);
}
/**
* Dispatch AWT event.
*
* @param event
* the event.
*/
void dispatchAWTEvent(AWTEvent event) {
AWTEvent.EventDescriptor descriptor = eventTypeLookup.getEventDescriptor(event);
if (descriptor == null) {
return;
}
for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
if ((proxy.getEventMask() & descriptor.eventMask) != 0) {
proxy.eventDispatched(event);
}
}
}
}
/**
* The Class AutoNumber.
*/
static final class AutoNumber {
/**
* The next component.
*/
int nextComponent = 0;
/**
* The next canvas.
*/
int nextCanvas = 0;
/**
* The next panel.
*/
int nextPanel = 0;
/**
* The next window.
*/
int nextWindow = 0;
/**
* The next frame.
*/
int nextFrame = 0;
/**
* The next dialog.
*/
int nextDialog = 0;
/**
* The next button.
*/
int nextButton = 0;
/**
* The next menu component.
*/
int nextMenuComponent = 0;
/**
* The next label.
*/
int nextLabel = 0;
/**
* The next check box.
*/
int nextCheckBox = 0;
/**
* The next scrollbar.
*/
int nextScrollbar = 0;
/**
* The next scroll pane.
*/
int nextScrollPane = 0;
/**
* The next list.
*/
int nextList = 0;
/**
* The next choice.
*/
int nextChoice = 0;
/**
* The next file dialog.
*/
int nextFileDialog = 0;
/**
* The next text area.
*/
int nextTextArea = 0;
/**
* The next text field.
*/
int nextTextField = 0;
}
private class Lock {
}
/**
* The lock.
*/
private final Object lock = new Lock();
}
|
