/*

 * Copyright 2002-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.X11;

import java.awt.*;

import java.awt.event.InputEvent;

import java.awt.event.MouseEvent;

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 java.util.logging.Level;

import java.util.logging.Logger;

import javax.swing.LookAndFeel;

import javax.swing.UIDefaults;

import sun.awt.*;

import sun.font.FontManager;

import sun.misc.PerformanceLogger;

import sun.print.PrintJob2D;

public final class XToolkit extends UNIXToolkit implements Runnable {

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

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

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

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

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

    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;

    /**

     * True when the x settings have been loaded.

     */

    private boolean loadedXSettings;

    /**

    * XSETTINGS for the default screen.

     * <p>

     */

    private XSettings xs;

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

    }

    // Error handler stuff

    static XErrorEvent saved_error;

    static long saved_error_handler;

    static XErrorHandler curErrorHandler;

    // Should be called under LOCK, before releasing LOCK RESTORE_XERROR_HANDLER should be called

    static void WITH_XERROR_HANDLER(XErrorHandler handler) {

        saved_error = null;

        curErrorHandler = handler;

        XSync();

        saved_error_handler = XlibWrapper.SetToolkitErrorHandler();

    }

    static void XERROR_SAVE(XErrorEvent event) {

        saved_error = event;

    }

    // Should be called under LOCK

    static void RESTORE_XERROR_HANDLER() {

       XSync();

        XlibWrapper.XSetErrorHandler(saved_error_handler);

        curErrorHandler = null;

    }

    // Should be called under LOCK

    static int SAVED_ERROR_HANDLER(long display, XErrorEvent error) {

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

    }

    interface XErrorHandler {

        int handleError(long display, XErrorEvent err);

    }

    static int GlobalErrorHandler(long display, long event_ptr) {

        XErrorEvent event = new XErrorEvent(event_ptr);

        try {

            if (curErrorHandler != null) {

                return curErrorHandler.handleError(display, event);

            } else {

                return SAVED_ERROR_HANDLER(display, event);

            }

        } finally {

        }

    }

/*

 * Instead of validating window id, we simply call XGetWindowProperty,

 * but temporary install this function as the error handler to ignore

 * BadWindow error.

 */

    static XErrorHandler IgnoreBadWindowHandler = new XErrorHandler() {

            public int handleError(long display, XErrorEvent err) {

                XERROR_SAVE(err);

                if (err.get_error_code() == XConstants.BadWindow) {

                    return 0;

                } else {

                    return SAVED_ERROR_HANDLER(display, err);

                }

            }

        };

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

            }

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

            awt_defaultFg = defaultScreen.get_blackpixel();

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

                XCursorFontConstants.XC_arrow);

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

                    }

                    if (log.isLoggable(Level.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);

        }

    }

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

        }

        XBaseWindow.dispatchToWindow(ev);

        Collection dispatchers = null;

        synchronized(winToDispatcher) {

            Long key = Long.valueOf(xany.get_window());

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

            if (dispatchers != null) { // Clone it to avoid synchronization during dispatching

                dispatchers = new Vector(dispatchers);

            }

        }

        if (dispatchers != null) {

            Iterator iter = dispatchers.iterator();

            while (iter.hasNext()) {

                XEventDispatcher disp = (XEventDispatcher)iter.next();

                disp.dispatchEvent(ev);

            }

        }

        notifyListeners(ev);

    }

    static void processException(Throwable thr) {

        if (log.isLoggable(Level.WARNING)) {

            log.log(Level.WARNING, "Exception on Toolkit thread", thr);