source: trunk/src/gui/kernel/qclipboard_pm.cpp@ 473

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information ([email protected])
**
** Copyright (C) 2009 netlabs.org. OS/2 parts.
**
** This file is part of the QtGui module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** 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.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "qclipboard.h"

#ifndef QT_NO_CLIPBOARD

#include "qapplication.h"
#include "qapplication_p.h"
#include "qeventloop.h"
#include "qwidget.h"
#include "qevent.h"
#include "qmime.h"
#include "qdnd_p.h"
#include "qclipboard_p.h"

#include "qt_os2.h"
#include "private/qpmobjectwindow_pm_p.h"

//#define QCLIPBOARD_DEBUG

#ifdef QCLIPBOARD_DEBUG
#   include "qdebug.h"
#   define DEBUG(a) qDebug a
#else
#   define DEBUG(a) do {} while(0)
#endif

QT_BEGIN_NAMESPACE

extern bool qt_sendSpontaneousEvent(QObject*, QEvent*); // qapplication.cpp

////////////////////////////////////////////////////////////////////////////////

class QClipboardWatcher : public QInternalMimeData
{
public:
    QClipboardWatcher() {}

    bool hasFormat_sys(const QString &mimetype) const;
    QStringList formats_sys() const;
    QVariant retrieveData_sys(const QString &mimetype, QVariant::Type preferredType) const;

private:

    bool peekData(bool leaveOpen = false) const;

    mutable QList<ULONG> formats;
    mutable QList<QPMMime::Match> matches;
};

bool QClipboardWatcher::peekData(bool leaveOpen) const
{
    if (!WinOpenClipbrd(NULLHANDLE)) {
#ifndef QT_NO_DEBUG
        qWarning("QClipboardWatcher::peekData: WinOpenClipbrd "
                 "failed with 0x%lX", WinGetLastError(NULLHANDLE));
#endif
        return false;
    }

    QList<ULONG> newFormats;
    ULONG cf = 0;
    while ((cf = WinEnumClipbrdFmts(NULLHANDLE, cf)))
        newFormats << cf;

    if (!leaveOpen)
        WinCloseClipbrd(NULLHANDLE);

    // optimization: we don't want to call the potentially expensive
    // allConvertersFromFormats() unlesss we really got a different set
    if (newFormats == formats)
        return true;

    formats = newFormats;
    matches = QPMMime::allConvertersFromFormats(formats);

#ifdef QCLIPBOARD_DEBUG
    foreach(ULONG cf, formats)
        DEBUG(("QClipboardWatcher::peekData: have format 0x%lX (%ls)",
               cf, QPMMime::formatName(cf).utf16()));
    foreach(QPMMime::Match match, matches)
        DEBUG(("QClipboardWatcher::peekData: converter %p mime \"%ls\" "
               "format 0x%lX priority %d", match.converter, match.mime.utf16(),
               match.format, match.priority));
#endif

    return true;
}

bool QClipboardWatcher::hasFormat_sys(const QString &mime) const
{
    if (!peekData())
        return false;

    foreach (QPMMime::Match match, matches)
        if (match.mime == mime)
            return true;

    return false;
}

QStringList QClipboardWatcher::formats_sys() const
{
    QStringList fmts;

    if (!peekData())
        return fmts;

    foreach (QPMMime::Match match, matches)
        fmts << match.mime;

    return fmts;
}

QVariant QClipboardWatcher::retrieveData_sys(const QString &mime,
                                             QVariant::Type type) const
{
    QVariant result;

    if (!peekData(true /*leaveOpen*/))
        return result;

    foreach (QPMMime::Match match, matches) {
        if (match.mime == mime) {
            ULONG flags;
            if (WinQueryClipbrdFmtInfo(NULLHANDLE, match.format, &flags)) {
                ULONG data = WinQueryClipbrdData(NULLHANDLE, match.format);
                result = match.converter->convertFromFormat(match.format, flags,
                                                            data, match.mime, type);
            }
            break;
        }
    }

    WinCloseClipbrd(NULLHANDLE);

    return result;
}

////////////////////////////////////////////////////////////////////////////////

class QClipboardData : public QPMObjectWindow
{
public:
    QClipboardData();
    ~QClipboardData();

    void setSource(QMimeData *s);

    void setAsClipboardViewer();
    bool ownsClipboard() const;
    void putAllMimeToClipboard(bool isDelayed);
    void flushClipboard();

    const QMimeData *mimeData() const;

    static QClipboardData *instance()
    {
        if (instancePtr == 0) {
            instancePtr = new QClipboardData;
        }
        Q_ASSERT(instancePtr);
        return instancePtr;
    }

    static void deleteInstance()
    {
        delete instancePtr;
        instancePtr = 0;
    }

private:
    bool setClipboard(QPMMime *converter, ULONG format, bool isDelayed);

    MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2);

    QMimeData *src;
    QList<QPMMime::Match> matches;
    HWND prevClipboardViewer;

    QClipboardWatcher watcher;

    bool ignore_WM_DESTROYCLIPBOARD;

    static QClipboardData *instancePtr;
};

// static
QClipboardData *QClipboardData::instancePtr = 0;

QClipboardData::QClipboardData()
    : src(0), prevClipboardViewer(NULLHANDLE)
    , ignore_WM_DESTROYCLIPBOARD(false)
{
}

QClipboardData::~QClipboardData()
{
    setSource(0);

    // make sure we are not the clipboard viewer any more
    if (hwnd() == WinQueryClipbrdViewer(NULLHANDLE))
        WinSetClipbrdViewer(NULLHANDLE, prevClipboardViewer);
}

void QClipboardData::setSource(QMimeData *s)
{
    if (s == src)
        return;
    delete src;
    src = s;

    // build the list of all mime <-> cf matches
    matches.clear();
    if (src)
        matches = QPMMime::allConvertersFromMimeData(src);

#ifdef QCLIPBOARD_DEBUG
    if (src) {
        DEBUG(() << "QClipboardData::setSource: mimes" << src->formats());
        foreach(QPMMime::Match match, matches)
            DEBUG(("QClipboardData::setSource: match: converter %p format 0x%lX "
                   "(%ls) priority %d", match.converter, match.format,
                   QPMMime::formatName(match.format).utf16(), match.priority));
    }
#endif
}

void QClipboardData::setAsClipboardViewer()
{
    DEBUG(("QClipboardData::setAsClipboardViewer"));

    HWND clipboardViewer = WinQueryClipbrdViewer(NULLHANDLE);
    if (hwnd() != clipboardViewer) {
        prevClipboardViewer = clipboardViewer;
        BOOL ok = WinSetClipbrdViewer(NULLHANDLE, hwnd());
        Q_UNUSED(ok);
#ifndef QT_NO_DEBUG
        if (!ok)
            qWarning("QClipboardData::setAsClipboardViewer: WinSetClipbrdViewer "
                     " failed with 0x%lX", WinGetLastError(NULLHANDLE));
#endif
    }
}

bool QClipboardData::ownsClipboard() const
{
    return src && hwnd() == WinQueryClipbrdOwner(NULLHANDLE);
}

bool QClipboardData::setClipboard(QPMMime *converter, ULONG format,
                                  bool isDelayed)
{
    Q_ASSERT(src);
    if (!src)
        return false;

    bool ok, ok2;
    ULONG flags = 0, data = 0;

    if (isDelayed) {
        // setup delayed rendering of clipboard data
        ok = converter->convertFromMimeData(src, format, flags, 0);
        if (ok) {
            WinSetClipbrdOwner(NULLHANDLE, hwnd());
            ok2 = WinSetClipbrdData(NULLHANDLE, 0, format, flags);
        }
    } else {
        // render now
        ok = converter->convertFromMimeData(src, format, flags, &data);
        if (ok)
            ok2 = WinSetClipbrdData(NULLHANDLE, data, format, flags);
    }
    DEBUG(("QClipboardData::setClipboard: convert to format 0x%lX (%ls) "
           "flags 0x%lX data 0x%lX delayed %d ok %d", format,
           QPMMime::formatName(format).utf16(), flags, data, isDelayed, ok));
#ifndef QT_NO_DEBUG
    if (!ok2) {
        qWarning("QClipboardData::setClipboard: WinSetClipbrdData "
                 "failed with 0x%lX", WinGetLastError(NULLHANDLE));
    }