| /* |
| * 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(); |
| |
| } |
