| /* |
| * 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; |
| |
| /** |
| * 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. |
| */ |
| 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. |
| */ |
| 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 derault 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(); |
| } |
| |
| /** |
| * Inits 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 beggining 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 preffered cursor width. |
| * @param prefHeight the preffered 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 othrwise. |
| * |
| * @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 - 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 - 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 he 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(); |
| |
| } |