/*

 * Copyright 1997-2008 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package sun.awt;

import java.awt.*;

import static java.awt.RenderingHints.*;

import java.awt.dnd.*;

import java.awt.dnd.peer.DragSourceContextPeer;

import java.awt.peer.*;

import java.awt.event.WindowEvent;

import java.awt.event.KeyEvent;

import java.awt.im.spi.InputMethodDescriptor;

import java.awt.image.*;

import java.awt.geom.AffineTransform;

import java.awt.TrayIcon;

import java.awt.SystemTray;

import java.io.*;

import java.net.URL;

import java.net.JarURLConnection;

import java.util.*;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

import java.util.logging.Level;

import java.util.logging.Logger;

import sun.misc.SoftCache;

import sun.font.FontDesignMetrics;

import sun.awt.im.InputContext;

import sun.awt.im.SimpleInputMethodWindow;

import sun.awt.image.*;

import sun.security.action.GetPropertyAction;

import sun.security.action.GetBooleanAction;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationTargetException;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.security.PrivilegedActionException;

import java.security.PrivilegedExceptionAction;

public abstract class SunToolkit extends Toolkit

    implements WindowClosingSupport, WindowClosingListener,

    ComponentFactory, InputMethodSupport, KeyboardFocusManagerPeerProvider {

    private static final Logger log = Logger.getLogger("sun.awt.SunToolkit");

    /* Load debug settings for native code */

    static {

        if (AccessController.doPrivileged(new GetBooleanAction("sun.awt.nativedebug"))) {

            DebugSettings.init();

        }

    };

    /**

     * Special mask for the UngrabEvent events, in addition to the

     * public masks defined in AWTEvent.  Should be used as the mask

     * value for Toolkit.addAWTEventListener.

     */

    public static final int GRAB_EVENT_MASK = 0x80000000;

    private static Field syncLWRequestsField;

    private static Method  wakeupMethod;

    private static Field componentKeyField;

    private static Field menuComponentKeyField;

    private static Field trayIconKeyField;

    private static Field componentAppContextField;

    private static Field menuComponentAppContextField;

    private static Field isPostedField;

    /* The key to put()/get() the PostEventQueue into/from the AppContext.

     */

    private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";

    public SunToolkit() {

        /* If awt.threadgroup is set to class name the instance of

         * this class is created (should be subclass of ThreadGroup)

         * and EventDispatchThread is created inside of it

         *

         * If loaded class overrides uncaughtException instance

         * handles all uncaught exception on EventDispatchThread

         */

        ThreadGroup threadGroup = null;

        String tgName = System.getProperty("awt.threadgroup", "");

        if (tgName.length() != 0) {

            try {

                Constructor ctor = Class.forName(tgName).

                    getConstructor(new Class[] {String.class});

                threadGroup = (ThreadGroup)ctor.newInstance(new Object[] {"AWT-ThreadGroup"});

            } catch (Exception e) {

                System.err.println("Failed loading " + tgName + ": " + e);

            }

        }

        Runnable initEQ = new Runnable() {

            public void run () {

                EventQueue eventQueue;

                String eqName = System.getProperty("AWT.EventQueueClass",

                                                   "java.awt.EventQueue");

                try {

                    eventQueue = (EventQueue)Class.forName(eqName).newInstance();

                } catch (Exception e) {

                    e.printStackTrace();

                    System.err.println("Failed loading " + eqName + ": " + e);

                    eventQueue = new EventQueue();

                }

                AppContext appContext = AppContext.getAppContext();

                appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);

                PostEventQueue postEventQueue = new PostEventQueue(eventQueue);

                appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);

            }

        };

        if (threadGroup != null) {

            Thread eqInitThread = new Thread(threadGroup, initEQ, "EventQueue-Init");

            eqInitThread.start();

            try {

                eqInitThread.join();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        } else {

            initEQ.run();

        }

    }

    public boolean useBufferPerWindow() {

        return false;

    }

    public abstract WindowPeer createWindow(Window target)

        throws HeadlessException;

    public abstract FramePeer createFrame(Frame target)

        throws HeadlessException;

    public abstract DialogPeer createDialog(Dialog target)

        throws HeadlessException;

    public abstract ButtonPeer createButton(Button target)

        throws HeadlessException;

    public abstract TextFieldPeer createTextField(TextField target)

        throws HeadlessException;

    public abstract ChoicePeer createChoice(Choice target)

        throws HeadlessException;

    public abstract LabelPeer createLabel(Label target)

        throws HeadlessException;

    public abstract ListPeer createList(java.awt.List target)

        throws HeadlessException;

    public abstract CheckboxPeer createCheckbox(Checkbox target)

        throws HeadlessException;

    public abstract ScrollbarPeer createScrollbar(Scrollbar target)

        throws HeadlessException;

    public abstract ScrollPanePeer createScrollPane(ScrollPane target)

        throws HeadlessException;

    public abstract TextAreaPeer createTextArea(TextArea target)

        throws HeadlessException;

    public abstract FileDialogPeer createFileDialog(FileDialog target)

        throws HeadlessException;

    public abstract MenuBarPeer createMenuBar(MenuBar target)

        throws HeadlessException;

    public abstract MenuPeer createMenu(Menu target)

        throws HeadlessException;

    public abstract PopupMenuPeer createPopupMenu(PopupMenu target)

        throws HeadlessException;

    public abstract MenuItemPeer createMenuItem(MenuItem target)

        throws HeadlessException;

    public abstract CheckboxMenuItemPeer createCheckboxMenuItem(

        CheckboxMenuItem target)

        throws HeadlessException;

    public abstract DragSourceContextPeer createDragSourceContextPeer(

        DragGestureEvent dge)

        throws InvalidDnDOperationException;

    public abstract TrayIconPeer createTrayIcon(TrayIcon target)

        throws HeadlessException, AWTException;

    public abstract SystemTrayPeer createSystemTray(SystemTray target);

    public abstract boolean isTraySupported();

    public abstract FontPeer getFontPeer(String name, int style);

    public abstract RobotPeer createRobot(Robot target, GraphicsDevice screen)

        throws AWTException;

    public KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager) throws HeadlessException {

        KeyboardFocusManagerPeerImpl peer = new KeyboardFocusManagerPeerImpl(manager);

        return peer;

    }

    /**

     * The AWT lock is typically only used on Unix platforms to synchronize

     * access to Xlib, OpenGL, etc.  However, these methods are implemented

     * in SunToolkit so that they can be called from shared code (e.g.

     * from the OGL pipeline) or from the X11 pipeline regardless of whether

     * XToolkit or MToolkit is currently in use.  There are native macros

     * (such as AWT_LOCK) defined in awt.h, so if the implementation of these

     * methods is changed, make sure it is compatible with the native macros.

     *

     * Note: The following methods (awtLock(), awtUnlock(), etc) should be

     * used in place of:

     *     synchronized (getAWTLock()) {

     *         ...

     *     }

     *

     * By factoring these methods out specially, we are able to change the

     * implementation of these methods (e.g. use more advanced locking

     * mechanisms) without impacting calling code.

     *

     * Sample usage:

     *     private void doStuffWithXlib() {

     *         assert !SunToolkit.isAWTLockHeldByCurrentThread();

     *         SunToolkit.awtLock();

     *         try {

     *             ...

     *             XlibWrapper.XDoStuff();

     *         } finally {

     *             SunToolkit.awtUnlock();

     *         }

     *     }

     */

    private static final ReentrantLock AWT_LOCK = new ReentrantLock();

    private static final Condition AWT_LOCK_COND = AWT_LOCK.newCondition();

    public static final void awtLock() {

        AWT_LOCK.lock();

    }

    public static final boolean awtTryLock() {

        return AWT_LOCK.tryLock();

    }

    public static final void awtUnlock() {

        AWT_LOCK.unlock();

    }

    public static final void awtLockWait()

        throws InterruptedException

    {

        AWT_LOCK_COND.await();

    }

    public static final void awtLockWait(long timeout)

        throws InterruptedException

    {

        AWT_LOCK_COND.await(timeout, TimeUnit.MILLISECONDS);

    }

    public static final void awtLockNotify() {

        AWT_LOCK_COND.signal();

    }

    public static final void awtLockNotifyAll() {

        AWT_LOCK_COND.signalAll();

    }

    public static final boolean isAWTLockHeldByCurrentThread() {

        return AWT_LOCK.isHeldByCurrentThread();

    }

    /*

     * Create a new AppContext, along with its EventQueue, for a

     * new ThreadGroup.  Browser code, for example, would use this

     * method to create an AppContext & EventQueue for an Applet.

     */

    public static AppContext createNewAppContext() {

        ThreadGroup threadGroup = Thread.currentThread().getThreadGroup();

        EventQueue eventQueue;

        String eqName = System.getProperty("AWT.EventQueueClass",

                                           "java.awt.EventQueue");

        try {

            eventQueue = (EventQueue)Class.forName(eqName).newInstance();

        } catch (Exception e) {

            System.err.println("Failed loading " + eqName + ": " + e);

            eventQueue = new EventQueue();

        }

        AppContext appContext = new AppContext(threadGroup);

        appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);

        PostEventQueue postEventQueue = new PostEventQueue(eventQueue);

        appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);

        return appContext;

    }

    public static Field getField(final Class klass, final String fieldName) {

        return AccessController.doPrivileged(new PrivilegedAction<Field>() {

            public Field run() {

                try {

                    Field field = klass.getDeclaredField(fieldName);

                    assert (field != null);

                    field.setAccessible(true);

                    return field;

                } catch (SecurityException e) {

                    assert false;

                } catch (NoSuchFieldException e) {

                    assert false;

                }

                return null;

            }//run

        });

    }

    static void wakeupEventQueue(EventQueue q, boolean isShutdown){

        if (wakeupMethod == null){

            wakeupMethod = (Method)AccessController.doPrivileged(new PrivilegedAction(){

                    public Object run(){

                        try {

                            Method method  = EventQueue.class.getDeclaredMethod("wakeup",new Class [] {Boolean.TYPE} );

                            if (method != null) {

                                method.setAccessible(true);

                            }

                            return method;

                        } catch (NoSuchMethodException e) {

                            assert false;

                        } catch (SecurityException e) {

                            assert false;

                        }

                        return null;

                    }//run

                });

        }

        try{

            if (wakeupMethod != null){

                wakeupMethod.invoke(q, new Object[]{Boolean.valueOf(isShutdown)});

            }

        } catch (InvocationTargetException e){

            assert false;

        } catch (IllegalAccessException e) {

            assert false;

        }

    }

    /*

     * Fetch the peer associated with the given target (as specified

     * in the peer creation method).  This can be used to determine

     * things like what the parent peer is.  If the target is null

     * or the target can't be found (either because the a peer was

     * never created for it or the peer was disposed), a null will

     * be returned.

     */

    protected static Object targetToPeer(Object target) {

        if (target != null && !GraphicsEnvironment.isHeadless()) {

            return AWTAutoShutdown.getInstance().getPeer(target);

        }

        return null;

    }

    protected static void targetCreatedPeer(Object target, Object peer) {

        if (target != null && peer != null &&

            !GraphicsEnvironment.isHeadless())

        {

            AWTAutoShutdown.getInstance().registerPeer(target, peer);

        }

    }

    protected static void targetDisposedPeer(Object target, Object peer) {

        if (target != null && peer != null &&

            !GraphicsEnvironment.isHeadless())

        {

            AWTAutoShutdown.getInstance().unregisterPeer(target, peer);

        }

    }

    // Maps from non-Component/MenuComponent to AppContext.

    // WeakHashMap<Component,AppContext>

    private static final Map appContextMap =

        Collections.synchronizedMap(new WeakHashMap());

    /**

     * Sets the appContext field of target. If target is not a Component or

     * MenuComponent, this returns false.

     */

    private static boolean setAppContext(Object target, AppContext context)

    {

        if (!(target instanceof Component) && !(target instanceof MenuComponent)) {

            return false;

        }

        try{

            if (target instanceof Component){

                if (componentAppContextField == null) {

                    componentAppContextField = getField(Component.class, "appContext");

                }

                componentAppContextField.set(target, context);

            } else if (target instanceof MenuComponent) {

                if (menuComponentAppContextField == null) {

                    menuComponentAppContextField = getField(MenuComponent.class, "appContext");

                }

                menuComponentAppContextField.set(target, context);

            }

        } catch( IllegalAccessException e){

            assert false;

        }

        return true;

    }

    /**

     * Returns the appContext field for target. If target is not a

     * Component or MenuComponent this returns null.

     */

    private static AppContext getAppContext(Object target) {

        AppContext retObj = null;

        try{

            if (target instanceof Component){

                if (componentAppContextField == null) {

                    componentAppContextField = getField(Component.class, "appContext");

                }

                retObj = (AppContext) componentAppContextField.get(target);

            } else if (target instanceof MenuComponent) {

                if (menuComponentAppContextField == null) {

                    menuComponentAppContextField = getField(MenuComponent.class, "appContext");

                }

                retObj = (AppContext) menuComponentAppContextField.get(target);

            }

        } catch( IllegalAccessException e){

            assert false;

        }

        return retObj;

    }

    /*

     * Fetch the AppContext associated with the given target.

     * This can be used to determine things like which EventQueue

     * to use for posting events to a Component.  If the target is

     * null or the target can't be found, a null with be returned.

     */

    public static AppContext targetToAppContext(Object target) {

        if (target == null || GraphicsEnvironment.isHeadless()) {

            return null;

        }

        AppContext context = getAppContext(target);

        if (context == null) {

            // target is not a Component/MenuComponent, try the

            // appContextMap.

            context = (AppContext)appContextMap.get(target);

        }

        return context;

    }

     /**

      * Sets the synchronous status of focus requests on lightweight

      * components in the specified window to the specified value.

      * If the boolean parameter is <code>true</code> then the focus

      * requests on lightweight components will be performed

      * synchronously, if it is <code>false</code>, then asynchronously.

      * By default, all windows have their lightweight request status

      * set to asynchronous.

      * <p>

      * The application can only set the status of lightweight focus

      * requests to synchronous for any of its windows if it doesn't

      * perform focus transfers between different heavyweight containers.

      * In this case the observable focus behaviour is the same as with

      * asynchronous status.

      * <p>

      * If the application performs focus transfer between different

      * heavyweight containers and sets the lightweight focus request

      * status to synchronous for any of its windows, then further focus

      * behaviour is unspecified.

      * <p>

      * @param    w window for which the lightweight focus request status

      *             should be set

      * @param    status the value of lightweight focus request status

      */

    public static void setLWRequestStatus(Window changed,boolean status){

        if (syncLWRequestsField == null){

            syncLWRequestsField = getField(Window.class, "syncLWRequests");

        }

        try{

            if (syncLWRequestsField != null){

                syncLWRequestsField.setBoolean(changed, status);

            }

        } catch( IllegalAccessException e){

            assert false;

        }

    };

    public static void checkAndSetPolicy(Container cont, boolean isSwingCont)

    {

        FocusTraversalPolicy defaultPolicy = KeyboardFocusManager

            .getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();

        String toolkitName = Toolkit.getDefaultToolkit().getClass().getName();