/*

 * Copyright (c) 1997, 2011, Oracle and/or its affiliates. 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.  Oracle designates this

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

 * by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.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.image.*;

import java.awt.TrayIcon;

import java.awt.SystemTray;

import java.net.URL;

import java.util.*;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

import sun.util.logging.PlatformLogger;

import sun.misc.SoftCache;

import sun.font.FontDesignMetrics;

import sun.awt.im.InputContext;

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 PlatformLogger log = PlatformLogger.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 Method  wakeupMethod;

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

     */

    private static final String POST_EVENT_QUEUE_KEY = "PostEventQueue";

    /**

     * Number of buttons.

     * By default it's taken from the system. If system value does not

     * fit into int type range, use our own MAX_BUTTONS_SUPPORT value.

     */

    protected static int numberOfButtons = 0;

    /* XFree standard mention 24 buttons as maximum:

     * http://www.xfree86.org/current/mouse.4.html

     * We workaround systems supporting more than 24 buttons.

     * Otherwise, we have to use long type values as masks

     * which leads to API change.

     * InputEvent.BUTTON_DOWN_MASK may contain only 21 masks due to

     * the 4-bytes limit for the int type. (CR 6799099)

     * One more bit is reserved for FIRST_HIGH_BIT.

     */

    public final static int MAX_BUTTONS_SUPPORTED = 20;

    private static void initEQ(AppContext appContext) {

        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.put(AppContext.EVENT_QUEUE_KEY, eventQueue);

        PostEventQueue postEventQueue = new PostEventQueue(eventQueue);

        appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);

    }

    public SunToolkit() {

        // 7122796: Always create an EQ for the main AppContext

        initEQ(AppContext.getMainAppContext());

    }

    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();

    @SuppressWarnings("deprecation")

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

    public abstract RobotPeer createRobot(Robot target, GraphicsDevice screen)

        throws AWTException;

    public abstract KeyboardFocusManagerPeer createKeyboardFocusManagerPeer(KeyboardFocusManager manager)

        throws HeadlessException;

    /**

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

        // Create appContext before initialization of EventQueue, so all

        // the calls to AppContext.getAppContext() from EventQueue ctor

        // return correct values

        AppContext appContext = new AppContext(threadGroup);

        initEQ(appContext);

        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 = AccessController.doPrivileged(new PrivilegedAction<Method>() {

                    public Method 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<Object, AppContext> appContextMap =

        Collections.synchronizedMap(new WeakHashMap<Object, AppContext>());

    /**

     * 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) {

            AWTAccessor.getComponentAccessor().

                setAppContext((Component)target, context);

        } else if (target instanceof MenuComponent) {

            AWTAccessor.getMenuComponentAccessor().

                setAppContext((MenuComponent)target, context);

        } else {

            return 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) {

        if (target instanceof Component) {

            return AWTAccessor.getComponentAccessor().

                       getAppContext((Component)target);

        } else if (target instanceof MenuComponent) {

            return AWTAccessor.getMenuComponentAccessor().

                       getAppContext((MenuComponent)target);

        } else {

            return null;

        }

    }

    /*

     * 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 = 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){

        AWTAccessor.getWindowAccessor().setLWRequestStatus(changed, status);

    };

    public static void checkAndSetPolicy(Container cont, boolean isSwingCont)

    {

        FocusTraversalPolicy defaultPolicy = KeyboardFocusManager

            .getCurrentKeyboardFocusManager().getDefaultFocusTraversalPolicy();

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

        // if this is not XAWT then use default policy

        // because Swing change it

        if (!"sun.awt.X11.XToolkit".equals(toolkitName)) {

            cont.setFocusTraversalPolicy(defaultPolicy);

            return;

        }

        String policyName = defaultPolicy.getClass().getName();

        if (DefaultFocusTraversalPolicy.class != defaultPolicy.getClass()) {

            // Policy was changed

            // Check if it is awt policy or swing policy

            // If it is Swing policy we shouldn't use it in AWT frames

            // If it is AWT policy  we shouldn't use it in Swing frames

            // Otherwise we should use this policy

            if (policyName.startsWith("java.awt.")) {

                // AWT

                if (isSwingCont) {

                    // Can't use AWT policy in Swing windows - should use Swing's one.

                    defaultPolicy = createLayoutPolicy();

                } else {

                    // New awt policy.

                }

            } else if (policyName.startsWith("javax.swing.")) {

                if (isSwingCont) {

                    // New Swing's policy

                } else {

                    defaultPolicy = new DefaultFocusTraversalPolicy();

                }

            }

        } else {

            // Policy is default, use different default policy for swing

            if (isSwingCont) {

                defaultPolicy = createLayoutPolicy();

            }

        }

        cont.setFocusTraversalPolicy(defaultPolicy);

    }

    private static FocusTraversalPolicy createLayoutPolicy() {

        FocusTraversalPolicy policy = null;

        try {

            Class<?> layoutPolicyClass =

                Class.forName("javax.swing.LayoutFocusTraversalPolicy");

            policy = (FocusTraversalPolicy)layoutPolicyClass.newInstance();

        }

        catch (ClassNotFoundException e) {

            assert false;

        }

        catch (InstantiationException e) {

            assert false;

        }

        catch (IllegalAccessException e) {