/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qplatformdefs.h"

#include "qapplication.h"

#ifndef QT_NO_DRAGANDDROP

#include "qwidget.h"

#include "qpainter.h"

#include "qpixmap.h"

#include "qbitmap.h"

#include "qdesktopwidget.h"

#include "qevent.h"

#include "qdatetime.h"

#include "qiodevice.h"

#include "qpointer.h"

#include "qcursor.h"

#include "qvariant.h"

#include "qvector.h"

#include "qurl.h"

#include "qdebug.h"

#include "qimagewriter.h"

#include "qbuffer.h"

#include "qtextcodec.h"

#include "qdnd_p.h"

#include "qt_x11_p.h"

#include "qx11info_x11.h"

#include "qwidget_p.h"

#include "qcursor_p.h"

QT_BEGIN_NAMESPACE

// #define DND_DEBUG

#ifdef DND_DEBUG

#define DEBUG qDebug

#else

#define DEBUG if(0) qDebug

#endif

#ifdef DND_DEBUG

#define DNDDEBUG qDebug()

#else

#define DNDDEBUG if(0) qDebug()

#endif

static int findXdndDropTransactionByWindow(Window window)

{

    int at = -1;

    for (int i = 0; i < X11->dndDropTransactions.count(); ++i) {

        const QXdndDropTransaction &t = X11->dndDropTransactions.at(i);

        if (t.target == window || t.proxy_target == window) {

            at = i;

            break;

        }

    }

    return at;

}

static int findXdndDropTransactionByTime(Time timestamp)

{

    int at = -1;

    for (int i = 0; i < X11->dndDropTransactions.count(); ++i) {

        const QXdndDropTransaction &t = X11->dndDropTransactions.at(i);

        if (t.timestamp == timestamp) {

            at = i;

            break;

        }

    }

    return at;

}

// timer used to discard old XdndDrop transactions

static int transaction_expiry_timer = -1;

enum { XdndDropTransactionTimeout = 5000 }; // 5 seconds

static void restartXdndDropExpiryTimer()

{

    if (transaction_expiry_timer != -1)

        QDragManager::self()->killTimer(transaction_expiry_timer);

    transaction_expiry_timer = QDragManager::self()->startTimer(XdndDropTransactionTimeout);

}

// find an ancestor with XdndAware on it

static Window findXdndAwareParent(Window window)

{

    Window target = 0;

    forever {

        // check if window has XdndAware

        Atom type = 0;

        int f;

        unsigned long n, a;

        unsigned char *data = 0;

        if (XGetWindowProperty(X11->display, window, ATOM(XdndAware), 0, 0, False,

                               AnyPropertyType, &type, &f,&n,&a,&data) == Success) {

	    if (data)

                XFree(data);

	    if (type) {

                target = window;

                break;

            }

        }

        // try window's parent

        Window root;

        Window parent;

        Window *children;

        uint unused;

        if (!XQueryTree(X11->display, window, &root, &parent, &children, &unused))

            break;

        if (children)

            XFree(children);

        if (window == root)

            break;

        window = parent;

    }

    return target;

}

// and all this stuff is copied -into- qapp_x11.cpp

static void handle_xdnd_position(QWidget *, const XEvent *, bool);

static void handle_xdnd_status(QWidget * w, const XEvent * xe, bool /*passive*/);

const int xdnd_version = 5;

static Qt::DropAction xdndaction_to_qtaction(Atom atom)

{

    if (atom == ATOM(XdndActionCopy) || atom == 0)

        return Qt::CopyAction;

    if (atom == ATOM(XdndActionLink))

        return Qt::LinkAction;

    if (atom == ATOM(XdndActionMove))

        return Qt::MoveAction;

    return Qt::CopyAction;

}

static int qtaction_to_xdndaction(Qt::DropAction a)

{

    switch (a) {

    case Qt::CopyAction:

        return ATOM(XdndActionCopy);

    case Qt::LinkAction:

        return ATOM(XdndActionLink);

    case Qt::MoveAction:

    case Qt::TargetMoveAction:

        return ATOM(XdndActionMove);

    case Qt::IgnoreAction:

        return XNone;

    default:

        return ATOM(XdndActionCopy);

    }

}

// clean up the stuff used.

static void qt_xdnd_cleanup();

static void qt_xdnd_send_leave();

// real variables:

// xid of current drag source

static Atom qt_xdnd_dragsource_xid = 0;

// the types in this drop. 100 is no good, but at least it's big.

const int qt_xdnd_max_type = 100;

static Atom qt_xdnd_types[qt_xdnd_max_type + 1];

// timer used when target wants "continuous" move messages (eg. scroll)

static int heartbeat = -1;

// rectangle in which the answer will be the same

static QRect qt_xdnd_source_sameanswer;

// top-level window we sent position to last.

static Window qt_xdnd_current_target;

// window to send events to (always valid if qt_xdnd_current_target)

static Window qt_xdnd_current_proxy_target;

static Time qt_xdnd_source_current_time;

// widget we forwarded position to last, and local position

static QPointer<QWidget> qt_xdnd_current_widget;

static QPoint qt_xdnd_current_position;

// timestamp from the XdndPosition and XdndDrop

static Time qt_xdnd_target_current_time;

// screen number containing the pointer... -1 means default

static int qt_xdnd_current_screen = -1;

// state of dragging... true if dragging, false if not

bool qt_xdnd_dragging = false;

static bool waiting_for_status = false;

// used to preset each new QDragMoveEvent

static Qt::DropAction last_target_accepted_action = Qt::IgnoreAction;

// Shift/Ctrl handling, and final drop status

static Qt::DropAction global_accepted_action = Qt::CopyAction;

static Qt::DropActions possible_actions = Qt::IgnoreAction;

// for embedding only

static QWidget* current_embedding_widget  = 0;

static XEvent last_enter_event;

// cursors

static QCursor *noDropCursor = 0;

static QCursor *moveCursor = 0;

static QCursor *copyCursor = 0;

static QCursor *linkCursor = 0;

static QPixmap *defaultPm = 0;

static const int default_pm_hotx = -2;

static const int default_pm_hoty = -16;

static const char* const default_pm[] = {

"13 9 3 1",

".      c None",

"       c #000000",

"X      c #FFFFFF",

"X X X X X X X",

" X X X X X X ",

"X ......... X",

" X.........X ",

"X ......... X",

" X.........X ",

"X ......... X",

" X X X X X X ",

"X X X X X X X"

};

class QShapedPixmapWidget : public QWidget

{

    Q_OBJECT

public:

    QShapedPixmapWidget(QWidget* w) :

        QWidget(w,

                Qt::Tool | Qt::FramelessWindowHint

                | Qt::X11BypassWindowManagerHint

                | Qt::BypassGraphicsProxyWidget)

    {

        setAttribute(Qt::WA_X11NetWmWindowTypeDND);

    }

    void setPixmap(const QPixmap &pm)

    {

        QBitmap mask = pm.mask();

        if (!mask.isNull()) {

            setMask(mask);

        } else {

            clearMask();

        }

        resize(pm.width(),pm.height());

        pixmap = pm;

        update();

    }

    QPoint pm_hot;

protected:

    QPixmap pixmap;

    void paintEvent(QPaintEvent*)

    {

        QPainter p(this);

        p.drawPixmap(0, 0, pixmap);

    }

};

#include "qdnd_x11.moc"

struct XdndData {

    QShapedPixmapWidget *deco;

    QWidget* desktop_proxy;

};

static XdndData xdnd_data = { 0, 0 };

class QExtraWidget : public QWidget

{

    Q_DECLARE_PRIVATE(QWidget)

public:

    inline QWExtra* extraData();

    inline QTLWExtra* topData();

};

inline QWExtra* QExtraWidget::extraData() { return d_func()->extraData(); }

inline QTLWExtra* QExtraWidget::topData() { return d_func()->topData(); }

static WId xdndProxy(WId w)

{

    Atom type = XNone;

    int f;

    unsigned long n, a;

    unsigned char *retval = 0;

    XGetWindowProperty(X11->display, w, ATOM(XdndProxy), 0, 1, False,

                       XA_WINDOW, &type, &f,&n,&a,&retval);

    WId *proxy_id_ptr = (WId *)retval;

    WId proxy_id = 0;

    if (type == XA_WINDOW && proxy_id_ptr) {

        proxy_id = *proxy_id_ptr;

        XFree(proxy_id_ptr);

        proxy_id_ptr = 0;

        // Already exists. Real?

        X11->ignoreBadwindow();

        XGetWindowProperty(X11->display, proxy_id, ATOM(XdndProxy), 0, 1, False,

                           XA_WINDOW, &type, &f,&n,&a,&retval);

        proxy_id_ptr = (WId *)retval;

        if (X11->badwindow() || type != XA_WINDOW || !proxy_id_ptr || *proxy_id_ptr != proxy_id)

            // Bogus - we will overwrite.

            proxy_id = 0;

    }

    if (proxy_id_ptr)

        XFree(proxy_id_ptr);

    return proxy_id;

}

static bool xdndEnable(QWidget* w, bool on)

{

    DNDDEBUG << "xdndEnable" << w << on;

    if (on) {

        QWidget * xdnd_widget = 0;

        if ((w->windowType() == Qt::Desktop)) {

            if (xdnd_data.desktop_proxy) // *WE* already have one.

                return false;

            // As per Xdnd4, use XdndProxy

            XGrabServer(X11->display);

            Q_ASSERT(w->testAttribute(Qt::WA_WState_Created));

            WId proxy_id = xdndProxy(w->effectiveWinId());

            if (!proxy_id) {

                xdnd_widget = xdnd_data.desktop_proxy = new QWidget;

                proxy_id = xdnd_data.desktop_proxy->effectiveWinId();

                XChangeProperty (X11->display, w->effectiveWinId(), ATOM(XdndProxy),

                                 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&proxy_id, 1);

                XChangeProperty (X11->display, proxy_id, ATOM(XdndProxy),

                                 XA_WINDOW, 32, PropModeReplace, (unsigned char *)&proxy_id, 1);

            }

            XUngrabServer(X11->display);

        } else {

            xdnd_widget = w->window();

        }

        if (xdnd_widget) {

            DNDDEBUG << "setting XdndAware for" << xdnd_widget << xdnd_widget->effectiveWinId();

            Atom atm = (Atom)xdnd_version;

            Q_ASSERT(xdnd_widget->testAttribute(Qt::WA_WState_Created));

            XChangeProperty(X11->display, xdnd_widget->effectiveWinId(), ATOM(XdndAware),

                             XA_ATOM, 32, PropModeReplace, (unsigned char *)&atm, 1);

            return true;

        } else {

            return false;

        }

    } else {

        if ((w->windowType() == Qt::Desktop)) {

            XDeleteProperty(X11->display, w->internalWinId(), ATOM(XdndProxy));

            delete xdnd_data.desktop_proxy;

            xdnd_data.desktop_proxy = 0;

        } else {

            DNDDEBUG << "not deleting XDndAware";

        }

        return true;

    }

}

QByteArray QX11Data::xdndAtomToString(Atom a)

{

    if (!a) return 0;

    if (a == XA_STRING || a == ATOM(UTF8_STRING)) {

        return "text/plain"; // some Xdnd clients are dumb

    }

    char *atom = XGetAtomName(display, a);

    QByteArray result = atom;

    XFree(atom);

    return result;

}

Atom QX11Data::xdndStringToAtom(const char *mimeType)

{

    if (!mimeType || !*mimeType)

        return 0;

    return XInternAtom(display, mimeType, False);

}

//$$$

QString QX11Data::xdndMimeAtomToString(Atom a)

{

    QString atomName;

    if (a) {

        char *atom = XGetAtomName(display, a);

        atomName = QString::fromLatin1(atom);

        XFree(atom);

    }

    return atomName;

}

//$$$

Atom QX11Data::xdndMimeStringToAtom(const QString &mimeType)

{

    if (mimeType.isEmpty())

        return 0;

    return XInternAtom(display, mimeType.toLatin1().constData(), False);

}

//$$$ replace ccxdndAtomToString()

QStringList QX11Data::xdndMimeFormatsForAtom(Atom a)

{

    QStringList formats;

    if (a) {

        QString atomName = xdndMimeAtomToString(a);

        formats.append(atomName);

        // special cases for string type

        if (a == ATOM(UTF8_STRING) || a == XA_STRING

            || a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT))

            formats.append(QLatin1String("text/plain"));

        // special cases for uris

        if (atomName == QLatin1String("text/x-moz-url"))

            formats.append(QLatin1String("text/uri-list"));

        // special case for images

        if (a == XA_PIXMAP)

            formats.append(QLatin1String("image/ppm"));

    }

    return formats;

}

//$$$

bool QX11Data::xdndMimeDataForAtom(Atom a, QMimeData *mimeData, QByteArray *data, Atom *atomFormat, int *dataFormat)

{

    bool ret = false;

    *atomFormat = a;

    *dataFormat = 8;

    QString atomName = xdndMimeAtomToString(a);

    if (QInternalMimeData::hasFormatHelper(atomName, mimeData)) {

        *data = QInternalMimeData::renderDataHelper(atomName, mimeData);

        if (atomName == QLatin1String("application/x-color"))

            *dataFormat = 16;

        ret = true;

    } else {

        if ((a == ATOM(UTF8_STRING) || a == XA_STRING

             || a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT))

            && QInternalMimeData::hasFormatHelper(QLatin1String("text/plain"), mimeData)) {

            if (a == ATOM(UTF8_STRING)){

                *data = QInternalMimeData::renderDataHelper(QLatin1String("text/plain"), mimeData);

                ret = true;

            } else if (a == XA_STRING) {

                *data = QString::fromUtf8(QInternalMimeData::renderDataHelper(

                        QLatin1String("text/plain"), mimeData)).toLocal8Bit();

                ret = true;

            } else if (a == ATOM(TEXT) || a == ATOM(COMPOUND_TEXT)) {

                // the ICCCM states that TEXT and COMPOUND_TEXT are in the

                // encoding of choice, so we choose the encoding of the locale

                QByteArray strData = QString::fromUtf8(QInternalMimeData::renderDataHelper(

                                     QLatin1String("text/plain"), mimeData)).toLocal8Bit();

                char *list[] = { strData.data(), NULL };

                XICCEncodingStyle style = (a == ATOM(COMPOUND_TEXT))

                                        ? XCompoundTextStyle : XStdICCTextStyle;

                XTextProperty textprop;

                if (list[0] != NULL

                    && XmbTextListToTextProperty(X11->display, list, 1, style,

                                                 &textprop) == Success) {

                    *atomFormat = textprop.encoding;

                    *dataFormat = textprop.format;

                    *data = QByteArray((const char *) textprop.value, textprop.nitems * textprop.format / 8);

                    ret = true;

                    DEBUG("    textprop type %lx\n"

                    "    textprop name '%s'\n"

                    "    format %d\n"

                    "    %ld items\n"

                    "    %d bytes\n",

                    textprop.encoding,

                    X11->xdndMimeAtomToString(textprop.encoding).toLatin1().data(),

                    textprop.format, textprop.nitems, data->size());

                    XFree(textprop.value);

                }

            }

        } else if (atomName == QLatin1String("text/x-moz-url") &&

                   QInternalMimeData::hasFormatHelper(QLatin1String("text/uri-list"), mimeData)) {

            QByteArray uri = QInternalMimeData::renderDataHelper(

                             QLatin1String("text/uri-list"), mimeData).split('\n').first();

            QString mozUri = QString::fromLatin1(uri, uri.size());

            mozUri += QLatin1Char('\n');

            *data = QByteArray(reinterpret_cast<const char *>(mozUri.utf16()), mozUri.length() * 2);