/* * 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 userPropSet = new HashSet(); /** * The desktop properties. */ protected Map 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 * GraphicsEnvironment.isHeadless() returns true. * * @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(); 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. * @throws HeadlessException * if the GraphicsEnvironment.isHeadless() method returns true. */ public abstract Map mapInputMethodHighlight( InputMethodHighlight highlight) throws HeadlessException; /** * Map input method highlight impl. * * @param highlight * the highlight. * @return the map. * @throws HeadlessException * the headless exception. */ Map mapInputMethodHighlightImpl(InputMethodHighlight highlight) throws HeadlessException { HashMap map = new HashMap(); wtk.getSystemProperties().mapInputMethodHighlight(highlight, map); return Collections. 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 listeners = new AWTListenerList(); /** * 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 listenersSet = new HashSet(); 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 listenersSet = new HashSet(); 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(); }