/*

 * Copyright (c) 2002, 2013, 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.X11;

import java.awt.*;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

import java.awt.event.KeyEvent;

import java.awt.datatransfer.Clipboard;

import java.awt.dnd.DragSource;

import java.awt.dnd.DragGestureListener;

import java.awt.dnd.DragGestureEvent;

import java.awt.dnd.DragGestureRecognizer;

import java.awt.dnd.MouseDragGestureRecognizer;

import java.awt.dnd.InvalidDnDOperationException;

import java.awt.dnd.peer.DragSourceContextPeer;

import java.awt.im.InputMethodHighlight;

import java.awt.im.spi.InputMethodDescriptor;

import java.awt.image.ColorModel;

import java.awt.peer.*;

import java.beans.PropertyChangeListener;

import java.security.AccessController;

import java.security.PrivilegedAction;

import java.util.*;

import javax.swing.LookAndFeel;

import javax.swing.UIDefaults;

import sun.awt.*;

import sun.font.FontConfigManager;

import sun.java2d.SunGraphicsEnvironment;

import sun.misc.PerformanceLogger;

import sun.print.PrintJob2D;

import sun.security.action.GetPropertyAction;

import sun.security.action.GetBooleanAction;

import sun.util.logging.PlatformLogger;

import sun.security.util.SecurityConstants;

public final class XToolkit extends UNIXToolkit implements Runnable {

    private static final PlatformLogger log = PlatformLogger.getLogger("sun.awt.X11.XToolkit");

    private static final PlatformLogger eventLog = PlatformLogger.getLogger("sun.awt.X11.event.XToolkit");

    private static final PlatformLogger timeoutTaskLog = PlatformLogger.getLogger("sun.awt.X11.timeoutTask.XToolkit");

    private static final PlatformLogger keyEventLog = PlatformLogger.getLogger("sun.awt.X11.kye.XToolkit");

    private static final PlatformLogger backingStoreLog = PlatformLogger.getLogger("sun.awt.X11.backingStore.XToolkit");

    //There is 400 ms is set by default on Windows and 500 by default on KDE and GNOME.

    //We use the same hardcoded constant.

    private final static int AWT_MULTICLICK_DEFAULT_TIME = 500;

    static final boolean PRIMARY_LOOP = false;

    static final boolean SECONDARY_LOOP = true;

    private static String awtAppClassName = null;

    // the system clipboard - CLIPBOARD selection

    XClipboard clipboard;

    // the system selection - PRIMARY selection

    XClipboard selection;

    // Dynamic Layout Resize client code setting

    protected static boolean dynamicLayoutSetting = false;

    //Is it allowed to generate events assigned to extra mouse buttons.

    //Set to true by default.

    private static boolean areExtraMouseButtonsEnabled = true;

    /**

     * True when the x settings have been loaded.

     */

    private boolean loadedXSettings;

    /**

    * XSETTINGS for the default screen.

     * <p>

     */

    private XSettings xs;

    private FontConfigManager fcManager = new FontConfigManager();

    static int arrowCursor;

    static TreeMap winMap = new TreeMap();

    static HashMap specialPeerMap = new HashMap();

    static HashMap winToDispatcher = new HashMap();

    private static long _display;

    static UIDefaults uidefaults;

    static X11GraphicsEnvironment localEnv;

    static X11GraphicsDevice device;

    static final X11GraphicsConfig config;

    static int awt_multiclick_time;

    static boolean securityWarningEnabled;

    private static volatile int screenWidth = -1, screenHeight = -1; // Dimensions of default screen

    static long awt_defaultFg; // Pixel

    private static XMouseInfoPeer xPeer;

    static {

        initSecurityWarning();

        if (GraphicsEnvironment.isHeadless()) {

            config = null;

        } else {

            localEnv = (X11GraphicsEnvironment) GraphicsEnvironment

                .getLocalGraphicsEnvironment();

            device = (X11GraphicsDevice) localEnv.getDefaultScreenDevice();

            config = (X11GraphicsConfig) (device.getDefaultConfiguration());

            if (device != null) {

                _display = device.getDisplay();

            }

            setupModifierMap();

            initIDs();

            setBackingStoreType();

        }

    }

    /*

     * Return (potentially) platform specific display timeout for the

     * tray icon

     */

    static native long getTrayIconDisplayTimeout();

    private native static void initIDs();

    native static void waitForEvents(long nextTaskTime);

    static Thread toolkitThread;

    static boolean isToolkitThread() {

        return Thread.currentThread() == toolkitThread;

    }

    static void initSecurityWarning() {

        // Enable warning only for internal builds

        String runtime = AccessController.doPrivileged(

                             new GetPropertyAction("java.runtime.version"));

        securityWarningEnabled = (runtime != null && runtime.contains("internal"));

    }

    static boolean isSecurityWarningEnabled() {

        return securityWarningEnabled;

    }

    static native void awt_output_flush();

    static final void  awtFUnlock() {

        awtUnlock();

        awt_output_flush();

    }

    public native void nativeLoadSystemColors(int[] systemColors);

    static UIDefaults getUIDefaults() {

        if (uidefaults == null) {

            initUIDefaults();

        }

        return uidefaults;

    }

    public void loadSystemColors(int[] systemColors) {

        nativeLoadSystemColors(systemColors);

        MotifColorUtilities.loadSystemColors(systemColors);

    }

    static void initUIDefaults() {

        try {

            // Load Defaults from MotifLookAndFeel

            // This dummy load is necessary to get SystemColor initialized. !!!!!!

            Color c = SystemColor.text;

            LookAndFeel lnf = new XAWTLookAndFeel();

            uidefaults = lnf.getDefaults();

        }

        catch (Exception e)

        {

            e.printStackTrace();

        }

    }

    static Object displayLock = new Object();

    public static long getDisplay() {

        return _display;

    }

    public static long getDefaultRootWindow() {

        awtLock();

        try {

            long res = XlibWrapper.RootWindow(XToolkit.getDisplay(),

                XlibWrapper.DefaultScreen(XToolkit.getDisplay()));

            if (res == 0) {

               throw new IllegalStateException("Root window must not be null");

            }

            return res;

        } finally {

            awtUnlock();

        }

    }

    void init() {

        awtLock();

        try {

            XlibWrapper.XSupportsLocale();

            if (XlibWrapper.XSetLocaleModifiers("") == null) {

                log.finer("X locale modifiers are not supported, using default");

            }

            tryXKB();

            AwtScreenData defaultScreen = new AwtScreenData(XToolkit.getDefaultScreenData());

            awt_defaultFg = defaultScreen.get_blackpixel();

            arrowCursor = XlibWrapper.XCreateFontCursor(XToolkit.getDisplay(),

                XCursorFontConstants.XC_arrow);

            areExtraMouseButtonsEnabled = Boolean.parseBoolean(System.getProperty("sun.awt.enableExtraMouseButtons", "true"));

            //set system property if not yet assigned

            System.setProperty("sun.awt.enableExtraMouseButtons", ""+areExtraMouseButtonsEnabled);

            // Detect display mode changes

            XlibWrapper.XSelectInput(XToolkit.getDisplay(), XToolkit.getDefaultRootWindow(), XConstants.StructureNotifyMask);

            XToolkit.addEventDispatcher(XToolkit.getDefaultRootWindow(), new XEventDispatcher() {

                @Override

                public void dispatchEvent(XEvent ev) {

                    if (ev.get_type() == XConstants.ConfigureNotify) {

                    }

                }

            });

        } finally {

            awtUnlock();

        }

        PrivilegedAction<Void> a = new PrivilegedAction<Void>() {

            public Void run() {

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

                ThreadGroup parentTG = mainTG.getParent();

                while (parentTG != null) {

                    mainTG = parentTG;

                    parentTG = mainTG.getParent();

                }

                Thread shutdownThread = new Thread(mainTG, "XToolkt-Shutdown-Thread") {

                        public void run() {

                            XSystemTrayPeer peer = XSystemTrayPeer.getPeerInstance();

                            if (peer != null) {

                                peer.dispose();

                            }

                            if (xs != null) {

                                ((XAWTXSettings)xs).dispose();

                            }

                            freeXKB();

                            if (log.isLoggable(PlatformLogger.Level.FINE)) {

                                dumpPeers();

                            }

                        }

                    };

                shutdownThread.setContextClassLoader(null);

                Runtime.getRuntime().addShutdownHook(shutdownThread);

                return null;

            }

        };

        AccessController.doPrivileged(a);

    }

    static String getCorrectXIDString(String val) {

        if (val != null) {

            return val.replace('.', '-');

        } else {

            return val;

        }

    }

    static native String getEnv(String key);

    static String getAWTAppClassName() {

        return awtAppClassName;

    }

    static final String DATA_TRANSFERER_CLASS_NAME = "sun.awt.X11.XDataTransferer";

    public XToolkit() {

        super();

        if (PerformanceLogger.loggingEnabled()) {

            PerformanceLogger.setTime("XToolkit construction");

        }

        if (!GraphicsEnvironment.isHeadless()) {

            String mainClassName = null;

            StackTraceElement trace[] = (new Throwable()).getStackTrace();

            int bottom = trace.length - 1;

            if (bottom >= 0) {

                mainClassName = trace[bottom].getClassName();

            }

            if (mainClassName == null || mainClassName.equals("")) {

                mainClassName = "AWT";

            }

            awtAppClassName = getCorrectXIDString(mainClassName);

            init();

            XWM.init();

            SunToolkit.setDataTransfererClassName(DATA_TRANSFERER_CLASS_NAME);

            PrivilegedAction<Thread> action = new PrivilegedAction() {

                public Thread run() {

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

                    ThreadGroup parentTG = currentTG.getParent();

                    while (parentTG != null) {

                        currentTG = parentTG;

                        parentTG = currentTG.getParent();

                    }

                    Thread thread = new Thread(currentTG, XToolkit.this, "AWT-XAWT");

                    thread.setPriority(Thread.NORM_PRIORITY + 1);

                    thread.setDaemon(true);

                    return thread;

                }

            };

            toolkitThread = AccessController.doPrivileged(action);

            toolkitThread.start();

        }

    }

    public ButtonPeer createButton(Button target) {

        ButtonPeer peer = new XButtonPeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public FramePeer createLightweightFrame(LightweightFrame target) {

        FramePeer peer = new XLightweightFramePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    public FramePeer createFrame(Frame target) {

        FramePeer peer = new XFramePeer(target);

        targetCreatedPeer(target, peer);

        return peer;

    }

    static void addToWinMap(long window, XBaseWindow xwin)

    {

        synchronized(winMap) {

            winMap.put(Long.valueOf(window),xwin);

        }

    }

    static void removeFromWinMap(long window, XBaseWindow xwin) {

        synchronized(winMap) {

            winMap.remove(Long.valueOf(window));

        }

    }

    static XBaseWindow windowToXWindow(long window) {

        synchronized(winMap) {

            return (XBaseWindow) winMap.get(Long.valueOf(window));

        }

    }

    static void addEventDispatcher(long window, XEventDispatcher dispatcher) {

        synchronized(winToDispatcher) {

            Long key = Long.valueOf(window);

            Collection dispatchers = (Collection)winToDispatcher.get(key);

            if (dispatchers == null) {

                dispatchers = new Vector();

                winToDispatcher.put(key, dispatchers);

            }

            dispatchers.add(dispatcher);

        }

    }

    static void removeEventDispatcher(long window, XEventDispatcher dispatcher) {

        synchronized(winToDispatcher) {

            Long key = Long.valueOf(window);

            Collection dispatchers = (Collection)winToDispatcher.get(key);

            if (dispatchers != null) {

                dispatchers.remove(dispatcher);

            }

        }

    }

    private Point lastCursorPos;

    /**

     * Returns whether there is last remembered cursor position.  The

     * position is remembered from X mouse events on our peers.  The

     * position is stored in <code>p</code>.

     * @return true, if there is remembered last cursor position,

     * false otherwise

     */

    boolean getLastCursorPos(Point p) {

        awtLock();

        try {

            if (lastCursorPos == null) {

                return false;

            }

            p.setLocation(lastCursorPos);

            return true;

        } finally {

            awtUnlock();

        }

    }

    private void processGlobalMotionEvent(XEvent e) {

        // Only our windows guaranteely generate MotionNotify, so we

        // should track enter/leave, to catch the moment when to

        // switch to XQueryPointer

        if (e.get_type() == XConstants.MotionNotify) {

            XMotionEvent ev = e.get_xmotion();

            awtLock();

            try {

                if (lastCursorPos == null) {

                    lastCursorPos = new Point(ev.get_x_root(), ev.get_y_root());

                } else {

                    lastCursorPos.setLocation(ev.get_x_root(), ev.get_y_root());

                }

            } finally {

                awtUnlock();

            }

        } else if (e.get_type() == XConstants.LeaveNotify) {

            // Leave from our window

            awtLock();

            try {

                lastCursorPos = null;

            } finally {

                awtUnlock();

            }

        } else if (e.get_type() == XConstants.EnterNotify) {

            // Entrance into our window

            XCrossingEvent ev = e.get_xcrossing();

            awtLock();

            try {

                if (lastCursorPos == null) {

                    lastCursorPos = new Point(ev.get_x_root(), ev.get_y_root());

                } else {

                    lastCursorPos.setLocation(ev.get_x_root(), ev.get_y_root());

                }

            } finally {

                awtUnlock();

            }

        }

    }

    public interface XEventListener {

        public void eventProcessed(XEvent e);

    }

    private Collection<XEventListener> listeners = new LinkedList<XEventListener>();

    public void addXEventListener(XEventListener listener) {

        synchronized (listeners) {

            listeners.add(listener);

        }

    }

    private void notifyListeners(XEvent xev) {

        synchronized (listeners) {

            if (listeners.size() == 0) return;

            XEvent copy = xev.clone();

            try {

                for (XEventListener listener : listeners) {

                    listener.eventProcessed(copy);

                }

            } finally {

                copy.dispose();

            }

        }

    }

    private void dispatchEvent(XEvent ev) {

        final XAnyEvent xany = ev.get_xany();

        if (windowToXWindow(xany.get_window()) != null &&

             (ev.get_type() == XConstants.MotionNotify || ev.get_type() == XConstants.EnterNotify || ev.get_type() == XConstants.LeaveNotify))

        {

            processGlobalMotionEvent(ev);

        }

        if( ev.get_type() == XConstants.MappingNotify ) {

            // The 'window' field in this event is unused.

            // This application itself does nothing to initiate such an event

            // (no calls of XChangeKeyboardMapping etc.).

            // SunRay server sends this event to the application once on every

            // keyboard (not just layout) change which means, quite seldom.

            XlibWrapper.XRefreshKeyboardMapping(ev.pData);

            resetKeyboardSniffer();

            setupModifierMap();

        }

        XBaseWindow.dispatchToWindow(ev);

        Collection dispatchers = null;

        synchronized(winToDispatcher) {