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

**

** Copyright (C) 2009 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$

**

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

// #define QCLIPBOARD_DEBUG

// #define QCLIPBOARD_DEBUG_VERBOSE

#ifdef QCLIPBOARD_DEBUG

#  define DEBUG qDebug

#else

#  define DEBUG if (false) qDebug

#endif

#ifdef QCLIPBOARD_DEBUG_VERBOSE

#  define VDEBUG qDebug

#else

#  define VDEBUG if (false) qDebug

#endif

#include "qplatformdefs.h"

#include "qclipboard.h"

#include "qclipboard_p.h"

#ifndef QT_NO_CLIPBOARD

#include "qabstracteventdispatcher.h"

#include "qapplication.h"

#include "qdesktopwidget.h"

#include "qbitmap.h"

#include "qdatetime.h"

#include "qiodevice.h"

#include "qbuffer.h"

#include "qtextcodec.h"

#include "qlist.h"

#include "qmap.h"

#include "qapplication_p.h"

#include "qevent.h"

#include "qt_x11_p.h"

#include "qx11info_x11.h"

#include "qimagewriter.h"

#include "qvariant.h"

#include "qdnd_p.h"

#ifndef QT_NO_XFIXES

#include <X11/extensions/Xfixes.h>

#endif // QT_NO_XFIXES

QT_BEGIN_NAMESPACE

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

  Internal QClipboard functions for X11.

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

static int clipboard_timeout = 5000; // 5s timeout on clipboard operations

static QWidget * owner = 0;

static QWidget *requestor = 0;

static bool timer_event_clear = false;

static int timer_id = 0;

static int pending_timer_id = 0;

static bool pending_clipboard_changed = false;

static bool pending_selection_changed = false;

// event capture mechanism for qt_xclb_wait_for_event

static bool waiting_for_data = false;

static bool has_captured_event = false;

static Window capture_event_win = XNone;

static int capture_event_type = -1;

static XEvent captured_event;

class QClipboardWatcher; // forward decl

static QClipboardWatcher *selection_watcher = 0;

static QClipboardWatcher *clipboard_watcher = 0;

static void cleanup()

{

    delete owner;

    delete requestor;

    owner = 0;

    requestor = 0;

}

static

void setupOwner()

{

    if (owner)

        return;

    owner = new QWidget(0);

    owner->setObjectName(QLatin1String("internal clipboard owner"));

    owner->createWinId();

    requestor = new QWidget(0);

    requestor->createWinId();

    requestor->setObjectName(QLatin1String("internal clipboard requestor"));

    qAddPostRoutine(cleanup);

}

class QClipboardWatcher : public QInternalMimeData {

public:

    QClipboardWatcher(QClipboard::Mode mode);

    ~QClipboardWatcher();

    bool empty() const;

    virtual bool hasFormat_sys(const QString &mimetype) const;

    virtual QStringList formats_sys() const;

    QVariant retrieveData_sys(const QString &mimetype, QVariant::Type type) const;

    QByteArray getDataInFormat(Atom fmtatom) const;

    Atom atom;

    mutable QStringList formatList;

    mutable QByteArray format_atoms;

};

class QClipboardData

{

private:

    QMimeData *&mimeDataRef() const

    {

        if(mode == QClipboard::Selection)

            return selectionData;

        return clipboardData;

    }

public:

    QClipboardData(QClipboard::Mode mode);

    ~QClipboardData();

    void setSource(QMimeData* s)

    {

        if ((mode == QClipboard::Selection && selectionData == s)

            || clipboardData == s) {

            return;

        }

        if (selectionData != clipboardData) {

            delete mimeDataRef();

        }

        mimeDataRef() = s;

    }

    QMimeData *source() const

    {

        return mimeDataRef();

    }

    void clear()

    {

        timestamp = CurrentTime;

        if (selectionData == clipboardData) {

            mimeDataRef() = 0;

        } else {

            QMimeData *&src = mimeDataRef();

            delete src;

            src = 0;

        }

    }

    static QMimeData *selectionData;

    static QMimeData *clipboardData;

    Time timestamp;

    QClipboard::Mode mode;

};

QMimeData *QClipboardData::selectionData = 0;

QMimeData *QClipboardData::clipboardData = 0;

QClipboardData::QClipboardData(QClipboard::Mode clipboardMode)

{

    timestamp = CurrentTime;

    mode = clipboardMode;

}

QClipboardData::~QClipboardData()

{ clear(); }

static QClipboardData *internalCbData = 0;

static QClipboardData *internalSelData = 0;

static void cleanupClipboardData()

{

    delete internalCbData;

    internalCbData = 0;

}

static QClipboardData *clipboardData()

{

    if (internalCbData == 0) {

        internalCbData = new QClipboardData(QClipboard::Clipboard);

        qAddPostRoutine(cleanupClipboardData);

    }

    return internalCbData;

}

static void cleanupSelectionData()

{

    delete internalSelData;

    internalSelData = 0;

}

static QClipboardData *selectionData()

{

    if (internalSelData == 0) {

        internalSelData = new QClipboardData(QClipboard::Selection);

        qAddPostRoutine(cleanupSelectionData);

    }

    return internalSelData;

}

class QClipboardINCRTransaction

{

public:

    QClipboardINCRTransaction(Window w, Atom p, Atom t, int f, QByteArray d, unsigned int i);

    ~QClipboardINCRTransaction(void);

    int x11Event(XEvent *event);

    Window window;

    Atom property, target;

    int format;

    QByteArray data;

    unsigned int increment;

    unsigned int offset;

};

typedef QMap<Window,QClipboardINCRTransaction*> TransactionMap;

static TransactionMap *transactions = 0;

static QApplication::EventFilter prev_event_filter = 0;

static int incr_timer_id = 0;

static bool qt_x11_incr_event_filter(void *message, long *result)

{

    XEvent *event = reinterpret_cast<XEvent *>(message);

    TransactionMap::Iterator it = transactions->find(event->xany.window);

    if (it != transactions->end()) {

        if ((*it)->x11Event(event) != 0)

            return true;

    }

    if (prev_event_filter)

        return prev_event_filter(event, result);

    return false;

}

/*

  called when no INCR activity has happened for 'clipboard_timeout'

  milliseconds... we assume that all unfinished transactions have

  timed out and remove everything from the transaction map

*/

static void qt_xclb_incr_timeout(void)

{

    qWarning("QClipboard: Timed out while sending data");

    while (transactions)

        delete *transactions->begin();

}

QClipboardINCRTransaction::QClipboardINCRTransaction(Window w, Atom p, Atom t, int f,

                                                     QByteArray d, unsigned int i)

    : window(w), property(p), target(t), format(f), data(d), increment(i), offset(0u)

{

    DEBUG("QClipboard: sending %d bytes (INCR transaction %p)", d.size(), this);

    XSelectInput(X11->display, window, PropertyChangeMask);

    if (! transactions) {

        VDEBUG("QClipboard: created INCR transaction map");

        transactions = new TransactionMap;

        prev_event_filter = qApp->setEventFilter(qt_x11_incr_event_filter);

        incr_timer_id = QApplication::clipboard()->startTimer(clipboard_timeout);

    }

    transactions->insert(window, this);

}

QClipboardINCRTransaction::~QClipboardINCRTransaction(void)

{

    VDEBUG("QClipboard: destroyed INCR transacton %p", this);

    XSelectInput(X11->display, window, NoEventMask);

    transactions->remove(window);

    if (transactions->isEmpty()) {

        VDEBUG("QClipboard: no more INCR transactions");

        delete transactions;

        transactions = 0;

        (void)qApp->setEventFilter(prev_event_filter);

        if (incr_timer_id != 0) {

            QApplication::clipboard()->killTimer(incr_timer_id);

            incr_timer_id = 0;

        }

    }

}

int QClipboardINCRTransaction::x11Event(XEvent *event)

{

    if (event->type != PropertyNotify

        || (event->xproperty.state != PropertyDelete

            || event->xproperty.atom != property))

        return 0;

    // restart the INCR timer

    if (incr_timer_id) QApplication::clipboard()->killTimer(incr_timer_id);

    incr_timer_id = QApplication::clipboard()->startTimer(clipboard_timeout);

    unsigned int bytes_left = data.size() - offset;

    if (bytes_left > 0) {

        unsigned int xfer = qMin(increment, bytes_left);

        VDEBUG("QClipboard: sending %d bytes, %d remaining (INCR transaction %p)",

               xfer, bytes_left - xfer, this);

        XChangeProperty(X11->display, window, property, target, format,

                        PropModeReplace, (uchar *) data.data() + offset, xfer);

        offset += xfer;

    } else {

        // INCR transaction finished...

        XChangeProperty(X11->display, window, property, target, format,

                        PropModeReplace, (uchar *) data.data(), 0);

        delete this;

    }

    return 1;

}

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

  QClipboard member functions for X11.

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

struct qt_init_timestamp_data

{

    Time timestamp;

};

#if defined(Q_C_CALLBACKS)

extern "C" {

#endif

static Bool qt_init_timestamp_scanner(Display*, XEvent *event, XPointer arg)

{

    qt_init_timestamp_data *data =

        reinterpret_cast<qt_init_timestamp_data*>(arg);

    switch(event->type)

    {

    case ButtonPress:

    case ButtonRelease:

        data->timestamp = event->xbutton.time;

        break;

    case MotionNotify:

        data->timestamp = event->xmotion.time;

        break;

    case XKeyPress:

    case XKeyRelease:

        data->timestamp = event->xkey.time;

        break;

    case PropertyNotify:

        data->timestamp = event->xproperty.time;

        break;

    case EnterNotify:

    case LeaveNotify:

        data->timestamp = event->xcrossing.time;

        break;

    case SelectionClear:

        data->timestamp = event->xselectionclear.time;

        break;

    default:

        break;

    }

#ifndef QT_NO_XFIXES

    if (X11->use_xfixes && event->type == (X11->xfixes_eventbase + XFixesSelectionNotify)) {

        XFixesSelectionNotifyEvent *req =

            reinterpret_cast<XFixesSelectionNotifyEvent *>(event);

        data->timestamp = req->selection_timestamp;

    }

#endif

    return false;

}

#if defined(Q_C_CALLBACKS)

}

#endif

QClipboard::QClipboard(QObject *parent)

    : QObject(*new QClipboardPrivate, parent)

{

    // create desktop widget since we need it to get PropertyNotify or

    // XFixesSelectionNotify events when someone changes the

    // clipboard.

    (void)QApplication::desktop();

#ifndef QT_NO_XFIXES

    if (X11->use_xfixes && X11->ptrXFixesSelectSelectionInput) {

        const unsigned long eventMask =

            XFixesSetSelectionOwnerNotifyMask | XFixesSelectionWindowDestroyNotifyMask | XFixesSelectionClientCloseNotifyMask;

        for (int i = 0; i < X11->screenCount; ++i) {

            X11->ptrXFixesSelectSelectionInput(X11->display, QX11Info::appRootWindow(i),

                                               XA_PRIMARY, eventMask);

            X11->ptrXFixesSelectSelectionInput(X11->display, QX11Info::appRootWindow(i),

                                               ATOM(CLIPBOARD), eventMask);

        }

    }

#endif // QT_NO_XFIXES

    if (X11->time == CurrentTime) {

        // send a dummy event to myself to get the timestamp from X11.

        qt_init_timestamp_data data;

        data.timestamp = CurrentTime;

        XEvent ev;

        XCheckIfEvent(X11->display, &ev, &qt_init_timestamp_scanner, (XPointer)&data);

        if (data.timestamp == CurrentTime) {

            setupOwner();

            int dummy = 0;

            Window ownerId = owner->internalWinId();

            XChangeProperty(X11->display, ownerId,

                            ATOM(CLIP_TEMPORARY), XA_INTEGER, 32,

                            PropModeReplace, (uchar*)&dummy, 1);

            XWindowEvent(X11->display, ownerId, PropertyChangeMask, &ev);

            data.timestamp = ev.xproperty.time;

            XDeleteProperty(X11->display, ownerId, ATOM(CLIP_TEMPORARY));

        }

        X11->time = data.timestamp;

    }

}

void QClipboard::clear(Mode mode)

{

    setMimeData(0, mode);

}

bool QClipboard::supportsMode(Mode mode) const

{

    return (mode == Clipboard || mode == Selection);

}

bool QClipboard::ownsMode(Mode mode) const

{

    if (mode == Clipboard)

        return clipboardData()->timestamp != CurrentTime;

    else if(mode == Selection)

        return selectionData()->timestamp != CurrentTime;

    else

        return false;

}

// event filter function... captures interesting events while

// qt_xclb_wait_for_event is running the event loop

static bool qt_x11_clipboard_event_filter(void *message, long *)

{

    XEvent *event = reinterpret_cast<XEvent *>(message);

    if (event->xany.type == capture_event_type &&

        event->xany.window == capture_event_win) {

        VDEBUG("QClipboard: event_filter(): caught event type %d", event->type);

        has_captured_event = true;

        captured_event = *event;

        return true;

    }

    return false;

}

static Bool checkForClipboardEvents(Display *, XEvent *e, XPointer)

{

    return ((e->type == SelectionRequest && (e->xselectionrequest.selection == XA_PRIMARY

                                             || e->xselectionrequest.selection == ATOM(CLIPBOARD)))

            || (e->type == SelectionClear && (e->xselectionclear.selection == XA_PRIMARY

                                              || e->xselectionclear.selection == ATOM(CLIPBOARD))));

}

bool QX11Data::clipboardWaitForEvent(Window win, int type, XEvent *event, int timeout)

{

    QTime started = QTime::currentTime();

    QTime now = started;

    if (QAbstractEventDispatcher::instance()->inherits("QtMotif")

        || QApplication::clipboard()->property("useEventLoopWhenWaiting").toBool()) {

        if (waiting_for_data) {

            Q_ASSERT(!"QClipboard: internal error, qt_xclb_wait_for_event recursed");

            return false;

        }

        waiting_for_data = true;

        has_captured_event = false;

        capture_event_win = win;

        capture_event_type = type;