/*

 * Copyright (c) 2003, 2014, 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.Component;

import java.awt.Cursor;

import java.awt.Window;

import java.awt.datatransfer.Transferable;

import java.awt.dnd.DnDConstants;

import java.awt.dnd.DragGestureEvent;

import java.awt.dnd.InvalidDnDOperationException;

import java.util.*;

import sun.util.logging.PlatformLogger;

import sun.awt.dnd.SunDragSourceContextPeer;

import sun.awt.dnd.SunDropTargetContextPeer;

import sun.awt.SunToolkit;

import sun.awt.AWTAccessor;

/**

 * The XDragSourceContextPeer class is the class responsible for handling

 * the interaction between the XDnD/Motif DnD subsystem and Java drag sources.

 *

 * @since 1.5

 */

public final class XDragSourceContextPeer

    extends SunDragSourceContextPeer implements XDragSourceProtocolListener {

    private static final PlatformLogger logger =

        PlatformLogger.getLogger("sun.awt.X11.xembed.xdnd.XDragSourceContextPeer");

    /* The events selected on the root window when the drag begins. */

    private static final int ROOT_EVENT_MASK = (int)XConstants.ButtonMotionMask |

        (int)XConstants.KeyPressMask | (int)XConstants.KeyReleaseMask;

    /* The events to be delivered during grab. */

    private static final int GRAB_EVENT_MASK = (int)XConstants.ButtonPressMask |

        (int)XConstants.ButtonMotionMask | (int)XConstants.ButtonReleaseMask;

    /* The event mask of the root window before the drag operation starts. */

    private long rootEventMask = 0;

    private boolean dndInProgress = false;

    private boolean dragInProgress = false;

    private long dragRootWindow = 0;

    /* The protocol chosen for the communication with the current drop target. */

    private XDragSourceProtocol dragProtocol = null;

    /* The drop action chosen by the current drop target. */

    private int targetAction = DnDConstants.ACTION_NONE;

    /* The set of drop actions supported by the drag source. */

    private int sourceActions = DnDConstants.ACTION_NONE;

    /* The drop action selected by the drag source based on the modifiers state

       and the action selected by the current drop target. */

    private int sourceAction = DnDConstants.ACTION_NONE;

    /* The data formats supported by the drag source for the current drag

       operation. */

    private long[] sourceFormats = null;

    /* The XID of the root subwindow that contains the current target. */

    private long targetRootSubwindow = 0;

    /* The pointer location. */

    private int xRoot = 0;

    private int yRoot = 0;

    /* Keyboard modifiers state. */

    private int eventState = 0;

    /* XEmbed DnD support. We act as a proxy between source and target. */

    private long proxyModeSourceWindow = 0;

    /* The singleton instance. */

    private static final XDragSourceContextPeer theInstance =

        new XDragSourceContextPeer(null);

    private XDragSourceContextPeer(DragGestureEvent dge) {

        super(dge);

    }

    static XDragSourceProtocolListener getXDragSourceProtocolListener() {

        return theInstance;

    }

    static XDragSourceContextPeer createDragSourceContextPeer(DragGestureEvent dge)

      throws InvalidDnDOperationException {

    theInstance.setTrigger(dge);

        return theInstance;

    }

    protected void startDrag(Transferable transferable,

                             long[] formats, Map formatMap) {

        Component component = getTrigger().getComponent();

        Component c = null;

        XWindowPeer wpeer = null;

        for (c = component; c != null && !(c instanceof Window);

             c = AWTAccessor.getComponentAccessor().getParent(c));

        if (c instanceof Window) {

            wpeer = (XWindowPeer)c.getPeer();

        }

        if (wpeer == null) {

            throw new InvalidDnDOperationException(

                "Cannot find top-level for the drag source component");

        }

        long xcursor = 0;

        long rootWindow = 0;

        long dragWindow = 0;

        long timeStamp = 0;

        /* Retrieve the X cursor for the drag operation. */

        {

            Cursor cursor = getCursor();

            if (cursor != null) {

                xcursor = XGlobalCursorManager.getCursor(cursor);

            }

        }

        XToolkit.awtLock();

        try {

            if (proxyModeSourceWindow != 0) {

                throw new InvalidDnDOperationException("Proxy drag in progress");

            }

            if (dndInProgress) {

                throw new InvalidDnDOperationException("Drag in progress");

            }

            /* Determine the root window for the drag operation. */

            {

                long screen = XlibWrapper.XScreenNumberOfScreen(wpeer.getScreen());

                rootWindow = XlibWrapper.RootWindow(XToolkit.getDisplay(), screen);

            }

            dragWindow = XWindow.getXAWTRootWindow().getWindow();

            timeStamp = XToolkit.getCurrentServerTime();

            int dropActions = getDragSourceContext().getSourceActions();

            Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();

            while (dragProtocols.hasNext()) {

                XDragSourceProtocol dragProtocol = (XDragSourceProtocol)dragProtocols.next();

                try {

                    dragProtocol.initializeDrag(dropActions, transferable,

                                                formatMap, formats);

                } catch (XException xe) {

                    throw (InvalidDnDOperationException)

                        new InvalidDnDOperationException().initCause(xe);

                }

            }

            /* Install X grabs. */

            {

                int status;

                XWindowAttributes wattr = new XWindowAttributes();

                try {

                    status = XlibWrapper.XGetWindowAttributes(XToolkit.getDisplay(),

                                                              rootWindow, wattr.pData);

                    if (status == 0) {

                        throw new InvalidDnDOperationException("XGetWindowAttributes failed");

                    }

                    rootEventMask = wattr.get_your_event_mask();

                    XlibWrapper.XSelectInput(XToolkit.getDisplay(), rootWindow,

                                             rootEventMask | ROOT_EVENT_MASK);

                } finally {

                    wattr.dispose();

                }

                XBaseWindow.ungrabInput();

                status = XlibWrapper.XGrabPointer(XToolkit.getDisplay(), rootWindow,

                                                  0, GRAB_EVENT_MASK,

                                                  XConstants.GrabModeAsync,

                                                  XConstants.GrabModeAsync,

                                                  XConstants.None, xcursor, timeStamp);

                if (status != XConstants.GrabSuccess) {

                    cleanup(timeStamp);

                    throwGrabFailureException("Cannot grab pointer", status);

                    return;

                }

                status = XlibWrapper.XGrabKeyboard(XToolkit.getDisplay(), rootWindow,

                                                   0,

                                                   XConstants.GrabModeAsync,

                                                   XConstants.GrabModeAsync,

                                                   timeStamp);

                if (status != XConstants.GrabSuccess) {

                    cleanup(timeStamp);

                    throwGrabFailureException("Cannot grab keyboard", status);

                    return;

                }

            }

            /* Update the global state. */

            dndInProgress = true;

            dragInProgress = true;

            dragRootWindow = rootWindow;

            sourceActions = dropActions;

            sourceFormats = formats;

        } finally {

            XToolkit.awtUnlock();

        }

        /* This implementation doesn't use native context */

        setNativeContext(0);

        SunDropTargetContextPeer.setCurrentJVMLocalSourceTransferable(transferable);

    }

    public long getProxyModeSourceWindow() {

        return proxyModeSourceWindow;

    }

    private void setProxyModeSourceWindowImpl(long window) {

        proxyModeSourceWindow = window;

    }

    public static void setProxyModeSourceWindow(long window) {

        theInstance.setProxyModeSourceWindowImpl(window);

    }

    /**

     * set cursor

     */

    public void setCursor(Cursor c) throws InvalidDnDOperationException {

        XToolkit.awtLock();

        try {

            super.setCursor(c);

        } finally {

            XToolkit.awtUnlock();

        }

    }

    protected void setNativeCursor(long nativeCtxt, Cursor c, int cType) {

        assert XToolkit.isAWTLockHeldByCurrentThread();

        if (c == null) {

            return;

        }

        long xcursor = XGlobalCursorManager.getCursor(c);

        if (xcursor == 0) {

            return;

        }

        XlibWrapper.XChangeActivePointerGrab(XToolkit.getDisplay(),

                                             GRAB_EVENT_MASK,

                                             xcursor,

                                             XConstants.CurrentTime);

    }

    protected boolean needsBogusExitBeforeDrop() {

        return false;

    }

    private void throwGrabFailureException(String msg, int grabStatus)

      throws InvalidDnDOperationException {

        String msgCause = "";

        switch (grabStatus) {

        case XConstants.GrabNotViewable:  msgCause = "not viewable";    break;

        case XConstants.AlreadyGrabbed:   msgCause = "already grabbed"; break;

        case XConstants.GrabInvalidTime:  msgCause = "invalid time";    break;

        case XConstants.GrabFrozen:       msgCause = "grab frozen";     break;

        default:                           msgCause = "unknown failure"; break;

        }

        throw new InvalidDnDOperationException(msg + ": " + msgCause);

    }

    /**

     * The caller must own awtLock.

     */

    public void cleanup(long time) {

        if (dndInProgress) {

            if (dragProtocol != null) {

                dragProtocol.sendLeaveMessage(time);

            }

            if (targetAction != DnDConstants.ACTION_NONE) {

                dragExit(xRoot, yRoot);

            }

            dragDropFinished(false, DnDConstants.ACTION_NONE, xRoot, yRoot);

        }

        Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();

        while (dragProtocols.hasNext()) {

            XDragSourceProtocol dragProtocol = (XDragSourceProtocol)dragProtocols.next();

            try {

                dragProtocol.cleanup();

            } catch (XException xe) {

                // Ignore the exception.

            }

        }

        dndInProgress = false;

        dragInProgress = false;

        dragRootWindow = 0;

        sourceFormats = null;

        sourceActions = DnDConstants.ACTION_NONE;

        sourceAction = DnDConstants.ACTION_NONE;

        eventState = 0;

        xRoot = 0;

        yRoot = 0;

        cleanupTargetInfo();

        removeDnDGrab(time);

    }

    /**

     * The caller must own awtLock.

     */

    private void cleanupTargetInfo() {

        targetAction = DnDConstants.ACTION_NONE;

        dragProtocol = null;

        targetRootSubwindow = 0;

    }

    private void removeDnDGrab(long time) {

        assert XToolkit.isAWTLockHeldByCurrentThread();

        XlibWrapper.XUngrabPointer(XToolkit.getDisplay(), time);

        XlibWrapper.XUngrabKeyboard(XToolkit.getDisplay(), time);

        /* Restore the root event mask if it was changed. */

        if ((rootEventMask | ROOT_EVENT_MASK) != rootEventMask &&

            dragRootWindow != 0) {

            XlibWrapper.XSelectInput(XToolkit.getDisplay(),

                                     dragRootWindow,

                                     rootEventMask);

        }

        rootEventMask = 0;

        dragRootWindow = 0;

    }

    private boolean processClientMessage(XClientMessageEvent xclient) {

        if (dragProtocol != null) {

            return dragProtocol.processClientMessage(xclient);

        }

        return false;

    }

    /**

     * Updates the source action according to the specified state.

     *

     * @returns true if the source

     */

    private boolean updateSourceAction(int state) {

        int action = SunDragSourceContextPeer.convertModifiersToDropAction(XWindow.getModifiers(state, 0, 0),

                                                                           sourceActions);

        if (sourceAction == action) {

            return false;

        }

        sourceAction = action;

        return true;

    }

    /**

     * Returns the client window under the specified root subwindow.

     */

    private static long findClientWindow(long window) {

        if (XlibUtil.isTrueToplevelWindow(window)) {

            return window;

        }

        Set<Long> children = XlibUtil.getChildWindows(window);

        for (Long child : children) {

            long win = findClientWindow(child);

            if (win != 0) {

                return win;

            }

        }

        return 0;

    }

    private void doUpdateTargetWindow(long subwindow, long time) {

        long clientWindow = 0;

        long proxyWindow = 0;

        XDragSourceProtocol protocol = null;

        boolean isReceiver = false;

        if (subwindow != 0) {

            clientWindow = findClientWindow(subwindow);

        }

        if (clientWindow != 0) {

            Iterator dragProtocols = XDragAndDropProtocols.getDragSourceProtocols();

            while (dragProtocols.hasNext()) {

                XDragSourceProtocol dragProtocol = (XDragSourceProtocol)dragProtocols.next();

                if (dragProtocol.attachTargetWindow(clientWindow, time)) {

                    protocol = dragProtocol;

                    break;

                }

            }

        }

        /* Update the global state. */

        dragProtocol = protocol;

        targetAction = DnDConstants.ACTION_NONE;

        targetRootSubwindow = subwindow;

    }

    private void updateTargetWindow(XMotionEvent xmotion) {

        assert XToolkit.isAWTLockHeldByCurrentThread();

        int x = xmotion.get_x_root();

        int y = xmotion.get_y_root();

        long time = xmotion.get_time();

        long subwindow = xmotion.get_subwindow();

        /*

         * If this event had occurred before the pointer was grabbed,

         * query the server for the current root subwindow.

         */

        if (xmotion.get_window() != xmotion.get_root()) {

            XlibWrapper.XQueryPointer(XToolkit.getDisplay(),

                                      xmotion.get_root(),

                                      XlibWrapper.larg1,  // root

                                      XlibWrapper.larg2,  // subwindow

                                      XlibWrapper.larg3,  // x_root

                                      XlibWrapper.larg4,  // y_root

                                      XlibWrapper.larg5,  // x

                                      XlibWrapper.larg6,  // y

                                      XlibWrapper.larg7); // modifiers

            subwindow = Native.getLong(XlibWrapper.larg2);

        }

        if (targetRootSubwindow != subwindow) {

            if (dragProtocol != null) {

                dragProtocol.sendLeaveMessage(time);

                /*

                 * Neither Motif DnD nor XDnD provide a mean for the target

                 * to notify the source that the pointer exits the drop site

                 * that occupies the whole top level.

                 * We detect this situation and post dragExit.

                 */

                if (targetAction != DnDConstants.ACTION_NONE) {

                    dragExit(x, y);

                }

            }

            /* Update the global state. */

            doUpdateTargetWindow(subwindow, time);

            if (dragProtocol != null) {

                dragProtocol.sendEnterMessage(sourceFormats,

                                              sourceAction,

                                              sourceActions,

                                              time);

            }

        }

    }

    /*

     * DO NOT USE is_hint field of xmotion since it could not be set when we

     * convert XKeyEvent or XButtonRelease to XMotionEvent.

     */

    private void processMouseMove(XMotionEvent xmotion) {

        if (!dragInProgress) {

            return;

        }

        if (xRoot != xmotion.get_x_root() || yRoot != xmotion.get_y_root()) {

            xRoot = xmotion.get_x_root();

            yRoot = xmotion.get_y_root();

            postDragSourceDragEvent(targetAction,

                                    XWindow.getModifiers(xmotion.get_state(),0,0),

                                    xRoot, yRoot, DISPATCH_MOUSE_MOVED);

        }

        if (eventState != xmotion.get_state()) {

            if (updateSourceAction(xmotion.get_state()) && dragProtocol != null) {

                postDragSourceDragEvent(targetAction,

                                        XWindow.getModifiers(xmotion.get_state(),0,0),

                                        xRoot, yRoot, DISPATCH_CHANGED);

            }

            eventState = xmotion.get_state();

        }

        updateTargetWindow(xmotion);

        if (dragProtocol != null) {

            dragProtocol.sendMoveMessage(xmotion.get_x_root(),

                                         xmotion.get_y_root(),

                                         sourceAction, sourceActions,

                                         xmotion.get_time());

        }

    }