/*

 * Copyright (c) 1997, 2016, 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 java.awt.event.InputEvent;

import java.awt.event.KeyEvent;

import java.awt.event.WindowEvent;

import java.awt.image.BufferedImage;

import java.awt.image.ColorModel;

import java.awt.image.DataBuffer;

import java.awt.image.DataBufferInt;

import java.awt.image.ImageObserver;

import java.awt.image.ImageProducer;

import java.awt.image.Raster;

import java.awt.peer.FramePeer;

import java.awt.peer.KeyboardFocusManagerPeer;

import java.awt.peer.MouseInfoPeer;

import java.awt.peer.SystemTrayPeer;

import java.awt.peer.TrayIconPeer;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.lang.reflect.InvocationTargetException;

import java.net.URL;

import java.security.AccessController;

import java.util.ArrayList;

import java.util.Collections;

import java.util.Iterator;

import java.util.Locale;

import java.util.Map;

import java.util.Vector;

import java.util.WeakHashMap;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.ReentrantLock;

import sun.awt.im.InputContext;

import sun.awt.image.ByteArrayImageSource;

import sun.awt.image.FileImageSource;

import sun.awt.image.ImageRepresentation;

import java.awt.image.MultiResolutionImage;

import sun.awt.image.MultiResolutionToolkitImage;

import sun.awt.image.ToolkitImage;

import sun.awt.image.URLImageSource;

import sun.font.FontDesignMetrics;

import sun.net.util.URLUtil;

import sun.security.action.GetBooleanAction;

import sun.security.action.GetPropertyAction;

import sun.util.logging.PlatformLogger;

import static java.awt.RenderingHints.*;

public abstract class SunToolkit extends Toolkit

    implements ComponentFactory, InputMethodSupport, KeyboardFocusManagerPeerProvider {

    // 8014718: logging has been removed from 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;

    /* 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 static final int MAX_BUTTONS_SUPPORTED = 20;

    /**

     * Creates and initializes EventQueue instance for the specified

     * AppContext.

     * Note that event queue must be created from createNewAppContext()

     * only in order to ensure that EventQueue constructor obtains

     * the correct AppContext.

     * @param appContext AppContext to associate with the event queue

     */

    private static void initEQ(AppContext appContext) {

        EventQueue eventQueue = new EventQueue();

        appContext.put(AppContext.EVENT_QUEUE_KEY, eventQueue);

        PostEventQueue postEventQueue = new PostEventQueue(eventQueue);

        appContext.put(POST_EVENT_QUEUE_KEY, postEventQueue);

    }

    public SunToolkit() {

    }

    public boolean useBufferPerWindow() {

        return false;

    }

    public abstract FramePeer createLightweightFrame(LightweightFrame target)

        throws HeadlessException;

    public abstract TrayIconPeer createTrayIcon(TrayIcon target)

        throws HeadlessException, AWTException;

    public abstract SystemTrayPeer createSystemTray(SystemTray target);

    public abstract boolean isTraySupported();

    @Override

    public abstract KeyboardFocusManagerPeer getKeyboardFocusManagerPeer()

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

        return createNewAppContext(threadGroup);

    }

    static final AppContext createNewAppContext(ThreadGroup threadGroup) {

        // 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;

    }

    static void wakeupEventQueue(EventQueue q, boolean isShutdown){

        AWTAccessor.getEventQueueAccessor().wakeup(q, isShutdown);

    }

    /*

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

            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} then the focus

      * requests on lightweight components will be performed

      * synchronously, if it is {@code false}, 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    changed the 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) {

        FocusTraversalPolicy defaultPolicy = KeyboardFocusManager.

            getCurrentKeyboardFocusManager().

                getDefaultFocusTraversalPolicy();

        cont.setFocusTraversalPolicy(defaultPolicy);

    }

    /*

     * Insert a mapping from target to AppContext, for later retrieval

     * via targetToAppContext() above.

     */

    public static void insertTargetMapping(Object target, AppContext appContext) {

        if (!setAppContext(target, appContext)) {

            // Target is not a Component/MenuComponent, use the private Map

            // instead.

            appContextMap.put(target, appContext);

        }

    }

    /*

     * Post an AWTEvent to the Java EventQueue, using the PostEventQueue

     * to avoid possibly calling client code (EventQueueSubclass.postEvent())

     * on the toolkit (AWT-Windows/AWT-Motif) thread.  This function should

     * not be called under another lock since it locks the EventQueue.

     * See bugids 4632918, 4526597.

     */

    public static void postEvent(AppContext appContext, AWTEvent event) {

        if (event == null) {

            throw new NullPointerException();

        }

        AWTAccessor.SequencedEventAccessor sea = AWTAccessor.getSequencedEventAccessor();

        if (sea != null && sea.isSequencedEvent(event)) {

            AWTEvent nested = sea.getNested(event);

            if (nested.getID() == WindowEvent.WINDOW_LOST_FOCUS &&

                nested instanceof TimedWindowEvent)

            {

                TimedWindowEvent twe = (TimedWindowEvent)nested;

                ((SunToolkit)Toolkit.getDefaultToolkit()).

                    setWindowDeactivationTime((Window)twe.getSource(), twe.getWhen());

            }

        }

        // All events posted via this method are system-generated.

        // Placing the following call here reduces considerably the

        // number of places throughout the toolkit that would

        // otherwise have to be modified to precisely identify

        // system-generated events.

        setSystemGenerated(event);

        AppContext eventContext = targetToAppContext(event.getSource());

        if (eventContext != null && !eventContext.equals(appContext)) {

            throw new RuntimeException("Event posted on wrong app context : " + event);

        }

        PostEventQueue postEventQueue =

            (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);

        if (postEventQueue != null) {

            postEventQueue.postEvent(event);

        }

    }

    /*

     * Post AWTEvent of high priority.

     */

    public static void postPriorityEvent(final AWTEvent e) {

        PeerEvent pe = new PeerEvent(Toolkit.getDefaultToolkit(), new Runnable() {

                @Override

                public void run() {

                    AWTAccessor.getAWTEventAccessor().setPosted(e);

                    ((Component)e.getSource()).dispatchEvent(e);

                }

            }, PeerEvent.ULTIMATE_PRIORITY_EVENT);

        postEvent(targetToAppContext(e.getSource()), pe);

    }

    /*

     * Flush any pending events which haven't been posted to the AWT

     * EventQueue yet.

     */

    public static void flushPendingEvents()  {

        AppContext appContext = AppContext.getAppContext();

        flushPendingEvents(appContext);

    }

    /*

     * Flush the PostEventQueue for the right AppContext.

     * The default flushPendingEvents only flushes the thread-local context,

     * which is not always correct, c.f. 3746956

     */

    public static void flushPendingEvents(AppContext appContext) {

        PostEventQueue postEventQueue =

                (PostEventQueue)appContext.get(POST_EVENT_QUEUE_KEY);

        if (postEventQueue != null) {

            postEventQueue.flush();

        }

    }

    /*

     * Execute a chunk of code on the Java event handler thread for the

     * given target.  Does not wait for the execution to occur before

     * returning to the caller.

     */

    public static void executeOnEventHandlerThread(Object target,

                                                   Runnable runnable) {

        executeOnEventHandlerThread(new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT));

    }

    /*

     * Fixed 5064013: the InvocationEvent time should be equals

     * the time of the ActionEvent

     */

    @SuppressWarnings("serial")

    public static void executeOnEventHandlerThread(Object target,

                                                   Runnable runnable,

                                                   final long when) {

        executeOnEventHandlerThread(

            new PeerEvent(target, runnable, PeerEvent.PRIORITY_EVENT) {

                @Override

                public long getWhen() {

                    return when;

                }

            });

    }

    /*

     * Execute a chunk of code on the Java event handler thread for the

     * given target.  Does not wait for the execution to occur before

     * returning to the caller.

     */

    public static void executeOnEventHandlerThread(PeerEvent peerEvent) {

        postEvent(targetToAppContext(peerEvent.getSource()), peerEvent);

    }

    /*

     * Execute a chunk of code on the Java event handler thread. The

     * method takes into account provided AppContext and sets

     * {@code SunToolkit.getDefaultToolkit()} as a target of the

     * event. See 6451487 for detailes.

     * Does not wait for the execution to occur before returning to

     * the caller.

     */

     public static void invokeLaterOnAppContext(