Changeset 324 for trunk/src

Timestamp:

Nov 18, 2009, 1:49:31 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui/kernel: Improved mime <-> PM clipboard format conversion interfaces.

Location:

trunk/src

Files:

• corelib/kernel/qcoreapplication.h (modified) (1 diff)
• gui/kernel/qclipboard_pm.cpp (modified) (10 diffs)
• gui/kernel/qmime.h (modified) (2 diffs)
• gui/kernel/qmime_pm.cpp (modified) (5 diffs)

trunk/src/corelib/kernel/qcoreapplication.h

@@ -217 +217 @@
     friend Q_CORE_EXPORT QString qAppName();
     friend class QClassFactory;
+
+
+
+
 };
 

trunk/src/gui/kernel/qclipboard_pm.cpp

@@ -52 +52 @@
 #include "qevent.h"
 #include "qmime.h"
+
+
 #include "qt_os2.h"
-#include "qdnd_p.h"
+#include "_p.h"
 
 #define QCLIPBOARD_DEBUG
 
+
+
+
+
 QT_BEGIN_NAMESPACE
 
@@ -64 +70 @@
 {
 public:
-    QClipboardWatcher() {}
+    QClipboardWatcher() {}
 
     bool hasFormat_sys(const QString &mimetype) const;
     QStringList formats_sys() const;
     QVariant retrieveData_sys(const QString &mimetype, QVariant::Type preferredType) const;
+
+
+
+
+
+
+
+
 };
 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 bool QClipboardWatcher::hasFormat_sys(const QString &mime) const
 {
-    bool ok = false;
-    if (WinOpenClipbrd(NULLHANDLE)) {
-        ULONG cf = 0;
-        while ((cf = WinEnumClipbrdFmts(NULLHANDLE, cf))) {
-            if (QPMMime::converterToMime(mime, cf)) {
-                ok = true;
-                break;
-            }
-        }
-        WinCloseClipbrd(NULLHANDLE);
-    }
-#ifndef QT_NO_DEBUG
-    else
-        qWarning("QClipboardWatcher: WinOpenClipbrd failed with %lX",
-                 WinGetLastError(NULLHANDLE));
-#endif
-    return ok;
+    peekData();
+    if (isDirty)
+        return false; // peekData() failed
+
+    foreach (QPMMime::Match match, matches)
+        if (match.mime == mime)
+            return true;
+
+    return false;
 }
 
@@ -95 +125 @@
 {
     QStringList fmts;
-    if (WinOpenClipbrd(NULLHANDLE)) {
-        QVector<ULONG> cfs;
-        ULONG cf = 0;
-        while ((cf = WinEnumClipbrdFmts(NULLHANDLE, cf)))
-            cfs << cf;
-        fmts = QPMMime::allMimesForFormats(cfs);
-        WinCloseClipbrd(NULLHANDLE);
-    }
-#ifndef QT_NO_DEBUG
-    else
-        qWarning("QClipboardWatcher: WinOpenClipbrd failed with %lX",
-                 WinGetLastError(NULLHANDLE));
-#endif
+
+    peekData();
+    if (isDirty)
+        return fmts; // peekData() failed
+
+    foreach (QPMMime::Match match, matches)
+        fmts << match.mime;
+
     return fmts;
 }
@@ -116 +141 @@
     QVariant result;
 
-    if (WinOpenClipbrd(NULLHANDLE)) {
-        ULONG cf = 0;
-        while ((cf = WinEnumClipbrdFmts(NULLHANDLE, cf))) {
-            QPMMime *converter = QPMMime::converterToMime(mime, cf);
-            if (converter) {
-                ULONG flags;
-                if (WinQueryClipbrdFmtInfo(NULLHANDLE, cf, &flags)) {
-                    ULONG data = WinQueryClipbrdData(NULLHANDLE, cf);
-                    if (data) {
-                        result = converter->convertToMime(mime, type, cf, flags, data);
-                    }
-                }
-                break;
+    peekData();
+    if (isDirty)
+        return result; // peekData() failed
+
+    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);
             }
+
         }
-        WinCloseClipbrd(NULLHANDLE);
-    }
-#ifndef QT_NO_DEBUG
-    else
-        qWarning("QClipboardWatcher: WinOpenClipbrd failed with %lX",
-                 WinGetLastError(NULLHANDLE));
-#endif
+    }
+
     return result;
 }
@@ -143 +162 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-class QClipboardData
+class QClipboardData
 {
 public:
@@ -149 +168 @@
     ~QClipboardData();
 
-    // @todo ...
+    void setSource(QMimeData *s)
+    {
+        if (s == src)
+            return;
+        delete src;
+        src = s;
+    }
+
+    QMimeData *source()
+    {
+        return src;
+    }
+
+    bool setClipboard(QPMMime *converter, ULONG format, bool isDelayed);
+
+    MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2);
 
 private:
+
 };
 
-QClipboardData::QClipboardData()
+QClipboardData::QClipboardData()
 {
 }
@@ -160 +195 @@
 QClipboardData::~QClipboardData()
 {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 }
 
@@ -168 +240 @@
     if (ptrClipboardData == 0) {
         ptrClipboardData = new QClipboardData;
-        // @todo ...
     }
     return ptrClipboardData;
@@ -181 +252 @@
 ////////////////////////////////////////////////////////////////////////////////
 
+
+
 QClipboard::~QClipboard()
 {
@@ -188 +261 @@
 void QClipboard::setMimeData(QMimeData *src, Mode mode)
 {
-    if (mode != Clipboard)
+    if (mode != Clipboard) {
+        delete src;
         return;
+
 
     if (!WinOpenClipbrd(NULLHANDLE)) {
 #ifndef QT_NO_DEBUG
-        qWarning("QClipboard: WinOpenClipbrd failed with %lX",
+        qWarning("QClipboard:%lX",
                  WinGetLastError(NULLHANDLE));
 #endif
+
         return;
     }
 
-    // @todo
-//  QClipboardData *d = clipboardData();
-//  d->setSource(src);
+    QClipboardData *d = clipboardData();
+    d->setSource(src);
+
+    ignore_WM_DESTROYCLIPBOARD = TRUE;
+    BOOL ok = WinEmptyClipbrd(NULLHANDLE);
+    ignore_WM_DESTROYCLIPBOARD = FALSE;
+#ifndef QT_NO_DEBUG
+    if (!ok)
+        qWarning("QClipboard::setMimeData: WinEmptyClipbrd failed with 0x%lX",
+                 WinGetLastError(NULLHANDLE));
+#else
+    Q_UNUSED(ok);
+#endif
+
+    if (!src)
+        return; // nothing to do
+
+    bool runsEventLoop = QCoreApplication::instance() &&
+                         QCoreApplication::instance()->d_func()->in_exec;
+
+    QStringList formats = src->formats();
+    foreach(QString mime, formats) {
+#ifdef QCLIPBOARD_DEBUG
+        qDebug() << "QClipboard::setMimeData: src mime" << mime;
+#endif
+        QList<QPMMime::Match> matches = QPMMime::allConvertersFromMimeData(src);
+        foreach(QPMMime::Match match, matches) {
+            d->setClipboard(match.converter, match.format, !runsEventLoop);
+        }
+    }
 
     WinCloseClipbrd(NULLHANDLE);

trunk/src/gui/kernel/qmime.h

@@ -123 +123 @@
 
     // for converting from Qt
-    virtual bool canConvertFromMime(ULONG format, const QMimeData *mimeData) const = 0;
-    virtual bool convertFromMime(ULONG format, const QMimeData *mimeData,
-                                 ULONG &flags, ULONG &data) const = 0;
-    virtual QVector<ULONG> formatsForMime(const QString &mimeType, const QMimeData *mimeData) const = 0;
+    virtual QList<ULONG> formatsForMimeData(const QMimeData *mimeData) const = 0;
+    virtual bool convertFromMimeData(const QMimeData *mimeData, ULONG format,
+                                     ULONG &flags, ULONG *data) const = 0;
 
     // for converting to Qt
-    virtual bool canConvertToMime(const QString &mimeType, ULONG format) const = 0;
-    virtual QVariant convertToMime(const QString &mimeType, QVariant::Type preferredType,
-                                   ULONG format, ULONG flags, ULONG data) const = 0;
-    virtual QString mimeForFormat(ULONG format) const = 0;
+    virtual ) const = 0;
+    virtual QVariant convert,
+                                   
+    ) const = 0;
 
     static ULONG registerMimeType(const QString &mime);
@@ -138 +137 @@
 private:
     friend class QClipboardWatcher;
-
-    static QPMMime *converterToMime(const QString &mimeType, ULONG format);
-    static QStringList allMimesForFormats(const QVector<ULONG> &formats);
-    static QPMMime *converterFromMime(ULONG format, const QMimeData *mimeData);
-    static QVector<ULONG> allFormatsForMime(const QMimeData *mimeData);
+    friend class QClipboard;
+
+    struct Match
+    {
+        Match(QPMMime *c, const QString f, int p) :
+            converter(c), mime(f), format(0), priority(p) {}
+
+        Match(QPMMime *c, ULONG f, int p) :
+            converter(c), format(f), priority(p) {}
+
+        QPMMime *converter;
+        QString mime; // used by allConvertersFromFormats()
+        ULONG format; // used by allConvertersFromMimeData()
+        int priority;
+    };
+
+    static QList<Match> allConvertersFromFormats(const QList<ULONG> &formats);
+    static QList<Match> allConvertersFromMimeData(const QMimeData *mimeData);
 };
 

trunk/src/gui/kernel/qmime_pm.cpp

@@ -114 +114 @@
     header, or even just passing on the data. See \l{Drag and Drop} for more
     information on choosing and definition MIME types.
-
-    You can check if a MIME type is convertible using canConvertFromMime() and
-    can perform conversions with convertToMime() and convertFromMime().
 */
 
@@ -158 +155 @@
 
 /*!
-    \fn bool QPMMime::canConvertFromMime(ULONG format, const QMimeData *mimeData) const
-
-    Returns true if the converter can convert from the \a mimeData to
-    the specified \a format.
+    \fn QList<ULONG> QPMMime::formatsForMimeData(const QMimeData *mimeData) const
+
+    Returns a list of ULONG values representing the different OS/2 PM
+    clipboard formats that can be provided for the \a mimeData, in order of
+    precedence (the most suitable format goes first), or an empty list if
+    neither of the mime types provided by \a mimeData is supported by this
+    converter.
 
     All subclasses must reimplement this pure virtual function.
@@ -167 +167 @@
 
 /*!
-    \fn bool QPMMime::convertFromMime(ULONG format, const QMimeData *mimeData,
-                                      ULONG &flags, ULONG &data) const
-
-    Convert the \a mimeData to the specified \a format.
-    The converted data should then be placed in the \a data variable with the
-    necessary flags returned in the \a flags variable.
+    \fn bool QPMMime::convertFromMimeData(const QMimeData *mimeData, ULONG format,
+                                          ULONG &flags, ULONG *data) const
+
+    Converts the \a mimeData to the specified \a format.
+
+    If \a data is not NULL, a handle to the converted data should then be placed
+    in a variable pointed to by \a data and with the necessary flags describing
+    the handle returned in the \a flags variable.
+
+    The following flags describing the data type are recognized:
+
+    \table
+    \row \o \c CFI_POINTER        \o \a data is a pointer to a block of memory
+                                      allocated with QPMMime::allocMem()
+    \row \o \c CFI_HANDLE         \o \a data is a handle to the appropriate
+                                      PM resource
+    \endtable
+
+    If \a data is NULL then a delayed conversion is requested by the caller.
+    The implementation should return the appropriate flags in the \a flags
+    variable and may perform the real data conversion later when this method is
+    called again with \a data being non-NULL.
 
     Return true if the conversion was successful.
@@ -180 +196 @@
 
 /*!
-    \fn QVector<ULONG> QPMMime::formatsForMime(const QString &mimeType, const QMimeData *mimeData) const
-
-    Returns a QVector of ULONG values representing the different OS/2 PM clipboard
-    formats that can be provided for the \a mimeType from the \a mimeData.
+    \fn QStringList QPMMime::mimesForFormats(const QList<ULONG> &formats) const
+
+    Returns a list of mime types that will be created form the specified \a list
+    of \a formats, in order of precedence (the most suitable mime type comes
+    first), or an empty list if neither of the \a formats is supported by this
+    converter.
 
     All subclasses must reimplement this pure virtual function.
@@ -189 +207 @@
 
 /*!
-    \fn bool QPMMime::canConvertToMime(const QString &mimeType, ULONG format) const
-
-    Returns true if the converter can convert to the \a mimeType from
-    the specified \a format.
+    \fn QVariant QPMMime::convertFromFormat(ULONG format, ULONG flags, ULONG data,
+                                            const QString &mimeType,
+                                            QVariant::Type preferredType) const
+
+    Returns a QVariant containing the converted from the \a data in the
+    specified \a format with the given \a flags to the requested \a mimeType. If
+    possible the QVariant should be of the \a preferredType to avoid needless
+    conversions.
 
     All subclasses must reimplement this pure virtual function.
 */
 
-/*!
-    \fn QVariant QPMMime::convertToMime(const QString &mimeType, QVariant::Type preferredType,
-                                        ULONG format, ULONG flags, ULONG data) const
-
-    Returns a QVariant containing the converted data for \a mimeType from the
-    \a data in the specified \a format and \a flags. If possible the QVariant
-    should be of the \a preferredType to avoid needless conversions.
-
-    All subclasses must reimplement this pure virtual function.
-*/
-
-/*!
-    \fn QString QPMMime::mimeForFormat(ULONG format) const
-
-    Returns the mime type that will be created form the specified \a format, or an
-    empty string if this converter does not support \a format.
-
-    All subclasses must reimplement this pure virtual function.
-*/
-
 // static
-QPMMime *QPMMime::converterToMime(const QString &mimeType, ULONG format)
-{
+QList<QPMMime::Match> QPMMime::allConvertersFromFormats(const QList<ULONG> &formats)
+{
+    QList<Match> matches;
+
     QList<QPMMime*> mimes = theMimeList()->mimes();
     for (int i = mimes.size()-1; i >= 0; --i) {
-        if (mimes.at(i)->canConvertToMime(mimeType, format))
-            return mimes.at(i);
-    }
-    return 0;
-}
-
-// static
-QStringList QPMMime::allMimesForFormats(const QVector<ULONG> &formats)
-{
-    QList<QPMMime*> mimes = theMimeList()->mimes();
-    QStringList fmts;
-
-    foreach(ULONG cf, formats) {
-#ifdef QMIME_DEBUG
-        HATOMTBL tbl = WinQuerySystemAtomTable();
-        ULONG len = WinQueryAtomLength(tbl, cf);
-        QByteArray atom(len, 0);
-        WinQueryAtomName(tbl, cf, atom.data(), atom.size() + 1 /* '\0' */);
-        qDebug("QPMMime::allMimesForFormats() CF %lu (%s)", cf, atom.constData());
-#endif
-        for (int i = mimes.size()-1; i >= 0; --i) {
-            QString format = mimes.at(i)->mimeForFormat(cf);
-            if (!format.isEmpty() && !fmts.contains(format)) {
-                fmts += format;
+        QStringList fmts = mimes[i]->mimesForFormats(formats);
+        int priority = 0;
+        foreach (QString fmt, fmts) {
+            ++priority;
+            QList<Match>::iterator it = matches.begin();
+            for (; it != matches.end(); ++it) {
+                Match &match = *it;
+                if (match.mime == fmt) {
+                    // replace if priority is higher, ignore otherwise
+                    if (priority < match.priority) {
+                        match.converter = mimes[i];
+                        match.priority = priority;
+                    }
+                    break;
+                }
+            }
+            if (it == matches.end()) {
+                matches += Match(mimes[i], fmt, priority);
             }
         }
     }
 
-    return fmts;
+    return s;
 }
 
 // static
-QPMMime *QPMMime::converterFromMime(ULONG format, const QMimeData *mimeData)
-{
+QList<QPMMime::Match> QPMMime::allConvertersFromMimeData(const QMimeData *mimeData)
+{
+    QList<Match> matches;
+
     QList<QPMMime*> mimes = theMimeList()->mimes();
     for (int i = mimes.size()-1; i >= 0; --i) {
-        if (mimes.at(i)->canConvertFromMime(format, mimeData))
-            return mimes.at(i);
+        QList<ULONG> cfs = mimes[i]->formatsForMimeData(mimeData);
+        int priority = 0;
+        foreach (ULONG cf, cfs) {
+            ++priority;
+            QList<Match>::iterator it = matches.begin();
+            for (; it != matches.end(); ++it) {
+                Match &match = *it;
+                if (match.format == cf) {
+                    // replace if priority is higher, ignore otherwise
+                    if (priority < match.priority) {
+                        match.converter = mimes[i];
+                        match.priority = priority;
+                    }
+                    break;
+                }
+            }
+            if (it == matches.end()) {
+                matches += Match(mimes[i], cf, priority);
+            }
+        }
     }
-    return 0;
-}
-
-// static
-QVector<ULONG> QPMMime::allFormatsForMime(const QMimeData *mimeData)
-{
-    QList<QPMMime*> mimes = theMimeList()->mimes();
-    QVector<ULONG> cfs(4);
-    QStringList formats = QInternalMimeData::formatsHelper(mimeData);
-    for (int f = 0; f < formats.size(); ++f) {
-        for (int i = mimes.size()-1; i >= 0; --i)
-            cfs += mimes.at(i)->formatsForMime(formats.at(f), mimeData);
-    }
-    return cfs;
+
+    return matches;
 }