harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r550346 [4/4] - in /harmony/enhanced/buildtest/branches/2.0: adaptors/jedit_test/ tests/jedit_test/ tests/jedit_test/scripts/ tests/jedit_test/src/ tests/jedit_test/src/org/ tests/jedit_test/src/org/apache/ tests/jedit_test/src/org/apache/h...
Date Mon, 25 Jun 2007 04:50:22 GMT
Added: harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/harmony/java/awt/Toolkit.java
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/harmony/java/awt/Toolkit.java?view=auto&rev=550346
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/harmony/java/awt/Toolkit.java (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/harmony/java/awt/Toolkit.java Sun Jun 24 21:50:20 2007
@@ -0,0 +1,1436 @@
+/*
+ *  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.datatransfer.Clipboard;
+import java.awt.dnd.DragGestureEvent;
+import java.awt.dnd.DragGestureListener;
+import java.awt.dnd.DragGestureRecognizer;
+import java.awt.dnd.DragSource;
+import java.awt.dnd.InvalidDnDOperationException;
+import java.awt.dnd.MouseDragGestureRecognizer;
+import java.awt.dnd.peer.DragSourceContextPeer;
+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.ButtonPeer;
+import java.awt.peer.CanvasPeer;
+import java.awt.peer.CheckboxMenuItemPeer;
+import java.awt.peer.CheckboxPeer;
+import java.awt.peer.ChoicePeer;
+import java.awt.peer.DialogPeer;
+import java.awt.peer.FileDialogPeer;
+import java.awt.peer.FontPeer;
+import java.awt.peer.FramePeer;
+import java.awt.peer.LabelPeer;
+import java.awt.peer.LightweightPeer;
+import java.awt.peer.ListPeer;
+import java.awt.peer.MenuBarPeer;
+import java.awt.peer.MenuItemPeer;
+import java.awt.peer.MenuPeer;
+import java.awt.peer.MouseInfoPeer;
+import java.awt.peer.PanelPeer;
+import java.awt.peer.PopupMenuPeer;
+import java.awt.peer.ScrollPanePeer;
+import java.awt.peer.ScrollbarPeer;
+import java.awt.peer.TextAreaPeer;
+import java.awt.peer.TextFieldPeer;
+import java.awt.peer.WindowPeer;
+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.LinkedHashSet;
+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.MouseEventPreprocessor;
+import org.apache.harmony.awt.ReadOnlyIterator;
+import org.apache.harmony.awt.Theme;
+import org.apache.harmony.awt.datatransfer.DTK;
+import org.apache.harmony.awt.datatransfer.NativeClipboard;
+import org.apache.harmony.awt.gl.MultiRectArea;
+import org.apache.harmony.awt.internal.nls.Messages;
+import org.apache.harmony.awt.text.TextFieldKit;
+import org.apache.harmony.awt.text.TextKit;
+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.NativeMouseInfo;
+import org.apache.harmony.awt.wtk.NativeWindow;
+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.awt.wtk.WindowFactory;
+
+public abstract class Toolkit {
+    private static final String RECOURCE_PATH = "org.apache.harmony.awt.resources.AWTProperties"; //$NON-NLS-1$
+
+    private static final ResourceBundle properties = loadResources(RECOURCE_PATH);
+
+    Dispatcher dispatcher;
+
+    private EventQueueCore systemEventQueueCore;
+
+    EventDispatchThread dispatchThread;
+
+    NativeEventThread nativeThread;
+
+    protected AWTEventsManager awtEventsManager;
+
+    /* key = nativeWindow, value = Component, should be Map<NativeWindow, Component> */
+    private final Map<NativeWindow, Object> windowComponentMap = new HashMap<NativeWindow, Object>();
+
+    /* key = nativeWindow, value = MenuComponent */
+    private final Map<NativeWindow, Object> windowPopupMap = new HashMap<NativeWindow, Object>();
+
+    private final Map<NativeWindow, Window> windowFocusProxyMap = new HashMap<NativeWindow, Window>();
+
+    private class AWTTreeLock {
+    }
+
+    final Object awtTreeLock = new AWTTreeLock();
+
+    private final Synchronizer synchronizer = ContextStorage.getSynchronizer();
+
+    final ShutdownWatchdog shutdownWatchdog = new ShutdownWatchdog();
+
+    final Theme theme = createTheme();
+
+    final AutoNumber autoNumber = new AutoNumber();
+
+    final AWTEvent.EventTypeLookup eventTypeLookup = new AWTEvent.EventTypeLookup();
+
+    final Frame.AllFrames allFrames = new Frame.AllFrames();
+
+    KeyboardFocusManager currentKeyboardFocusManager;
+
+    MouseEventPreprocessor mouseEventPreprocessor;
+
+    NativeClipboard systemClipboard = null;
+
+    private NativeClipboard systemSelection = null;
+
+    private boolean bDynamicLayoutSet = true;
+
+    /**
+     * The set of desktop properties that user set directly.
+     */
+    private final HashSet<String> userPropSet = new HashSet<String>();
+
+    protected Map<String, Object> desktopProperties;
+
+    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;
+
+    final WindowList windows = new WindowList();
+
+    private WTK wtk;
+
+    DTK dtk;
+
+    protected final class ComponentInternalsImpl extends ComponentInternals {
+        @Override
+        public NativeWindow getNativeWindow(Component component) {
+            lockAWT();
+            try {
+                return component != null ? component.getNativeWindow() : null;
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void startMouseGrab(Window grabWindow, Runnable whenCanceled) {
+            lockAWT();
+            try {
+                dispatcher.mouseGrabManager.startGrab(grabWindow, whenCanceled);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void endMouseGrab() {
+            lockAWT();
+            try {
+                dispatcher.mouseGrabManager.endGrab();
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public Window attachNativeWindow(long nativeWindowId) {
+            lockAWT();
+            try {
+                Window window = new EmbeddedWindow(nativeWindowId);
+                windowComponentMap.put(window.getNativeWindow(), window);
+                windows.add(window);
+                return window;
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void makePopup(Window window) {
+            lockAWT();
+            try {
+                window.setPopup(true);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void onDrawImage(Component comp, Image image, Point destLocation,
+                Dimension destSize, Rectangle source) {
+            lockAWT();
+            try {
+                comp.onDrawImage(image, destLocation, destSize, source);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void setCaretPos(Component c, int x, int y) {
+            c.setCaretPos(x, y);
+        }
+
+        @Override
+        public void unsafeInvokeAndWait(Runnable runnable) throws InterruptedException,
+                InvocationTargetException {
+            Toolkit.this.unsafeInvokeAndWait(runnable);
+        }
+
+        @Override
+        public TextKit getTextKit(Component comp) {
+            lockAWT();
+            try {
+                return comp.getTextKit();
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void setTextKit(Component comp, TextKit kit) {
+            lockAWT();
+            try {
+                comp.setTextKit(kit);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public TextFieldKit getTextFieldKit(Component comp) {
+            lockAWT();
+            try {
+                return comp.getTextFieldKit();
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void setTextFieldKit(Component comp, TextFieldKit kit) {
+            lockAWT();
+            try {
+                comp.setTextFieldKit(kit);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public void shutdown() {
+            dispatchThread.shutdown();
+        }
+
+        @Override
+        public void setMouseEventPreprocessor(MouseEventPreprocessor preprocessor) {
+            lockAWT();
+            try {
+                mouseEventPreprocessor = preprocessor;
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public Choice createCustomChoice(ChoiceStyle style) {
+            return new Choice(style);
+        }
+
+        @Override
+        public Insets getNativeInsets(Window w) {
+            lockAWT();
+            try {
+                return (w != null) ? w.getNativeInsets() : new Insets(0, 0, 0, 0);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public MultiRectArea getRepaintRegion(Component c) {
+            return c.repaintRegion;
+        }
+
+        @Override
+        public MultiRectArea subtractPendingRepaintRegion(Component c, MultiRectArea mra) {
+            lockAWT();
+            try {
+                RedrawManager rm = c.getRedrawManager();
+                if (rm == null) {
+                    return null;
+                }
+                return rm.subtractPendingRepaintRegion(c, mra);
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public boolean wasPainted(Window w) {
+            lockAWT();
+            try {
+                return w.painted;
+            } finally {
+                unlockAWT();
+            }
+        }
+
+        @Override
+        public MultiRectArea getObscuredRegion(Component c) {
+            return c.getObscuredRegion(null);
+        }
+
+        @Override
+        public void setDesktopProperty(String name, Object value) {
+            Toolkit.this.setDesktopProperty(name, value);
+        }
+
+        @Override
+        public void runModalLoop(Dialog dlg) {
+            dlg.runModalLoop();
+        }
+
+        @Override
+        public void endModalLoop(Dialog dlg) {
+            dlg.endModalLoop();
+        }
+
+        @Override
+        public void setVisibleFlag(Component comp, boolean visible) {
+            comp.visible = visible;
+        }
+
+        @Override
+        public void addObscuredRegions(MultiRectArea mra, Component c, Container container) {
+            if (container != null) {
+                container.addObscuredRegions(mra, c);
+            }            
+        }
+    }
+
+    /*
+     * A lot of methods must throw HeadlessException
+     * if <code>GraphicsEnvironment.isHeadless()</code> returns <code>true</code>.
+     */
+    static void checkHeadless() throws HeadlessException {
+        if (GraphicsEnvironment.getLocalGraphicsEnvironment().isHeadlessInstance())
+            throw new HeadlessException();
+    }
+
+    final void lockAWT() {
+        synchronizer.lock();
+    }
+
+    static final void staticLockAWT() {
+        ContextStorage.getSynchronizer().lock();
+    }
+
+    final void unlockAWT() {
+        synchronizer.unlock();
+    }
+
+    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
+     */
+    final void unsafeInvokeAndWait(Runnable runnable) throws InterruptedException,
+            InvocationTargetException {
+        synchronizer.storeStateAndFree();
+        try {
+            EventQueue.invokeAndWait(runnable);
+        } finally {
+            synchronizer.lockAndRestoreState();
+        }
+    }
+
+    final Synchronizer getSynchronizer() {
+        return synchronizer;
+    }
+
+    final WTK getWTK() {
+        return wtk;
+    }
+
+    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();
+        }
+    }
+
+    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
+        }
+    }
+
+    Font getDefaultFont() {
+        return wtk.getSystemProperties().getDefaultFont();
+    }
+
+    private static ResourceBundle loadResources(String path) {
+        try {
+            return ResourceBundle.getBundle(path);
+        } catch (MissingResourceException e) {
+            return null;
+        }
+    }
+
+    private static String getWTKClassName() {
+        String osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$
+        String packageBase = "org.apache.harmony.awt.wtk", win = "windows", lin = "linux"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+        if (osName.startsWith(lin)) {
+            return packageBase + "." + lin + ".LinuxWTK"; //$NON-NLS-1$ //$NON-NLS-2$
+        }
+        if (osName.startsWith(win)) {
+            return packageBase + "." + win + ".WinWTK"; //$NON-NLS-1$ //$NON-NLS-2$
+        }
+        return null;
+    }
+
+    Component getComponentById(long id) {
+        if (id == 0) {
+            return null;
+        }
+        return (Component) windowComponentMap.get(getWindowFactory().getWindowById(id));
+    }
+
+    PopupBox getPopupBoxById(long id) {
+        if (id == 0) {
+            return null;
+        }
+        return (PopupBox) windowPopupMap.get(getWindowFactory().getWindowById(id));
+    }
+
+    Window getFocusProxyOwnerById(long id) {
+        if (id == 0) {
+            return null;
+        }
+        return windowFocusProxyMap.get(getWindowFactory().getWindowById(id));
+    }
+
+    WindowFactory getWindowFactory() {
+        return wtk.getWindowFactory();
+    }
+
+    GraphicsFactory getGraphicsFactory() {
+        return wtk.getGraphicsFactory();
+    }
+    
+    public Toolkit() {        
+        init();
+    }
+
+    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();
+            dtk = DTK.getDTK();
+            NativeEventThread.Init init = new NativeEventThread.Init() {
+                public WTK init() {
+                    wtk = createWTK(className);
+                    wtk.getNativeEventQueue().setShutdownWatchdog(shutdownWatchdog);
+                    synchronizer.setEnvironment(wtk, dispatchThread);
+                    ContextStorage.setWTK(wtk);
+                    dtk.initDragAndDrop();
+                    return wtk;
+                }
+            };
+            nativeThread.start(init);
+            dispatchThread.start();
+            wtk.getNativeEventQueue().awake();
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public abstract void sync();
+
+    protected abstract TextAreaPeer createTextArea(TextArea a0) throws HeadlessException;
+
+    public abstract int checkImage(Image a0, int a1, int a2, ImageObserver a3);
+
+    public abstract Image createImage(ImageProducer a0);
+
+    public abstract Image createImage(byte[] a0, int a1, int a2);
+
+    public abstract Image createImage(URL a0);
+
+    public abstract Image createImage(String a0);
+
+    public abstract ColorModel getColorModel() throws HeadlessException;
+
+    /**
+     * @deprecated
+     */
+    @Deprecated
+    public abstract FontMetrics getFontMetrics(Font font);
+
+    public abstract boolean prepareImage(Image a0, int a1, int a2, ImageObserver a3);
+
+    public abstract void beep();
+
+    protected abstract ButtonPeer createButton(Button a0) throws HeadlessException;
+
+    protected abstract CanvasPeer createCanvas(Canvas a0);
+
+    protected abstract CheckboxPeer createCheckbox(Checkbox a0) throws HeadlessException;
+
+    protected abstract CheckboxMenuItemPeer createCheckboxMenuItem(CheckboxMenuItem a0)
+            throws HeadlessException;
+
+    protected abstract ChoicePeer createChoice(Choice a0) throws HeadlessException;
+
+    protected abstract DialogPeer createDialog(Dialog a0) throws HeadlessException;
+
+    public abstract DragSourceContextPeer createDragSourceContextPeer(DragGestureEvent a0)
+            throws InvalidDnDOperationException;
+
+    protected abstract FileDialogPeer createFileDialog(FileDialog a0) throws HeadlessException;
+
+    protected abstract FramePeer createFrame(Frame a0) throws HeadlessException;
+
+    protected abstract LabelPeer createLabel(Label a0) throws HeadlessException;
+
+    protected abstract ListPeer createList(List a0) throws HeadlessException;
+
+    protected abstract MenuPeer createMenu(Menu a0) throws HeadlessException;
+
+    protected abstract MenuBarPeer createMenuBar(MenuBar a0) throws HeadlessException;
+
+    protected abstract MenuItemPeer createMenuItem(MenuItem a0) throws HeadlessException;
+
+    protected abstract PanelPeer createPanel(Panel a0);
+
+    protected abstract PopupMenuPeer createPopupMenu(PopupMenu a0) throws HeadlessException;
+
+    protected abstract ScrollPanePeer createScrollPane(ScrollPane a0) throws HeadlessException;
+
+    protected abstract ScrollbarPeer createScrollbar(Scrollbar a0) throws HeadlessException;
+
+    protected abstract TextFieldPeer createTextField(TextField a0) throws HeadlessException;
+
+    protected abstract WindowPeer createWindow(Window a0) throws HeadlessException;
+
+    /**
+     * @deprecated
+     */
+    @Deprecated
+    public abstract String[] getFontList();
+
+    /**
+     * @deprecated
+     */
+    @Deprecated
+    protected abstract FontPeer getFontPeer(String a0, int a1);
+
+    public abstract Image getImage(String a0);
+
+    public abstract Image getImage(URL a0);
+
+    public abstract PrintJob getPrintJob(Frame a0, String a1, Properties a2);
+
+    public abstract int getScreenResolution() throws HeadlessException;
+
+    public abstract Dimension getScreenSize() throws HeadlessException;
+
+    public abstract Clipboard getSystemClipboard() throws HeadlessException;
+
+    protected abstract EventQueue getSystemEventQueueImpl();
+
+    public abstract Map<java.awt.font.TextAttribute, ?> mapInputMethodHighlight(
+            InputMethodHighlight highlight) throws HeadlessException;
+
+    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);
+    }
+
+    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);
+        }
+    }
+
+    protected java.awt.peer.MouseInfoPeer getMouseInfoPeer() {
+        return new MouseInfoPeer() {
+        };
+    }
+
+    protected LightweightPeer createComponent(Component a0) throws 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 null;
+    }
+
+    public Image createImage(byte[] imagedata) {
+        return createImage(imagedata, 0, imagedata.length);
+    }
+
+    protected static Container getNativeContainer(Component c) {
+        staticLockAWT();
+        try {
+            //TODO: implement
+            return c.getWindowAncestor();
+        } finally {
+            staticUnlockAWT();
+        }
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners() {
+        return desktopPropsSupport.getPropertyChangeListeners();
+    }
+
+    public PropertyChangeListener[] getPropertyChangeListeners(String propName) {
+        return desktopPropsSupport.getPropertyChangeListeners(propName);
+    }
+
+    public void removePropertyChangeListener(String propName, PropertyChangeListener l) {
+        desktopPropsSupport.removePropertyChangeListener(propName, l);
+    }
+
+    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();
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends DragGestureRecognizer> T createDragGestureRecognizer(
+            Class<T> recognizerAbstractClass, DragSource ds, Component c, int srcActions,
+            DragGestureListener dgl) {
+        if (recognizerAbstractClass == null) {
+            return null;
+        }
+        if (recognizerAbstractClass.isAssignableFrom(MouseDragGestureRecognizer.class)) {
+            return (T) new DefaultMouseDragGestureRecognizer(ds, c, srcActions, dgl);
+        }
+        return null;
+    }
+
+    public Dimension getBestCursorSize(int prefWidth, int prefHeight) throws HeadlessException {
+        lockAWT();
+        try {
+            return wtk.getCursorFactory().getBestCursorSize(prefWidth, prefHeight);
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    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();
+        }
+    }
+
+    public boolean getLockingKeyState(int a0) throws UnsupportedOperationException, org.apache.harmony.luni.util.NotImplementedException {
+        lockAWT();
+        try {
+            return false;
+        } finally {
+            unlockAWT();
+        }
+//        if (true) {
+//            throw new RuntimeException("Method is not implemented"); //TODO: implement //$NON-NLS-1$
+//        }
+//        return true;
+    }
+
+    public int getMaximumCursorColors() throws HeadlessException {
+        lockAWT();
+        try {
+            return wtk.getCursorFactory().getMaximumCursorColors();
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public int getMenuShortcutKeyMask() throws HeadlessException {
+        lockAWT();
+        try {
+            return InputEvent.CTRL_MASK;
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public PrintJob getPrintJob(Frame a0, String a1, JobAttributes a2, PageAttributes a3) throws 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 null;
+    }
+
+    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();
+        }
+    }
+
+    public final EventQueue getSystemEventQueue() {
+        SecurityManager sm = System.getSecurityManager();
+        if (sm != null) {
+            sm.checkAwtEventQueueAccess();
+        }
+        return getSystemEventQueueImpl();
+    }
+
+    EventQueueCore getSystemEventQueueCore() {
+        return systemEventQueueCore;
+    }
+
+    void setSystemEventQueueCore(EventQueueCore core) {
+        systemEventQueueCore = core;
+    }
+
+    public Clipboard getSystemSelection() throws HeadlessException {
+        lockAWT();
+        try {
+            SecurityManager security = System.getSecurityManager();
+            if (security != null) {
+                security.checkSystemClipboardAccess();
+            }
+            if (systemSelection == null) {
+                systemSelection = dtk.getNativeSelection();
+            }
+            return systemSelection;
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    protected void initializeDesktopProperties() {
+        lockAWT();
+        try {
+            wtk.getSystemProperties().init(desktopProperties);
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public boolean isDynamicLayoutActive() throws HeadlessException {
+        lockAWT();
+        try {
+            // always return true
+            return true;
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    protected boolean isDynamicLayoutSet() throws HeadlessException {
+        lockAWT();
+        try {
+            return bDynamicLayoutSet;
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public boolean isFrameStateSupported(int state) throws HeadlessException {
+        lockAWT();
+        try {
+            return wtk.getWindowFactory().isWindowStateSupported(state);
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    protected Object lazilyLoadDesktopProperty(String propName) {
+        return null;
+    }
+
+    protected void loadSystemColors(int[] colors) throws HeadlessException {
+        lockAWT();
+        try {
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    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);
+    }
+
+    public void setDynamicLayout(boolean dynamic) throws HeadlessException {
+        lockAWT();
+        try {
+            bDynamicLayoutSet = dynamic;
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    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;
+    }
+
+    void onQueueEmpty() {
+        if (windows.isEmpty()) {
+            if (systemClipboard != null) {
+                systemClipboard.onShutdown();
+            }
+            if (systemSelection != null) {
+                systemSelection.onShutdown();
+            }
+            shutdownWatchdog.setWindowListEmpty(true);
+        } else {
+            for (Iterator<?> i = windows.iterator(); i.hasNext();) {
+                ((Window) i.next()).redrawAll();
+            }
+        }
+    }
+
+    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
+     * This method is called after the synchronous window creation,
+     * and also in the window creation callback if it exists (WM_CREATE on Windows)
+     * Calling this method twice is OK because in second time it just does nothing.
+     *
+     * This is done this way because on Windows the native window gets a series of native
+     * events before windowFactory.CreateWindow() returns, and the WinWindow object should be created
+     * to process them. The WM_CREATE message is guaranteed to be first in the series, so that the
+     * the WM_CREATE handler creates the WinWindow object and calls nativeWindowCreated()
+     * for it.
+     *
+     * @param win - native window just created
+     */
+    void nativeWindowCreated(NativeWindow win) {
+        if (recentNativeWindowComponent == null) {
+            return;
+        }
+        if (recentNativeWindowComponent instanceof Component) {
+            windowComponentMap.put(win, recentNativeWindowComponent);
+            ((Component) recentNativeWindowComponent).nativeWindowCreated(win);
+        } else if (recentNativeWindowComponent instanceof PopupBox) {
+            windowPopupMap.put(win, recentNativeWindowComponent);
+        }
+        recentNativeWindowComponent = null;
+    }
+
+    /**
+     * Connect the component to its native window
+     * @param winId - id of native window just created
+     */
+    boolean onWindowCreated(long winId) {
+        nativeWindowCreated(getWindowFactory().getWindowById(winId));
+        return false;
+    }
+
+    NativeWindow createEmbeddedNativeWindow(EmbeddedWindow ew) {
+        windows.add(ew);
+        CreationParams cp = new CreationParams();
+        cp.child = true;
+        cp.disabled = false;
+        cp.name = "EmbeddedWindow"; //$NON-NLS-1$
+        cp.parentId = ew.nativeWindowId;
+        cp.x = 0;
+        cp.y = 0;
+        Dimension size = getWindowFactory().getWindowSizeById(ew.nativeWindowId);
+        cp.w = size.width;
+        cp.h = size.height;
+        recentNativeWindowComponent = ew;
+        NativeWindow win = getWindowFactory().createWindow(cp);
+        nativeWindowCreated(win);
+        shutdownWatchdog.setWindowListEmpty(false);
+        return win;
+    }
+
+    NativeWindow createNativeWindow(Component c) {
+        if (c instanceof Window) {
+            windows.add(c);
+        }
+        Component parent = null;
+        Point location = c.getLocation();
+        CreationParams cp = new CreationParams();
+        cp.child = !(c instanceof Window);
+        cp.disabled = !c.isEnabled();
+        if (c instanceof Window) {
+            Window w = (Window) c;
+            cp.resizable = w.isResizable();
+            cp.undecorated = w.isUndecorated();
+            parent = w.getOwner();
+            cp.locationByPlatform = w.locationByPlatform;
+            if (c instanceof Frame) {
+                Frame frame = (Frame) c;
+                int state = frame.getExtendedState();
+                cp.name = frame.getTitle();
+                cp.iconified = (state & Frame.ICONIFIED) != 0;
+                cp.maximizedState = 0;
+                if ((state & Frame.MAXIMIZED_BOTH) != 0) {
+                    cp.maximizedState |= cp.MAXIMIZED;
+                }
+                if ((state & Frame.MAXIMIZED_HORIZ) != 0) {
+                    cp.maximizedState |= cp.MAXIMIZED_HORIZ;
+                }
+                if ((state & Frame.MAXIMIZED_VERT) != 0) {
+                    cp.maximizedState |= cp.MAXIMIZED_VERT;
+                }
+                cp.decorType = CreationParams.DECOR_TYPE_FRAME;
+            } else if (c instanceof Dialog) {
+                Dialog dlg = (Dialog) c;
+                cp.name = dlg.getTitle();
+                cp.decorType = CreationParams.DECOR_TYPE_DIALOG;
+            } else if (w.isPopup()) {
+                cp.decorType = CreationParams.DECOR_TYPE_POPUP;
+            } else {
+                cp.decorType = CreationParams.DECOR_TYPE_UNDECOR;
+            }
+        } else {
+            parent = c.getHWAncestor();
+            cp.name = c.getName();
+            //set location relative to the nearest heavy weight ancestor
+            location = MouseDispatcher.convertPoint(c, 0, 0, parent);
+        }
+        if (parent != null) {
+            NativeWindow nativeParent = parent.getNativeWindow();
+            if (nativeParent == null) {
+                if (cp.child) {
+                    return null; //component's window will be created when its parent is created ???
+                }
+                parent.mapToDisplay(true); //TODO: verify it
+                nativeParent = parent.getNativeWindow();
+            }
+            cp.parentId = nativeParent.getId();
+        }
+        cp.x = location.x;
+        cp.y = location.y;
+        cp.w = c.getWidth();
+        cp.h = c.getHeight();
+        recentNativeWindowComponent = c;
+        NativeWindow win = getWindowFactory().createWindow(cp);
+        nativeWindowCreated(win);
+        if (c instanceof Window) {
+            shutdownWatchdog.setWindowListEmpty(false);
+        }
+        return win;
+    }
+
+    void removeNativeWindow(NativeWindow w) {
+        Component comp = (Component) windowComponentMap.get(w);
+        if ((comp != null) && (comp instanceof Window)) {
+            windows.remove(comp);
+        }
+        windowComponentMap.remove(w);
+    }
+
+    NativeWindow createPopupNativeWindow(PopupBox popup) {
+        CreationParams cp = new CreationParams();
+        cp.child = popup.isMenuBar();
+        cp.disabled = false;
+        cp.resizable = false;
+        cp.undecorated = true;
+        cp.iconified = false;
+        cp.visible = false;
+        cp.maximizedState = 0;
+        cp.decorType = CreationParams.DECOR_TYPE_POPUP;
+        NativeWindow nativeParent;
+        if (popup.getParent() != null) {
+            nativeParent = popup.getParent().getNativeWindow();
+        } else {
+            nativeParent = popup.getOwner().getNativeWindow();
+        }
+        assert nativeParent != null;
+        cp.parentId = nativeParent.getId();
+        cp.x = popup.getLocation().x;
+        cp.y = popup.getLocation().y;
+        cp.w = popup.getSize().width;
+        cp.h = popup.getSize().height;
+        recentNativeWindowComponent = popup;
+        NativeWindow win = getWindowFactory().createWindow(cp);
+        nativeWindowCreated(win);
+        return win;
+    }
+
+    void removePopupNativeWindow(NativeWindow w) {
+        windowPopupMap.remove(w);
+    }
+
+    NativeWindow createFocusProxyNativeWindow(Window owner) {
+        CreationParams cp = new CreationParams();
+        cp.child = true;
+        cp.disabled = false;
+        cp.resizable = false;
+        cp.undecorated = true;
+        cp.iconified = false;
+        cp.visible = true;
+        cp.maximizedState = 0;
+        cp.decorType = CreationParams.DECOR_TYPE_NONE;
+        cp.parentId = owner.getNativeWindow().getId();
+        cp.x = -10;
+        cp.y = -10;
+        cp.w = 1;
+        cp.h = 1;
+        NativeWindow win = getWindowFactory().createWindow(cp);
+        windowFocusProxyMap.put(win, owner);
+        return win;
+    }
+
+    void removeFocusProxyNativeWindow(NativeWindow w) {
+        windowFocusProxyMap.remove(w);
+    }
+
+    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 type - Java Cursor type
+     * @return new instance of implementation of NativeCursor
+     */
+    NativeCursor createCustomNativeCursor(Image img, Point hotSpot, String name) {
+        return wtk.getCursorFactory().createCustomCursor(img, hotSpot.x, hotSpot.y);
+    }
+
+    /**
+     * Returns implementation of org.apache.harmony.awt.wtk.NativeMouseInfo
+     * for current platform.
+     * @return implementation of NativeMouseInfo
+     */
+    NativeMouseInfo getNativeMouseInfo() {
+        return wtk.getNativeMouseInfo();
+    }
+
+    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();
+        }
+    }
+
+    public void removeAWTEventListener(AWTEventListener listener) {
+        lockAWT();
+        try {
+            SecurityManager security = System.getSecurityManager();
+            if (security != null) {
+                security.checkPermission(awtEventsManager.permission);
+            }
+            awtEventsManager.removeAWTEventListener(listener);
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public AWTEventListener[] getAWTEventListeners() {
+        lockAWT();
+        try {
+            SecurityManager security = System.getSecurityManager();
+            if (security != null) {
+                security.checkPermission(awtEventsManager.permission);
+            }
+            return awtEventsManager.getAWTEventListeners();
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    public AWTEventListener[] getAWTEventListeners(long eventMask) {
+        lockAWT();
+        try {
+            SecurityManager security = System.getSecurityManager();
+            if (security != null) {
+                security.checkPermission(awtEventsManager.permission);
+            }
+            return awtEventsManager.getAWTEventListeners(eventMask);
+        } finally {
+            unlockAWT();
+        }
+    }
+
+    void dispatchAWTEvent(AWTEvent event) {
+        awtEventsManager.dispatchAWTEvent(event);
+    }
+
+    private static Theme createTheme() {
+        String osName = System.getProperty("os.name").toLowerCase(); //$NON-NLS-1$
+        String packageBase = "org.apache.harmony.awt.theme", win = "windows", lin = "linux"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+        PrivilegedAction<String> action = new PrivilegedAction<String>() {
+            public String run() {
+                return System.getProperty("awt.theme"); //$NON-NLS-1$
+            }
+        };
+        String className = AccessController.doPrivileged(action);
+        if (className == null) {
+            if (osName.startsWith(lin)) {
+                className = packageBase + "." + lin + ".LinuxTheme"; //$NON-NLS-1$ //$NON-NLS-2$
+            } else if (osName.startsWith(win)) {
+                className = packageBase + "." + win + ".WinTheme"; //$NON-NLS-1$ //$NON-NLS-2$
+            }
+        }
+        if (className != null) {
+            try {
+                return (Theme) Class.forName(className).newInstance();
+            } catch (Exception e) {
+            }
+        }
+        return new Theme();
+    }
+
+    final class AWTEventsManager {
+        AWTPermission permission = new AWTPermission("listenToAllAWTEvents"); //$NON-NLS-1$
+
+        private final AWTListenerList<AWTEventListenerProxy> listeners = new AWTListenerList<AWTEventListenerProxy>();
+
+        void addAWTEventListener(AWTEventListener listener, long eventMask) {
+            if (listener != null) {
+                listeners.addUserListener(new AWTEventListenerProxy(eventMask, listener));
+            }
+        }
+
+        void removeAWTEventListener(AWTEventListener listener) {
+            if (listener != null) {
+                for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+                    if (listener == proxy.getListener()) {
+                        listeners.removeUserListener(proxy);
+                        return;
+                    }
+                }
+            }
+        }
+
+        AWTEventListener[] getAWTEventListeners() {
+            HashSet<EventListener> listenersSet = new HashSet<EventListener>();
+            for (AWTEventListenerProxy proxy : listeners.getUserListeners()) {
+                listenersSet.add(proxy.getListener());
+            }
+            return listenersSet.toArray(new AWTEventListener[listenersSet.size()]);
+        }
+
+        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()]);
+        }
+
+        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);
+                }
+            }
+        }
+    }
+
+    static final class AutoNumber {
+        int nextComponent = 0;
+
+        int nextCanvas = 0;
+
+        int nextPanel = 0;
+
+        int nextWindow = 0;
+
+        int nextFrame = 0;
+
+        int nextDialog = 0;
+
+        int nextButton = 0;
+
+        int nextMenuComponent = 0;
+
+        int nextLabel = 0;
+
+        int nextCheckBox = 0;
+
+        int nextScrollbar = 0;
+
+        int nextScrollPane = 0;
+
+        int nextList = 0;
+
+        int nextChoice = 0;
+
+        int nextFileDialog = 0;
+
+        int nextTextArea = 0;
+
+        int nextTextField = 0;
+    }
+
+    /**
+     * Thread-safe collection of Window objects
+     */
+    static final class WindowList {
+        /**
+         * If a non-dispatch thread adds/removes a window,
+         * this set it is replaced to avoid the possible conflict
+         * with concurrently running lock-free iterator loop
+         */
+        private LinkedHashSet<Component> windows = new LinkedHashSet<Component>();
+
+        private class Lock {
+        }
+
+        private final Object lock = new Lock();
+
+        @SuppressWarnings("unchecked")
+        void add(Component w) {
+            synchronized (lock) {
+                if (isDispatchThread()) {
+                    windows.add(w);
+                } else {
+                    windows = (LinkedHashSet<Component>) windows.clone();
+                    windows.add(w);
+                }
+            }
+        }
+
+        @SuppressWarnings("unchecked")
+        void remove(Component w) {
+            synchronized (lock) {
+                if (isDispatchThread()) {
+                    windows.remove(w);
+                } else {
+                    windows = (LinkedHashSet<Component>) windows.clone();
+                    windows.remove(w);
+                }
+            }
+        }
+
+        Iterator<Component> iterator() {
+            synchronized (lock) {
+                return new ReadOnlyIterator<Component>(windows.iterator());
+            }
+        }
+
+        boolean isEmpty() {
+            synchronized (lock) {
+                return windows.isEmpty();
+            }
+        }
+
+        private boolean isDispatchThread() {
+            return Thread.currentThread() instanceof EventDispatchThread;
+        }
+    }
+}

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/harmony/java/awt/Toolkit.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/patch.txt
URL: http://svn.apache.org/viewvc/harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/patch.txt?view=auto&rev=550346
==============================================================================
--- harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/patch.txt (added)
+++ harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/patch.txt Sun Jun 24 21:50:20 2007
@@ -0,0 +1,209 @@
+Index: C:/mol/wrk/ws/abbot.plain/test/abbot/util/NamedTimerTest.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/test/abbot/util/NamedTimerTest.java   (revision 2056)
++++ C:/mol/wrk/ws/abbot.plain/test/abbot/util/NamedTimerTest.java   (working copy)
+@@ -21,7 +21,7 @@
+     public void testSetName() throws Exception {
+         class Flag { volatile String name; }
+         final Flag flag = new Flag();
+-        timer.schedule(new TimerTask() {
++        timer.schedule(new ExtendedTimerTask() {
+             public void run() {
+                 flag.name = Thread.currentThread().getName();
+             }
+@@ -39,7 +39,7 @@
+     public void testExceptionThrowingTimerTask() throws Exception {
+         class Flag { volatile boolean taskRan; }
+         final Flag flag = new Flag();
+-        TimerTask task = new TimerTask() {
++        TimerTask task = new ExtendedTimerTask() {
+             public void run() {
+                 try {
+                     throw new RuntimeException("Purposely throwing");
+@@ -57,13 +57,13 @@
+             Thread.yield();
+         }
+         // This will throw an exception if the Timer was canceled
+-        timer.schedule(new TimerTask() { public void run() { }}, 0);
++        timer.schedule(new ExtendedTimerTask() { public void run() { }}, 0);
+     }
+ 
+     public void testCancelTask() throws Exception {
+         class Flag { volatile boolean taskRan; }
+         final Flag flag = new Flag();
+-        TimerTask task = new TimerTask() {
++        TimerTask task = new ExtendedTimerTask() {
+             public void run() {
+                 flag.taskRan = true;
+             }
+Index: C:/mol/wrk/ws/abbot.plain/src/abbot/tester/WindowTracker.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/src/abbot/tester/WindowTracker.java   (revision 2056)
++++ C:/mol/wrk/ws/abbot.plain/src/abbot/tester/WindowTracker.java   (working copy)
+@@ -8,6 +8,7 @@
+ 
+ import abbot.Log;
+ import abbot.util.AWT;
++import abbot.util.ExtendedTimerTask;
+ import abbot.util.Properties;
+ import abbot.util.WeakAWTEventListener;
+ import abbot.util.NamedTimer;
+@@ -369,7 +370,7 @@
+         synchronized(openWindows) {
+             // At worst, time out and say the window is ready
+             // after the configurable delay
+-            TimerTask task = new TimerTask() {
++            TimerTask task = new ExtendedTimerTask() {
+                 public void run() {
+                     markWindowReady(w);
+                 }
+Index: C:/mol/wrk/ws/abbot.plain/src/abbot/util/PathClassLoader.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/src/abbot/util/PathClassLoader.java   (revision 2056)
++++ C:/mol/wrk/ws/abbot.plain/src/abbot/util/PathClassLoader.java   (working copy)
+@@ -99,7 +99,11 @@
+ 
+     /** Taken from sun.misc.Launcher. */
+     private static class Factory implements URLStreamHandlerFactory {
+-        private static final String PREFIX = "sun.net.www.protocol";
++        private static final String PREFIX;
++        static {
++            PREFIX=System.getProperty("abbot.util.url_stream_handler_prefix",
++                    "sun.net.www.protocol");
++        }
+         private Factory() { }
+         public URLStreamHandler createURLStreamHandler(String protocol) {
+             String name = PREFIX + "." + protocol + ".Handler";
+Index: C:/mol/wrk/ws/abbot.plain/src/abbot/util/EventDispatchExceptionHandler.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/src/abbot/util/EventDispatchExceptionHandler.java (revision 2056)
++++ C:/mol/wrk/ws/abbot.plain/src/abbot/util/EventDispatchExceptionHandler.java (working copy)
+@@ -53,6 +53,12 @@
+             throw new IllegalStateException("Handler must not be installed from the event dispatch thread");
+         }
+ 
++        // Check if we don't want this hack
++        if (Boolean.getBoolean("abbot.util.do_not_install_handler")) {
++            Log.log("Skipped own handler for event dispatch exceptions installation");
++            return;
++        }
++
+         Class cls = getClass();
+         final String className = cls.getName();
+         try {
+Index: C:/mol/wrk/ws/abbot.plain/src/abbot/util/ExtendedTimerTask.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/src/abbot/util/ExtendedTimerTask.java (revision 0)
++++ C:/mol/wrk/ws/abbot.plain/src/abbot/util/ExtendedTimerTask.java (revision 0)
+@@ -0,0 +1,46 @@
++package abbot.util;
++
++import java.util.TimerTask;
++
++/**
++ * <code>ExtendedTimerTask</code> instances may be checked on cancellation state.
++ * This class must be a base for all timer tasks scheduled in <code>abbot.util.NamedTimer</code>
++ * @see abbot.util.NamedTimer
++ */
++public abstract class ExtendedTimerTask extends TimerTask {
++    /**
++     * 'false' initially, 'true' after cancel() invocation
++     */
++    private boolean cancelled;
++
++    /**
++     * Creates a new extended timer task
++     */
++    protected ExtendedTimerTask() {
++        super();
++    }
++
++    /**
++     * @see java.util.TimerTask#run()
++     */
++    public abstract void run();
++
++    /**
++     * @see java.util.TimerTask#cancel()
++     */
++    public boolean cancel() {
++        cancelled = true;
++        return super.cancel();
++    }
++
++    /**
++     * Returns this timer task's cancellation state
++     * 
++     * @return
++     *  <code>true</code> if this timer task has been cancelled
++     *  <code>false</code> otherwise 
++     */
++    public boolean isCancelled() {
++        return cancelled;
++    }
++}
+Index: C:/mol/wrk/ws/abbot.plain/src/abbot/util/NamedTimer.java
+===================================================================
+--- C:/mol/wrk/ws/abbot.plain/src/abbot/util/NamedTimer.java    (revision 2056)
++++ C:/mol/wrk/ws/abbot.plain/src/abbot/util/NamedTimer.java    (working copy)
+@@ -1,7 +1,6 @@
+ package abbot.util;
+ 
+ import java.util.Timer;
+-import java.lang.reflect.Field;
+ import java.util.TimerTask;
+ import java.util.Date;
+ import abbot.Log;
+@@ -21,7 +20,7 @@
+     /** Creates a named timer, optionally running as a daemon thread. */
+     public NamedTimer(final String name, boolean isDaemon) {
+         super(isDaemon);
+-        schedule(new TimerTask() {
++        schedule(new ExtendedTimerTask() {
+             public void run() {
+                 Thread.currentThread().setName(name);
+             }
+@@ -40,12 +39,17 @@
+     // cancel the wrapper when 
+ 
+     private class ProtectingTimerTask extends TimerTask {
+-        private TimerTask task;
++        private ExtendedTimerTask task;
++        /* <code>ProtectingTimerTask</code> ctor
++         * @param <code>orig</code> Timer task object to be wrapped
++         * @throws <code>java.lang.ClassCastException</code> if
++         * <code>orig</code> is not <code>ExtendedTimerTask</code> instance 
++         */
+         public ProtectingTimerTask(TimerTask orig) {
+-            this.task = orig;
++            this.task = (ExtendedTimerTask)orig;
+         }
+         public void run() {
+-            if (isCanceled()) {
++            if (task.isCancelled()) {
+                 cancel();
+             }
+             else {
+@@ -53,20 +57,6 @@
+                 catch(Throwable thrown) { handleException(thrown); }
+             }
+         }
+-        private boolean isCanceled() {
+-            boolean canceled = false;
+-            final int CANCELED = 3;
+-            try {
+-                Field f = TimerTask.class.getDeclaredField("state");
+-                f.setAccessible(true);
+-                int state = ((Integer)f.get(task)).intValue();
+-                canceled = state == CANCELED;
+-            }
+-            catch(Exception e) {
+-                Log.warn(e);
+-            }
+-            return canceled;
+-        }
+     }
+ 
+     public void schedule(TimerTask task, Date time) {
+
+ 	  	 

Propchange: harmony/enhanced/buildtest/branches/2.0/tests/jedit_test/src/patches/patch.txt
------------------------------------------------------------------------------
    svn:eol-style = native



Mime
View raw message