/*

 * Copyright 2002-2009 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.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.lang.reflect.InvocationTargetException;

import java.lang.reflect.Method;

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.font.FontManager;

import sun.misc.PerformanceLogger;

import sun.print.PrintJob2D;

import sun.security.action.GetBooleanAction;

import sun.util.logging.PlatformLogger;

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;

    // WeakSet should be used here, but there is no such class

    // in JDK (at least in JDK6 and earlier versions)

    private WeakHashMap<Window, Boolean> overrideRedirectWindows =

        new WeakHashMap<Window, Boolean>();

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

    static long awt_defaultFg; // Pixel

    private static XMouseInfoPeer xPeer;

    private static Method m_removeSourceEvents;

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

        }

        m_removeSourceEvents = SunToolkit.getMethod(EventQueue.class, "removeSourceEvents", new Class[] {Object.class, Boolean.TYPE}) ;

        noisyAwtHandler = AccessController.doPrivileged(new GetBooleanAction("sun.awt.noisyerrorhandler"));

    }

    //---- ERROR HANDLER CODE ----//

    /*

     * Error handler at the moment of XToolkit initialization

     */

    private static long saved_error_handler;

    /*

     * XErrorEvent being handled

     */

    static volatile XErrorEvent saved_error;

    /*

     * Current error handler or null if no error handler is set

     */

    private static XErrorHandler current_error_handler;

    /*

     * Value of sun.awt.noisyerrorhandler system property

     */

    private static boolean noisyAwtHandler;

    public static void WITH_XERROR_HANDLER(XErrorHandler handler) {

        saved_error = null;

        current_error_handler = handler;

    }

    public static void RESTORE_XERROR_HANDLER() {

        // wait until all requests are processed by the X server

        // and only then uninstall the error handler

        XSync();

        current_error_handler = null;

    }

    // Should be called under LOCK

    public static int SAVED_ERROR_HANDLER(long display, XErrorEvent error) {

        if (saved_error_handler != 0) {

            // Default XErrorHandler may just terminate the process. Don't call it.

            // return XlibWrapper.CallErrorHandler(saved_error_handler, display, error.pData);

        }

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

            log.fine("Unhandled XErrorEvent: " +

                     "id=" + error.get_resourceid() + ", " +

                     "serial=" + error.get_serial() + ", " +

                     "ec=" + error.get_error_code() + ", " +

                     "rc=" + error.get_request_code() + ", " +

                     "mc=" + error.get_minor_code());

        }

        return 0;

    }

    // Called from the native code when an error occurs

    private static int globalErrorHandler(long display, long event_ptr) {

        if (noisyAwtHandler) {

            XlibWrapper.PrintXErrorEvent(display, event_ptr);

        }

        XErrorEvent event = new XErrorEvent(event_ptr);

        saved_error = event;

        try {

            if (current_error_handler != null) {

                return current_error_handler.handleError(display, event);

            } else {

                return SAVED_ERROR_HANDLER(display, event);

            }

        } catch (Throwable z) {

            log.fine("Error in GlobalErrorHandler", z);

        }

        return 0;

    }

    //---- END OF ERROR HANDLER CODE ----//

    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 = getSystemProperty("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);

            saved_error_handler = XlibWrapper.SetToolkitErrorHandler();

        } finally {

            awtUnlock();

        }

        Runtime.getRuntime().addShutdownHook(new Thread() {

            public void run() {

                XSystemTrayPeer peer = XSystemTrayPeer.getPeerInstance();

                if (peer != null) {

                    peer.dispose();

                }

                if (xs != null) {

                    ((XAWTXSettings)xs).dispose();

                }

                freeXKB();

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

                    dumpPeers();

                }

            }

        });

    }

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

            toolkitThread = new Thread(this, "AWT-XAWT");

            toolkitThread.setPriority(Thread.NORM_PRIORITY + 1);

            toolkitThread.setDaemon(true);

            ThreadGroup mainTG = (ThreadGroup)AccessController.doPrivileged(

                                                                            new PrivilegedAction() {

                                                                                    public Object run() {

                                                                                        ThreadGroup currentTG =

                                                                                            Thread.currentThread().getThreadGroup();

                                                                                        ThreadGroup parentTG = currentTG.getParent();

                                                                                        while (parentTG != null) {

                                                                                            currentTG = parentTG;

                                                                                            parentTG = currentTG.getParent();

                                                                                        }

                                                                                        return currentTG;

                                                                                    }

                                                                                });

            toolkitThread.start();

        }

    }

    public ButtonPeer createButton(Button target) {

        ButtonPeer peer = new XButtonPeer(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);

        }

    }