Changeset 444 for trunk/src/gui/kernel/qmime_pm.cpp

Timestamp:

Dec 30, 2009, 2:32:09 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: DND: Implemented dropping text to Qt applications.

File:

• trunk/src/gui/kernel/qmime_pm.cpp (modified) (9 diffs)

trunk/src/gui/kernel/qmime_pm.cpp

@@ -60 +60 @@
 #include "qdir.h"
 
-#define QDND_DEBUG // in pair with qdnd_pm.cpp
+//#define QDND_DEBUG // in pair with qdnd_pm.cpp
 
 #ifdef QDND_DEBUG
@@ -769 +769 @@
 }
 
-// @todo
+// @todo remove
 //int QPMMime::DefaultDropWorker::formatCount() const
 //{
@@ -814 +814 @@
 
 QVariant QPMMime::DefaultDropWorker::retrieveData(const QString &mimeType,
-                                                  QVariant::Type type) const
-{
-    Q_UNUSED(type);
-
-    DEBUG(() << "DefaultDropWorker::retrieveData(" << mimeType << ")");
+                                                  QVariant::Type preferredType) const
+{
+    Q_UNUSED(preferredType);
+
+    DEBUG(() << "DefaultDropWorker::retrieveData: mimeType" << mimeType);
 
     QVariant ret;
@@ -1000 +1000 @@
                 bool ok = file.remove();
                 Q_ASSERT((ok = ok));
+                Q_UNUSED(ok);
             } else {
                 Q_ASSERT(xfer->hstrRenderToName);
@@ -1088 +1089 @@
             if (d->sending_DM_RENDER)
             {
+#ifndef QT_NO_DEBUG
                 DRAGTRANSFER *xfer = (DRAGTRANSFER *) mp1;
-#ifndef QT_NO_DEBUG
                 qWarning("Drag item 0x%08lX sent DM_RENDERCOMPLETE w/o first "
                          "replying to DM_RENDER!\n"
@@ -1420 +1421 @@
     All subclasses must reimplement this pure virtual function.
 */
+
+// @todo add DnD interfaces docs
 
 // static
@@ -1788 +1791 @@
 QPMMime::DefaultDragWorker *QPMMime::defaultExclDragWorker()
 {
-    static DefaultDragWorker defExclDragWorker(false /* exclusive */);
+    static DefaultDragWorker defExclDragWorker(true /* exclusive */);
     return &defExclDragWorker;
 }
@@ -1821 +1824 @@
                                QVariant::Type preferredType) const;
 
+#if !defined(QT_NO_DRAGANDDROP)
+
+    // Direct Manipulation (DND) converter interface
+    DragWorker *dragWorkerFor(const QString &mimeType, QMimeData *mimeData);
+    DropWorker *dropWorkerFor(DRAGINFO *info);
+
+    class NativeFileDrag : public DragWorker, public QPMObjectWindow
+    {
+    public:
+        // DragWorker interface
+        bool cleanup(bool isCancelled) { return true; } // always disallow Move
+        bool isExclusive() const { return true; }
+        ULONG itemCount() const { return 0; } // super exclusive
+        HWND hwnd() const { return QPMObjectWindow::hwnd(); }
+        DRAGINFO *createDragInfo(const QString &targetName, USHORT supportedOps);
+        // QPMObjectWindow interface (dummy implementation, we don't need to interact)
+        MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2) { return 0; }
+    };
+
+    class NativeFileDrop : public DropWorker
+    {
+    public:
+        // DropWorker interface
+        bool isExclusive() const { return true; }
+        bool hasFormat(const QString &mimeType) const;
+        QStringList formats() const;
+        QVariant retrieveData(const QString &mimeType,
+                              QVariant::Type preferredType) const;
+    };
+
+    class TextDragProvider : public DefaultDragWorker::Provider
+    {
+    public:
+        TextDragProvider() : exclusive(false) {}
+        bool exclusive;
+        // Provider interface
+        QString format(const char *drf) const;
+        bool provide(const char *drf, const QByteArray &allData,
+                     ULONG itemIndex, QByteArray &itemData);
+        void fileType(const char *drf, const char *&type, const char *&ext);
+    };
+
+    class TextDropProvider : public DefaultDropWorker::Provider
+    {
+    public:
+        // Provider interface
+        const char *drf(const QString &mimeType) const;
+        bool provide(const QString &format, ULONG itemIndex,
+                     const QByteArray &itemData, QByteArray &allData);
+    };
+
+#endif // !QT_NO_DRAGANDDROP
+
     const ULONG CF_TextUnicode;
     const ULONG CF_TextHtml;
+
+#if !defined(QT_NO_DRAGANDDROP)
+    NativeFileDrag nativeFileDrag;
+    NativeFileDrop nativeFileDrop;
+    TextDragProvider textDragProvider;
+    TextDropProvider textDropProvider;
+#endif // !QT_NO_DRAGANDDROP
 };
 
@@ -1999 +2062 @@
 }
 
+#if !defined(QT_NO_DRAGANDDROP)
+
+DRAGINFO *QPMMimeText::NativeFileDrag::createDragInfo(const QString &targetName,
+                                                      USHORT supportedOps)
+{
+    Q_ASSERT(source());
+    if (!source())
+        return 0;
+
+    // obtain the list of files
+    QList<QUrl> list;
+    if (source()->hasUrls())
+        list = source()->urls();
+    ULONG itemCnt = list.count();
+    Q_ASSERT(itemCnt);
+    if (!itemCnt)
+        return 0;
+
+    DEBUG(() << "QPMMimeText::NativeFileDrag: itemCnt" << itemCnt);
+
+    DRAGINFO *info = DrgAllocDraginfo(itemCnt);
+    Q_ASSERT(info);
+    if (!info)
+        return 0;
+
+    bool ok = true;
+    QList<QUrl>::iterator it = list.begin();
+    for (ULONG i = 0; i < itemCnt; ++i, ++it) {
+        DRAGITEM *item = DrgQueryDragitemPtr(info, i);
+        Q_ASSERT(item);
+        if (!item) {
+            ok = false;
+            break;
+        }
+
+        QByteArray fileName = QFile::encodeName(QDir::convertSeparators(it->toLocalFile()));
+
+        int sep = fileName.lastIndexOf('\\');
+        Q_ASSERT(sep > 0 && sep < fileName.length() - 1);
+        if (sep <= 0 || sep >= fileName.length() - 1) {
+            ok = false;
+            break;
+        }
+
+        item->hstrSourceName = DrgAddStrHandle(fileName.data() + sep + 1);
+        fileName.truncate(sep + 1);
+        item->hstrContainerName = DrgAddStrHandle(fileName);
+
+        DEBUG(() << "QPMMimeText::NativeFileDrag: item" << i
+                 << "dir" << queryHSTR(item->hstrContainerName)
+                 << "name" << queryHSTR(item->hstrSourceName));
+
+        item->hwndItem = hwnd();
+        item->ulItemID = 0;
+        item->hstrType = DrgAddStrHandle(DRT_UNKNOWN);
+        item->hstrRMF = DrgAddStrHandle("<DRM_OS2FILE,DRF_UNKNOWN>");
+        item->hstrTargetName = 0;
+        item->cxOffset = 0;
+        item->cyOffset = 0;
+        item->fsControl = 0;
+        item->fsSupportedOps = supportedOps;
+    }
+
+    if (!ok) {
+        DrgFreeDraginfo(info);
+        info = 0;
+    }
+
+    return info;
+}
+
+bool QPMMimeText::NativeFileDrop::hasFormat(const QString &mimeType) const
+{
+    return mimeType == QLatin1String("text/uri-list");
+}
+
+QStringList QPMMimeText::NativeFileDrop::formats() const
+{
+    QStringList mimes;
+    mimes << QLatin1String("text/uri-list");
+    return mimes;
+}
+
+QVariant QPMMimeText::NativeFileDrop::retrieveData(const QString &mimeType,
+                                                   QVariant::Type preferredType) const
+{
+    QVariant result;
+
+    Q_ASSERT(info());
+    if (!info())
+        return result;
+
+    ULONG itemCount = DrgQueryDragitemCount(info());
+    Q_ASSERT(itemCount);
+    if (!itemCount)
+        return result;
+
+    // sanity check
+    if (mimeType != QLatin1String("text/uri-list"))
+        return result;
+
+    QList<QVariant> urls;
+
+    for (ULONG i = 0; i < itemCount; ++i) {
+        DRAGITEM *item = DrgQueryDragitemPtr(info(), i);
+        Q_ASSERT(item);
+        QByteArray fullName;
+        if (!item || !canTargetRenderAsOS2File(item, &fullName))
+            return result;
+        QString fn = QFile::decodeName(fullName);
+        urls += QUrl::fromLocalFile(fn).toString();
+    }
+
+    if (preferredType == QVariant::Url && urls.size() == 1)
+        result = urls.at(0);
+    else if (!urls.isEmpty())
+        result = urls;
+
+    return result;
+}
+
+QString QPMMimeText::TextDragProvider::format(const char *drf) const
+{
+    QString result;
+
+    if (qstrcmp(drf, "DRF_TEXT") == 0) {
+        if (exclusive)
+            result = QLatin1String("text/uri-list");
+        else
+            result = QLatin1String("text/plain");
+    }
+    return result;
+}
+
+bool QPMMimeText::TextDragProvider::provide(const char *drf,
+                                            const QByteArray &allData,
+                                            ULONG itemIndex,
+                                            QByteArray &itemData)
+{
+    if (qstrcmp(drf, "DRF_TEXT") == 0) {
+        if (exclusive) {
+            // locate the required item
+            int dataSize = allData.size();
+            if (!dataSize)
+                return false;
+            int begin = 0, end = 0, next = 0;
+            do {
+                begin = next;
+                end = allData.indexOf('\r', begin);
+                if (end >= 0) {
+                    next = end + 1;
+                    if (next < dataSize && allData[next] == '\n')
+                        ++next;
+                } else {
+                    end = allData.indexOf('\n', begin);
+                    if (end >= 0)
+                        next = end + 1;
+                }
+            } while (itemIndex-- && end >= 0 && next < dataSize);
+            int urlLen = end - begin;
+            if (urlLen <= 0)
+                return false;
+            QUrl url = QUrl(QString::fromUtf8(allData.data() + begin, urlLen));
+            if (!url.isValid())
+                return false;
+            itemData = url.toEncoded();
+        } else {
+            itemData = allData;
+        }
+        return true;
+    }
+    return false;
+}
+
+void QPMMimeText::TextDragProvider::fileType(const char *drf, const char *&type,
+                                             const char *&ext)
+{
+    if (qstrcmp(drf, "DRF_TEXT") == 0) {
+        if (exclusive) {
+            type = "UniformResourceLocator";
+            // no extension for URLs
+        } else {
+            type = DRT_TEXT;
+            ext = "txt";
+        }
+    }
+};
+
+const char *QPMMimeText::TextDropProvider::drf(const QString &mimeType) const
+{
+    // sanity check
+    if (mimeType == QLatin1String("text/plain") ||
+        mimeType == QLatin1String("text/uri-list"))
+        return "DRF_TEXT";
+    return 0;
+}
+
+bool QPMMimeText::TextDropProvider::provide(const QString &mimeType,
+                                            ULONG itemIndex,
+                                            const QByteArray &itemData,
+                                            QByteArray &allData)
+{
+    if (mimeType == QLatin1String("text/plain")) {
+        allData = itemData;
+        return true;
+    }
+
+    if (mimeType == QLatin1String("text/uri-list")) {
+        QUrl url = QUrl::fromEncoded(itemData);
+        if (!url.isValid())
+            return false;
+        // append the URL to the list
+        allData += url.toString().toUtf8();
+        allData += "\r\n";
+        return true;
+    }
+
+    return false;
+}
+
+QPMMime::DragWorker *QPMMimeText::dragWorkerFor(const QString &mimeType,
+                                                QMimeData *mimeData)
+{
+    if (mimeType == QLatin1String("text/plain")) {
+        // add a cooperative provider
+        textDragProvider.exclusive = false;
+        DefaultDragWorker *defWorker = defaultCoopDragWorker();
+        defWorker->addProvider("DRF_TEXT", &textDragProvider);
+        return defWorker;
+    }
+
+    if (mimeType == QLatin1String("text/uri-list")) {
+        // see what kind of items text/uri-list represents
+        QList<QUrl> urls = mimeData->urls();
+        int fileCnt = 0;
+        foreach (const QUrl &url, urls) {
+            if (url.scheme() == QLatin1String("file"))
+                ++fileCnt;
+        }
+        if (fileCnt && fileCnt == urls.count()) {
+            // all items are local files, return an exclusive file drag worker
+            return &nativeFileDrag;
+        }
+        if (urls.count() && !fileCnt) {
+            // all items are non-files, add an exclusive provider for the
+            // specified item count
+            textDragProvider.exclusive = true;
+            DefaultDragWorker *defWorker = defaultExclDragWorker();
+            bool ok = defWorker->addProvider("DRF_TEXT", &textDragProvider,
+                                             urls.count());
+            return ok ? defWorker : 0;
+        }
+        // if items are mixed, we return NULL to fallback to QPMMimeAnyMime
+    }
+
+    return 0;
+}
+
+QPMMime::DropWorker *QPMMimeText::dropWorkerFor(DRAGINFO *info)
+{
+    ULONG itemCount = DrgQueryDragitemCount(info);
+    Q_ASSERT(itemCount);
+    if (!itemCount)
+        return 0;
+
+    if (itemCount == 1) {
+        DRAGITEM *item = DrgQueryDragitemPtr(info, 0);
+        Q_ASSERT(item);
+        if (!item)
+            return 0;
+        // proceed only if the target cannot render DRM_OS2FILE on its own
+        // and if the item type is not "UniformResourceLocator" (which will be
+        // processed below)
+        if (!canTargetRenderAsOS2File(item) &&
+            !DrgVerifyType(item, "UniformResourceLocator")) {
+            DefaultDropWorker *defWorker = defaultDropWorker();
+            // check that we support one of DRMs and the format is DRF_TEXT
+            if (defWorker->canRender(item, "DRF_TEXT")) {
+                // add a cooperative provider (can coexist with others)
+                defWorker->addProvider(QLatin1String("text/plain"),
+                                        &textDropProvider);
+                return defWorker;
+            }
+            return 0;
+        }
+    }
+
+    // Either the target can render DRM_OS2FILE on its own (so it's a valid
+    // file/directory name), or it's an "UniformResourceLocator", or there is
+    // more than one drag item. Check that all items are of either one type
+    // or another. If so, we can represent them as 'text/uri-list'.
+    bool allAreFiles = true;
+    bool allAreURLs = true;
+    DefaultDropWorker *defWorker = defaultDropWorker();
+    for (ULONG i = 0; i < itemCount; ++i) {
+        DRAGITEM *item = DrgQueryDragitemPtr(info, i);
+        Q_ASSERT(item);
+        if (!item)
+            return 0;
+        if (allAreFiles)
+            allAreFiles &= canTargetRenderAsOS2File(item);
+        if (allAreURLs)
+            allAreURLs &= DrgVerifyType(item, "UniformResourceLocator") &&
+                          defWorker->canRender(item, "DRF_TEXT");
+        if (!allAreFiles && !allAreURLs)
+            return 0;
+    }
+
+    if (allAreFiles) {
+        // return an exclusive drop worker
+        return &nativeFileDrop;
+    }
+
+    // add an exclusive provider (can neither coexist with other workers
+    // or providers)
+    bool ok = defWorker->addExclusiveProvider(QLatin1String("text/uri-list"),
+                                              &textDropProvider);
+    return ok ? defWorker : 0;
+}
+
+#endif // !QT_NO_DRAGANDDROP
+
 ////////////////////////////////////////////////////////////////////////////////