Changeset 441 for trunk/src

Timestamp:

Dec 26, 2009, 2:14:18 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: QPMMime: Adding more DND support code, fixing the build.

Location:

trunk/src/gui/kernel

Files:

• qmime.h (modified) (5 diffs)
• qmime_pm.cpp (modified) (41 diffs)

trunk/src/gui/kernel/qmime.h

@@ -115 +115 @@
 */
 
-typedef unsigned long ULONG;
+#if !defined(QT_NO_DRAGANDDROP)
+QT_END_NAMESPACE
+#include "private/qpmobjectwindow_pm_p.h"
+QT_BEGIN_NAMESPACE
+#endif
 
 class QPMCoopDragWorker;
@@ -125 +129 @@
 #if !defined(QT_NO_DRAGANDDROP)
 
+    typedef QList<QByteArray> QByteArrayList;
+
     class DragWorker
     {
     public:
-        DragWorker() : data(0) {}
+        DragWorker() : src(0) {}
         virtual ~DragWorker() {}
 
@@ -177 +183 @@
         {
         public:
-            virtual const char *format( const char *drf ) const = 0;
+            virtual const QString &format(const char *drf) const = 0;
             virtual bool provide(const char *drf, const QByteArray &allData,
                                  ULONG itemIndex, QByteArray &itemData) = 0;
@@ -246 +252 @@
 
         static bool canRender(DRAGITEM *item, const char *drf );
-        static bool getSupportedRMFs(DRAGITEM *item, QPtrList<QStrList> &list);
+        static bool getSupportedRMFs(DRAGITEM *item, QList<QByteArrayList> &list);
 
     private:
@@ -297 +303 @@
     static QByteArray querySourceNameFull(DRAGITEM *item);
     static bool canTargetRenderAsOS2File(DRAGITEM *item, QByteArray *fullName = 0);
-    static bool parseRMFs(HSTR rmfs, QList<QList<QByteArray> > &list);
+    static bool parseRMFs(HSTR rmfs, QList<QByteArrayList> &list);
     static bool parseRMF(HSTR rmf, QByteArray &mechanism, QByteArray &format);
 

trunk/src/gui/kernel/qmime_pm.cpp

@@ -63 +63 @@
 
 #ifdef QDND_DEBUG
+#   include "qdebug.h"
 #   define DEBUG(a) qDebug a
 #else
@@ -72 +73 @@
 #if !defined(QT_NO_DRAGANDDROP)
 
-// @todo remove
-//#define DRT_URL "UniformResourceLocator"
-//
-//#define DRM_OS2FILE "DRM_OS2FILE"
-//#define DRM_SHAREDMEM "DRM_SHAREDMEM"
-//
-//#define DRF_UNKNOWN "DRF_UNKNOWN"
-//#define DRF_TEXT "DRF_TEXT"
-//#define DRF_POINTERDATA "DRF_POINTERDATA"
-//
-//#define MIME_TEXT_PLAIN "text/plain"
-//#define MIME_TEXT_PLAIN_CHARSET_SYSTEM "text/plain;charset=system"
-//#define MIME_TEXT_URI_LIST "text/uri-list"
+// Undoc'd DC_PREPAREITEM, see
+// http://lxr.mozilla.org/seamonkey/source/widget/src/os2/nsDragService.cpp
+#if !defined (DC_PREPAREITEM)
+#define DC_PREPAREITEM 0x40
+#endif
 
 /*! \internal
@@ -241 +234 @@
         ULONG index;
         Provider *provider;
-        QCString drm;
-        QCString drf;
+        QByteArray drm;
+        QByteArray drf;
         DRAGTRANSFER *xfer;
         bool rendered;
@@ -255 +248 @@
         DrfProvider() : prov(0) {}
         DrfProvider(const char *d, Provider *p) : drf(d), prov(p) {}
-        const QByteArray drf;
-        Provider * const prov;
+        QByteArray drf;
+        Provider *prov;
     };
 
@@ -378 +371 @@
     // (however, it doesn't help when dropping objects to it -- WPS still
     // chooses DRM_OS2FILE).
-    formats = "("DRM_SHAREDMEM","DRM_OS2FILE")x(" + formats + "),"
-              "<"DRM_SHAREDMEM","DRF_POINTERDATA">";
+    formats = "(DRM_SHAREDMEM,DRM_OS2FILE)x(" + formats + "),"
+              "<DRM_SHAREDMEM,DRF_POINTERDATA>";
 
     DEBUG(() << "DefaultDragWorker: formats" << formats
@@ -400 +393 @@
 
     DEBUG(() << "DefaultDragWorker: Preparing item" <<  itemIndex << "(id "
-             << item->ulItemID << ") for <" << drm << "," << drf ">");
+             << item->ulItemID << ") for <" << drm << "," << drf << ">");
 
     Provider *p = d->providerFor(drf);
@@ -469 +462 @@
                  << "(id " << xfer->pditem->ulItemID << ")");
 
-        QCString drm, drf;
+        QByteArray drm, drf;
         if (!parseRMF(xfer->hstrSelectedRMF, drm, drf))
             Q_ASSERT(/* parseRMF() = */ FALSE);
@@ -525 +518 @@
 
         bool renderOk = false;
-        QByteArray allData =
-            source()->encodedData(req->provider->format(req->drf));
+
+        QByteArray allData = source()->data(req->provider->format(req->drf));
         QByteArray itemData;
 
@@ -534 +527 @@
         if (renderOk) {
             enum DRM { OS2File, SharedMem } drmType;
-            if (qstrcmp(req->drm, DRM_SHAREDMEM) == 0) drmType = SharedMem;
+            if (qstrcmp(req->drm, "DRM_SHAREDMEM") == 0) drmType = SharedMem;
             else drmType = OS2File;
 
             if (drmType == OS2File) {
-                QCString renderToName = queryHSTR(req->xfer->hstrRenderToName);
+                QByteArray renderToName = queryHSTR(req->xfer->hstrRenderToName);
                 Q_ASSERT(!renderToName.isEmpty());
                 renderOk = !renderToName.isEmpty();
@@ -544 +537 @@
                     DEBUG(() << "DefaultDragWorker: Will write to" << renderToName);
                     QFile file(QFile::decodeName(renderToName));
-                    renderOk = file.open(IO_WriteOnly);
+                    renderOk = file.open(QIODevice::WriteOnly);
                     if (renderOk) {
-                        Q_LONG written =
-                            file.writeBlock(itemData.data(), itemData.size());
-                        renderOk = written == (Q_LONG) itemData.size() &&
-                                   file.status() == IO_Ok;
+                        qint64 written = file.write(itemData, itemData.size());
+                        renderOk = written == itemData.size();
                         file.close();
                         if (renderOk && req->xfer->pditem->hstrType) {
@@ -626 +617 @@
             DEBUG(("DefaultDragWorker: Freed DRAGTRANSFER: "
                    "req->xfer %p size %lu (0x%08lX) flags 0x%08lX",
-                   req->xfer, size, size, flags);
+                   req->xfer, size, size, flags));
         }
 #endif
@@ -686 +677 @@
             // first provider
             d->itemCnt = itemCnt;
-            d->providers.insert(Data::DrfProvider(drf, provider));
+            d->providers.append(Data::DrfProvider(drf, provider));
             return true;
         }
@@ -693 +684 @@
             // ensure there are no dups (several providers for the same drf)
             if (!d->providerFor(drf))
-                d->providers.insert(Data::DrfProvider(drf, provider));
+                d->providers.append(Data::DrfProvider(drf, provider));
             return true;
         }
@@ -703 +694 @@
 bool QPMMime::DefaultDragWorker::canRender(const char *drm)
 {
-    return qstrcmp(drm, DRM_SHAREDMEM) == 0 ||
-           qstrcmp(drm, DRM_OS2FILE) == 0;
+    return qstrcmp(drm, "DRM_SHAREDMEM") == 0 ||
+           qstrcmp(drm, "DRM_OS2FILE") == 0;
 }
 
@@ -715 +706 @@
         MimeProvider() : prov(NULL) {}
         MimeProvider(const QString &m, Provider *p) : mime(m), prov(p) {}
-        const QString mime;
-        Provider * const prov;
+        QString mime;
+        Provider *prov;
     };
 
@@ -736 +727 @@
     bool got_DM_RENDERCOMPLETE : 1;
     USHORT flags_DM_RENDERCOMPLETE;
-    int waiting_DM_RENDERCOMPLETE;
+
+    QEventLoop eventLoop;
 };
 
@@ -744 +736 @@
     d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
     d->flags_DM_RENDERCOMPLETE = 0;
-    d->waiting_DM_RENDERCOMPLETE = 0;
 }
 
@@ -754 +745 @@
 void QPMMime::DefaultDropWorker::cleanup(bool isAccepted, bool isActAccepted)
 {
-    if (d->waiting_DM_RENDERCOMPLETE != 0) {
+    if (d->eventLoop.isRunning()) {
 #ifndef QT_NO_DEBUG
         qWarning("The previous drag source didn't post DM_RENDERCOMPLETE!\n"
                  "Contact the drag source developer.");
 #endif
-        qApp->eventLoop()->exitLoop();
+        d->eventLoop.exit(1);
     }
 
@@ -766 +757 @@
     d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
     d->flags_DM_RENDERCOMPLETE = 0;
-    d->waiting_DM_RENDERCOMPLETE = 0;
 }
 
@@ -774 +764 @@
 }
 
-bool QPMMime::DefaultDropWorker::provides(const char *format) const
-{
-    return d->providerFor(format) != NULL;
-}
-
-int QPMMime::DefaultDropWorker::formatCount() const
-{
-    return d->providers.count();
-}
-
-const char *QPMMime::DefaultDropWorker::format(int fn) const
-{
-    if (fn >= 0 && (uint) fn < d->providers.count())
-        return d->providers[ fn ].mime;
-    return NULL;
-}
-
-static QCString composeTempFileName()
-{
-    static char defTmpDir[ 3 ] = { 0 };
-    const char *tmpDir = getenv("TEMP");
-    if (!tmpDir) tmpDir = getenv("TMP");
-    if (!tmpDir || !QFile::exists(QFile::decodeName(tmpDir))) {
-        if (!defTmpDir[ 0 ]) {
-            ULONG bootDrive = 0;
-            DosQuerySysInfo(QSV_BOOT_DRIVE, QSV_BOOT_DRIVE,
-                            &bootDrive, sizeof (bootDrive));
-            defTmpDir[ 0 ] = bootDrive;
-            defTmpDir[ 1 ] = ':';
-        }
-        tmpDir = defTmpDir;
-    }
+bool QPMMime::DefaultDropWorker::hasFormat(const QString &mimeType) const
+{
+    return d->providerFor(mimeType) != NULL;
+}
+
+// @todo
+//int QPMMime::DefaultDropWorker::formatCount() const
+//{
+//    return d->providers.count();
+//}
+
+QStringList QPMMime::DefaultDropWorker::formats() const
+{
+    QStringList mimes;
+    foreach(const Data::MimeProvider &p, d->providers)
+        mimes << p.mime;
+    return mimes;
+}
+
+static QByteArray composeTempFileName()
+{
+    QByteArray tmpDir =
+        QFile::encodeName(QDir::toNativeSeparators(QDir::tempPath()));
 
     static bool srandDone = false;
@@ -817 +798 @@
     int attempts = Attempts;
 
-    QCString tmpName;
+    QString tmpName;
     do {
-        tmpName.sprintf("%s\\%08lX.tmp", tmpDir, num);
-        if (!QFile::exists(QFile::decodeName(tmpName)))
+        tmpName.sprintf("%s\\%08lX.tmp", tmpDir.constData(), num);
+        if (!QFile::exists(tmpName))
             break;
         num = rand();
@@ -827 +808 @@
     Q_ASSERT(attempts > 0);
     if (attempts <= 0)
-        tmpName.resize(0);
-
-    return tmpName;
-}
-
-QByteArray QPMMime::DefaultDropWorker::encodedData(const char *format) const
-{
-    DEBUG("DefaultDropWorker::encodedData(" << format << ")");
-
-    QByteArray data;
+        tmpName.clear();
+
+    return QFile::encodeName(tmpName);
+}
+
+QVariant QPMMime::DefaultDropWorker::retrieveData(const QString &mimeType,
+                                                  QVariant::Type type) const
+{
+    Q_UNUSED(type);
+
+    DEBUG(() << "DefaultDropWorker::retrieveData(" << mimeType << ")");
+
+    QVariant ret;
 
     Q_ASSERT(info());
     if (!info())
-        return data;
+        return ret;
 
     ULONG itemCount = DrgQueryDragitemCount(info());
     Q_ASSERT(itemCount);
     if (!itemCount)
-        return data;
-
-    Provider *provider = d->providerFor(format);
+        return ret;
+
+    Provider *provider = d->providerFor(mimeType);
     if (!provider)
-        return data;
-
-    const char *drf = provider->drf(format);
+        return ret;
+
+    const char *drf = provider->drf(mimeType);
     Q_ASSERT(drf);
     if (!drf)
-        return data;
+        return ret;
 
     // Note: Allocating and freeing DRAGTRANSFER structures is a real mess. It's
@@ -868 +852 @@
     // always allocate a new struct per every item. It seems to work.
 
-    QCString renderToName = composeTempFileName();
+    QByteArray renderToName = composeTempFileName();
     HSTR hstrRenderToName = DrgAddStrHandle(renderToName);
 
     HSTR rmfOS2File =
-        DrgAddStrHandle(QCString().sprintf("<"DRM_OS2FILE",%s>", drf));
+        DrgAddStrHandle(QString().sprintf("<DRM_OS2FILE,%s>", drf).toLocal8Bit());
     HSTR rmfSharedMem =
-        DrgAddStrHandle(QCString().sprintf("<"DRM_SHAREDMEM",%s>", drf));
+        DrgAddStrHandle(QString().sprintf("<DRM_SHAREDMEM,%s>", drf).toLocal8Bit());
 
     MRESULT mrc;
@@ -880 +864 @@
 
     DRAGTRANSFER *xfer = NULL;
-    QCString srcFileName;
+    QByteArray srcFileName;
 
     QByteArray allData, itemData;
@@ -897 +881 @@
         // determine the mechanism to use (prefer DRM_SHAREDMEM)
 
-        if (DrgVerifyRMF(item, DRM_SHAREDMEM, drf) &&
-             DrgVerifyRMF(item, DRM_SHAREDMEM, DRF_POINTERDATA))
+        if (DrgVerifyRMF(item, "DRM_SHAREDMEM", drf) &&
+             DrgVerifyRMF(item, "DRM_SHAREDMEM", "DRF_POINTERDATA"))
             drm = SharedMem;
-        if (DrgVerifyRMF(item, DRM_OS2FILE, drf)) {
+        if (DrgVerifyRMF(item, "DRM_OS2FILE", drf)) {
             srcFileName = querySourceNameFull(item);
             // If the source provides the full file name, we prefer DRM_OS2FILE
@@ -950 +934 @@
 
             mrc = (MRESULT)TRUE;
-            if ((item->fsControl & DC_PREPARE) |
-                 (item->fsControl & DC_PREPAREITEM)) {
+            if ((item->fsControl & DC_PREPARE) ||
+                (item->fsControl & DC_PREPAREITEM)) {
                 DEBUG(("DefaultDropWorker: Sending DM_RENDERPREPARE to 0x%08lX...",
                        info()->hwndSource));
@@ -957 +941 @@
                                          MPFROMP (xfer), 0);
                 DEBUG(("DefaultDropWorker: Finisned sending DM_RENDERPREPARE\n"
-                       " mrc %p xfer->fsReply 0x%08hX", mrc, xfer->fsReply);
+                       " mrc %p xfer->fsReply 0x%08hX", mrc, xfer->fsReply));
                 renderOk = (BOOL) mrc;
             }
@@ -979 +963 @@
                 } else {
                     // synchronously wait for DM_RENDERCOMPLETE
-                    d->waiting_DM_RENDERCOMPLETE = qApp->loopLevel() + 1;
                     DEBUG(() << "DefaultDropWorker: Waiting for DM_RENDERCOMPLETE...");
-                    int level = qApp->eventLoop()->enterLoop();
+                    int result = d->eventLoop.exec();
                     DEBUG(("DefaultDropWorker: Finished waiting for "
-                           "DM_RENDERCOMPLETE (%d)\n"
+                           "DM_RENDERCOMPLETE (result %d)\n"
                            " got_DM_RENDERCOMPLETE %d usFS 0x%hX",
-                           level, d->got_DM_RENDERCOMPLETE, d->flags_DM_RENDERCOMPLETE));
-                    Q_UNUSED(level);
+                           result, d->got_DM_RENDERCOMPLETE, d->flags_DM_RENDERCOMPLETE));
+                    Q_UNUSED(result);
                     // JFTR: at this point, cleanup() might have been called,
                     // as a result of either program exit or getting another
@@ -992 +975 @@
                     // DM_RENDERCOMPLETE from the source. Use data members with
                     // care!
-                    d->waiting_DM_RENDERCOMPLETE = 0;
                     renderOk = d->got_DM_RENDERCOMPLETE &&
                                (d->flags_DM_RENDERCOMPLETE & DMFL_RENDEROK);
@@ -1000 +982 @@
             }
         } else {
-            DEBUG(() << "DefaultDropWorker: Source supports <" << DRM_OS2FILE
-                     << "," << drf << "> and provides a file" << srcFileName
+            DEBUG(() << "DefaultDropWorker: Source supports <DRM_OS2FILE,"
+                     << drf << "> and provides a file" << srcFileName
                      << "for item" << item << "(no need to render)");
             renderOk = true;
@@ -1010 +992 @@
                 DEBUG(() << "DefaultDragWorker: Will read from" << srcFileName);
                 QFile file(QFile::decodeName(srcFileName));
-                renderOk = file.open(IO_ReadOnly);
+                renderOk = file.open(QIODevice::ReadOnly);
                 if (renderOk) {
                     itemData = file.readAll();
-                    renderOk = file.status() == IO_Ok;
+                    renderOk = file.error() == QFile::NoError;
                     file.close();
                 }
@@ -1030 +1012 @@
                         DEBUG(("DefaultDropWorker: Got shared data %p size %lu "
                                "(0x%08lX) flags 0x%08lX", ptr, size, size, flags));
-                        Q_ASSERT(flags & (PAG_COMMIT | PAG_READ | PAG_BASE) ==
+                        Q_ASSERT((flags & (PAG_COMMIT | PAG_READ | PAG_BASE)) ==
                                  (PAG_COMMIT | PAG_READ | PAG_BASE));
-                        renderOk = flags & (PAG_COMMIT | PAG_READ | PAG_BASE) ==
+                        renderOk = (flags & (PAG_COMMIT | PAG_READ | PAG_BASE)) ==
                                    (PAG_COMMIT | PAG_READ | PAG_BASE);
 #ifndef QT_NO_DEBUG
@@ -1046 +1028 @@
                         if (renderOk) {
                             itemData.resize(realSize);
-                            memcpy(itemData.data(), ptr + sizeof (ULONG), realSize);
+                            memcpy(itemData.data(), ptr + sizeof(ULONG), realSize);
                         }
                     }
@@ -1058 +1040 @@
 
         if (renderOk)
-            renderOk = provider->provide(format, i, itemData, allData);
+            renderOk = provider->provide(mimeType, i, itemData, allData);
 
         if (needToTalk) {
@@ -1086 +1068 @@
 
     if (renderOk)
-        data = allData;
-
-    return data;
+        ret = allData;
+
+    return ret;
 }
 
@@ -1100 +1082 @@
                 return (MRESULT)FALSE;
 
-            DEBUG("DefaultDropWorker: Got DM_RENDERCOMPLETE");
+            DEBUG(("DefaultDropWorker: Got DM_RENDERCOMPLETE"));
             d->got_DM_RENDERCOMPLETE = true;
             d->flags_DM_RENDERCOMPLETE = SHORT1FROMMP(mp2);
@@ -1117 +1099 @@
 
             // stop synchronous waiting for DM_RENDERCOMPLETE
-            if (d->waiting_DM_RENDERCOMPLETE != 0)
-                qApp->eventLoop()->exitLoop();
+            if (d->eventLoop.isRunning())
+                d->eventLoop.exit();
             return (MRESULT)FALSE;
         }
@@ -1128 +1110 @@
 }
 
-bool QPMMime::DefaultDropWorker::addProvider(const char *format,
+bool QPMMime::DefaultDropWorker::addProvider(const QString &mimeType,
                                              Provider *provider)
 {
-    Q_ASSERT(format && provider);
-    if (format && provider && !d->exclusive) {
+    Q_ASSERT(!mimeType.isEmpty() && provider);
+    if (!mimeType.isEmpty() && provider && !d->exclusive) {
         // ensure there are no dups (several providers for the same mime)
-        if (!d->providerFor(format))
-            d->providers.insert(Data::MimeProvider(format, provider));
+        if (!d->providerFor(mimeType))
+            d->providers.append(Data::MimeProvider(mimeType, provider));
         return true;
     }
@@ -1141 +1123 @@
 }
 
-bool QPMMime::DefaultDropWorker::addExclusiveProvider(const char *format,
+bool QPMMime::DefaultDropWorker::addExclusiveProvider(const QString &mimeType,
                                                       Provider *provider)
 {
-    Q_ASSERT(format && provider);
-    if (format && provider && !d->exclusive) {
+    Q_ASSERT(!mimeType.isEmpty() && provider);
+    if (!mimeType.isEmpty() && provider && !d->exclusive) {
         d->exclusive = true;
         d->providers.clear();
-        d->providers.insert(Data::MimeProvider(format, provider));
+        d->providers.append(Data::MimeProvider(mimeType, provider));
         return true;
     }
@@ -1157 +1139 @@
 bool QPMMime::DefaultDropWorker::canRender(DRAGITEM *item, const char *drf)
 {
-    return DrgVerifyRMF(item, DRM_OS2FILE, drf) ||
-           (DrgVerifyRMF(item, DRM_SHAREDMEM, drf) &&
-            DrgVerifyRMF(item, DRM_SHAREDMEM, DRF_POINTERDATA));
-}
-
+    return DrgVerifyRMF(item, "DRM_OS2FILE", drf) ||
+           (DrgVerifyRMF(item, "DRM_SHAREDMEM", drf) &&
+            DrgVerifyRMF(item, "DRM_SHAREDMEM", "DRF_POINTERDATA"));
+}
+
+/*! \internal
+
+    Parses the rendering mechanism/format specification of the given \a item
+    and stores only those mechanism branches in the given \a list that represent
+    mechanisms supported by this worker. Returns false if fails to parse the
+    RMF specification. Note that if no supported mechanisms are found, true is
+    returned but the \a list will simply contain zero items.
+
+    \note The method clears the given \a list variable before proceeding.
+
+    \sa canRender(), PMMime::parseRMFs()
+*/
 // static
-/*! \internal
-  Parses the rendering mechanism/format specification of the given \a item
-  and stores only those mechanism branches in the given \a list that represent
-  mechanisms supported by this worker. Returns false if fails to parse the
-  RMF specification. Note that if no supported mechanisms are found, true is
-  returned but the \a list will simply contain zero items.
-  \note The method clears the given \a list variable before proceeding and sets
-  auto-deletion to true.
-  \sa canRender(), PMMime::parseRMFs()
-*/
 bool QPMMime::DefaultDropWorker::getSupportedRMFs(DRAGITEM *item,
-                                                  QPtrList<QStrList> &list)
+                                                  QList<QByteArrayList> &list)
 {
     if (!parseRMFs(item->hstrRMF, list))
         return false;
 
-    for (QStrList *mech = list.first(); mech;) {
-        const char *drm = mech->first();
-        if (qstrcmp(drm, DRM_OS2FILE) == 0) {
-            mech = list.next();
+    for (QList<QByteArrayList>::iterator rmf = list.begin(); rmf != list.end();) {
+        QByteArrayList::iterator mf = rmf->begin();
+        Q_ASSERT(mf != rmf->end());
+        const char *drm = *mf;
+        if (qstrcmp(drm, "DRM_OS2FILE") == 0) {
+            ++rmf;
             continue;
         }
-        if (qstrcmp(drm, DRM_SHAREDMEM) == 0) {
-            const char *drf = mech->next();
+        if (qstrcmp(drm, "DRM_SHAREDMEM") == 0) {
             // accept DRM_SHAREDMEM only if there is DRF_POINTERDATA
-            for(; drf; drf = mech->next()) {
-                if (qstrcmp(drf, DRF_POINTERDATA) == 0)
+            for(; mf != rmf->end(); ++mf) {
+                const char *drf = *mf;
+                if (qstrcmp(drf, "DRF_POINTERDATA") == 0)
                     break;
             }
-            if (drf) {
-                mech = list.next();
+            if (mf != rmf->end()) {
+                ++rmf;
                 continue;
             }
         }
         // remove the unsupported mechanism branch from the list
-        bool wasLast = list.getLast() == mech;
-        list.removeRef(mech);
-        // after deleting the last item, the current one will be set to the new
-        // last item which was already analyzed earlier, so set to 0 to stop
-        mech = wasLast ? 0 : list.current();
+        rmf = list.erase(rmf);
     }
 
@@ -1518 +1500 @@
 }
 
+#if !defined(QT_NO_DRAGANDDROP)
+
+/*!
+    Returns a string represented by \a hstr.
+*/
+// static
+QByteArray QPMMime::queryHSTR(HSTR hstr)
+{
+    QByteArray str;
+    ULONG len = DrgQueryStrNameLen(hstr);
+    if (len) {
+        str.resize(len);
+        DrgQueryStrName(hstr, str.size() + 1 /* \0 */, str.data());
+    }
+    return str;
+}
+
+/*!
+    Returns a string that is a concatenation of \c hstrContainerName and
+    \c hstrSourceName fileds of the given \a item structure.
+*/
+// static
+QByteArray QPMMime::querySourceNameFull(DRAGITEM *item)
+{
+    QByteArray fullName;
+    if (!item)
+        return fullName;
+
+    ULONG pathLen = DrgQueryStrNameLen(item->hstrContainerName);
+    ULONG nameLen = DrgQueryStrNameLen(item->hstrSourceName);
+    if (!pathLen || !nameLen)
+        return fullName;
+
+    fullName.resize(pathLen + nameLen);
+    DrgQueryStrName(item->hstrContainerName, pathLen + 1, fullName.data());
+    DrgQueryStrName(item->hstrSourceName, nameLen + 1, fullName.data() + pathLen);
+
+    return fullName;
+}
+
+/*! \internal
+
+    Checks that the given drag \a item supports the DRM_OS2FILE rendering
+    mechanism and can be rendered by a target w/o involving the source (i.e.,
+    DRM_OS2FILE is the first supported format and a valid file name with full
+    path is provided). If the function returns TRUE, \a fullName (if not NULL)
+    will be assigned the item's full source file name (composed from
+    \c hstrContainerName and \c hstrSourceName fields).
+ */
+// static
+bool QPMMime::canTargetRenderAsOS2File(DRAGITEM *item, QByteArray *fullName /*= 0*/)
+{
+    if ( !item )
+        return false;
+
+    if (item->fsControl & (DC_PREPARE | DC_PREPAREITEM))
+        return false;
+
+    {
+        // DrgVerifyNativeRMF doesn't work on my system (ECS 1.2.1 GA):
+        // it always returns FALSE regardless of arguments. Use simplified
+        // hstrRMF parsing to determine whether DRM_OS2FILE is the native
+        // mechanism or not (i.e. "^\s*[\(<]\s*DRM_OS2FILE\s*,.*").
+
+        QByteArray rmf = queryHSTR(item->hstrRMF);
+        bool ok = false;
+        int i = rmf.indexOf("DRM_OS2FILE");
+        if (i >= 1) {
+            for (int j = i - 1; j >= 0; --j) {
+                char ch = rmf[j];
+                if (ch == ' ')
+                    continue;
+                if (ch == '<' || ch == '(') {
+                    if (ok)
+                        return false;
+                    ok = true;
+                } else {
+                    return false;
+                }
+            }
+        }
+        if (ok) {
+            ok = false;
+            int drmLen = strlen("DRM_OS2FILE");
+            for (int j = i + drmLen; j < (int) rmf.size(); ++j) {
+                char ch = rmf[j];
+                if (ch == ' ')
+                    continue;
+                if (ch == ',') {
+                    ok = true;
+                    break;
+                }
+                return false;
+            }
+        }
+        if (!ok)
+            return false;
+    }
+
+    QByteArray srcFullName = querySourceNameFull(item);
+    if (srcFullName.isEmpty())
+        return false;
+
+    QByteArray srcFullName2(srcFullName.size(), '\0');
+    APIRET rc = DosQueryPathInfo(srcFullName, FIL_QUERYFULLNAME,
+                                 srcFullName2.data(), srcFullName2.size());
+    if (rc != 0)
+        return false;
+
+    QString s1 = QFile::decodeName(srcFullName);
+    QString s2 = QFile::decodeName(srcFullName2);
+
+    if (s1.compare(s2, Qt::CaseInsensitive) != 0)
+        return false;
+
+    if (fullName)
+        *fullName = srcFullName;
+    return true;
+}
+
+/*! \internal
+
+    Parses the given \a rmfs list (full rendering mechanism/format specification)
+    and builds a \a list of mechanism branches. Each mechanism branch is also a
+    list, where the first item is the mechahism name and all subsequent items are
+    formats supported by this mechanism. Returns false if fails to parse \a rmf.
+
+    \note The method clears the given \a list variable before proceeding.
+*/
+// static
+bool QPMMime::parseRMFs(HSTR rmfs, QList<QByteArrayList> &list)
+{
+    // The format of the RMF list is "elem {,elem,elem...}"
+    // where elem is "(mechanism{,mechanism...}) x (format{,format...})"
+    // or "<mechanism,format>".
+    // We use a simple FSM to parse it. In terms of FSM, the format is:
+    //
+    // STRT ( BCM m CMCH echanism CMCH , NCM m CMCH echanism CMCH ) ECM x
+    //     SCMF ( BCF f CFCH ormat CFCH , NCF f CFCH ormat CFCH ) ECF , STRT
+    // STRT < BP m PMCH echanism PMCH , SPMF f PFCH ormat PFCH > EP , STRT
+
+    QByteArray str = queryHSTR(rmfs);
+    uint len = str.length();
+
+    enum {
+        // states
+        STRT = 0, BCM, CMCH, NCM, ECM, SCMF, BCF, CFCH, NCF, ECF,
+        BP, PMCH, SPMF, PFCH, EP,
+        STATES_COUNT,
+        // pseudo states
+        Err, Skip,
+        // inputs
+        obr = 0, cbr, xx, lt, gt, cm, any, ws,
+        INPUTS_COUNT,
+    };
+
+    static const char Chars[] =  { '(', ')', 'x', 'X', '<', '>', ',', ' ', 0 };
+    static const char Inputs[] = { obr, cbr, xx,  xx,  lt,  gt,  cm,  ws };
+    static const uchar Fsm [STATES_COUNT] [INPUTS_COUNT] = {
+             /* 0 obr  1 cbr  2 xx   3 lt   4 gt   5 cm   6 any  7 ws */
+/* STRT 0  */ { BCM,   Err,   Err,   BP,    Err,   Err,   Err,   Skip },
+/* BCM  1  */ { Err,   Err,   Err,   Err,   Err,   Err,   CMCH,  Skip },
+/* CMCH 2  */ { Err,   ECM,   CMCH,  Err,   Err,   NCM,   CMCH,  CMCH },
+/* NCM  3  */ { Err,   Err,   Err,   Err,   Err,   Err,   CMCH,  Skip },
+/* ECM  4  */ { Err,   Err,   SCMF,  Err,   Err,   Err,   Err,   Skip },
+/* SCMF 5  */ { BCF,   Err,   Err,   Err,   Err,   Err,   Err,   Skip },
+/* BCF  6  */ { Err,   Err,   Err,   Err,   Err,   Err,   CFCH,  Skip },
+/* CFCH 7  */ { Err,   ECF,   CFCH,  Err,   Err,   NCF,   CFCH,  CFCH },
+/* NCF  8  */ { Err,   Err,   Err,   Err,   Err,   Err,   CFCH,  Skip },
+/* ECF  9  */ { Err,   Err,   Err,   Err,   Err,   STRT,  Err,   Skip },
+/* BP   10 */ { Err,   Err,   Err,   Err,   Err,   Err,   PMCH,  Skip },
+/* PMCH 11 */ { Err,   Err,   PMCH,  Err,   Err,   SPMF,  PMCH,  PMCH  },
+/* SPMF 12 */ { Err,   Err,   Err,   Err,   Err,   Err,   PFCH,  Skip },
+/* PFCH 13 */ { Err,   Err,   PFCH,  Err,   EP,    Err,   PFCH,  PFCH },
+/* EP   14 */ { Err,   Err,   Err,   Err,   Err,   STRT,  Err,   Skip }
+    };
+
+    list.clear();
+
+    QList<QByteArrayList*> refList;
+
+    QByteArray buf;
+    QList<QByteArrayList>::iterator rmf;
+
+    uint state = STRT;
+    uint start = 0, end = 0, space = 0;
+
+    for (uint i = 0; i < len && state != Err ; ++i) {
+        char ch = str[i];
+        char *p = strchr(Chars, ch);
+        uint input = p ? Inputs[p - Chars] : any;
+        uint newState = Fsm[state][input];
+        switch (newState) {
+            case Skip:
+                continue;
+            case CMCH:
+            case CFCH:
+            case PMCH:
+            case PFCH:
+                if (state != newState)
+                    start = end = i;
+                ++end;
+                // accumulate trailing space for truncation
+                if (input == ws) ++space;
+                else space = 0;
+                break;
+            case NCM:
+            case ECM:
+            case SPMF:
+                buf = QByteArray(str.data() + start, end - start - space);
+                // find the mechanism branch in the output list
+                for (rmf = list.begin(); rmf != list.end(); ++rmf) {
+                    if (rmf->first() == buf)
+                        break;
+                }
+                if (rmf == list.end()) {
+                    // append to the output list if not found
+                    QByteArrayList newRmf;
+                    newRmf.append(buf);
+                    rmf = list.insert(list.end(), newRmf);
+                }
+                // store a refecence in the helper list for making a cross product
+                refList.append(&*rmf);
+                start = end = 0;
+                break;
+            case NCF:
+            case ECF:
+            case EP:
+                buf = QByteArray(str.data() + start, end - start - space);
+                // make a cross product with all current mechanisms
+                foreach(QByteArrayList *rmfRef, refList)
+                    rmfRef->append(buf);
+                if (newState != NCF)
+                    refList.clear();
+                start = end = 0;
+                break;
+            default:
+                break;
+        }
+        state = newState;
+    }
+
+    return state == ECF || state == EP;
+}
+
+/*! \internal
+
+    Splits the given \a rmf (rendering mechanism/format pair) to a \a mechanism
+    and a \a format string. Returns FALSE if fails to parse \a rmf.
+ */
+// static
+bool QPMMime::parseRMF(HSTR rmf, QByteArray &mechanism, QByteArray &format)
+{
+    QList<QByteArrayList> list;
+    if (!parseRMFs(rmf, list))
+        return false;
+
+    if (list.count() != 1 || list.first().count() != 2)
+        return false;
+
+    QByteArrayList first = list.first();
+    mechanism = first.at(0);
+    format = first.at(1);
+
+    return true;
+}
+
+/*! \internal */
+// static
+QPMMime::DefaultDragWorker *QPMMime::defaultCoopDragWorker()
+{
+    static DefaultDragWorker defCoopDragWorker(false /* exclusive */);
+    return &defCoopDragWorker;
+}
+
+// static
+/*! \internal */
+QPMMime::DefaultDragWorker *QPMMime::defaultExclDragWorker()
+{
+    static DefaultDragWorker defExclDragWorker(false /* exclusive */);
+    return &defExclDragWorker;
+}
+
+/*! \internal */
+// static
+QPMMime::DefaultDropWorker *QPMMime::defaultDropWorker()
+{
+    static DefaultDropWorker defaultDropWorker;
+    return &defaultDropWorker;
+}
+
+#endif // !QT_NO_DRAGANDDROP
+
 ////////////////////////////////////////////////////////////////////////////////