Changeset 439 for trunk/src

Timestamp:

Dec 25, 2009, 12:21:47 AM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: More DnD code typed in.

Location:

trunk/src/gui/kernel

Files:

• qdnd_pm.cpp (modified) (8 diffs)
• qmime.h (modified) (3 diffs)
• qmime_pm.cpp (modified) (2 diffs)

trunk/src/gui/kernel/qdnd_pm.cpp

@@ -57 +57 @@
 #include "qt_os2.h"
 
+#define QDND_DEBUG // in pair with qmime_pm.cpp
+
+#ifdef QDND_DEBUG
+#   define DEBUG(a) qDebug a
+#else
+#   define DEBUG(a) do {} while(0)
+#endif
+
 QT_BEGIN_NAMESPACE
 
@@ -79 +87 @@
     DRAGINFO *info() const { return di; }
 
-    bool provides( const char *format );
-    const char *format( int fn );
-    QByteArray encodedData( const char *format );
+    bool hasFormat_sys(const QString &mimeType);
+    QStringList formats_sys();
+    QVariant retrieveData_sys(const QString &mimeType, QVariant::Type type);
 
 private:
@@ -152 +160 @@
     }
 
-#if defined(QT_DEBUG_DND)
-    qDebug( "QPMDragData: %d drop workers for DRAGINFO %p",
-            workers.count(), di );
-#endif
+    DEBUG(() << "QPMDragData:" << workers.count() << "drop workers for DRAGINFO" << di);
 
     // init all workers
@@ -182 +187 @@
     di = NULL;
     initialized = dropped = gotWorkers = FALSE;
+}
+
+bool QPMDragData::hasFormat_sys(const QString &mimeType)
+{
+    return false;
+}
+
+QStringList QPMDragData::formats_sys()
+{
+    return QStringList();
+}
+
+QVariant QPMDragData::retrieveData_sys(const QString &mimeType,
+                                       QVariant::Type type)
+{
+    QVariant result;
+
+    // we may only do data transfer after DM_DROP is sent. Return shortly.
+    if (!isDropped())
+        return result;
+
+    return result;
 }
 
@@ -527 +554 @@
 bool QDropData::hasFormat_sys(const QString &mimeType) const
 {
-    // @todo implement
+    Q_ASSERT(d);
+    if (d)
+        return d->hasFormat_sys(mimeType);
     return false;
 }
@@ -534 +563 @@
 {
     QStringList fmts;
-    // @todo implement
+    Q_ASSERT(d);
+    if (d)
+        fmts = d->formats_sys();
     return fmts;
 }
@@ -541 +572 @@
 {
     QVariant result;
-    // @todo implement
+    Q_ASSERT(d);
+    if (d)
+        result = d->retrieveData_sys(mimeType, type);
     return result;
 }
@@ -548 +581 @@
 
 {
-#ifdef QDND_DEBUG
-    qDebug("QDragManager::drag(QDrag *drag)");
-#endif
+    DEBUG(() << "QDragManager::drag");
 
     // @todo implement

trunk/src/gui/kernel/qmime.h

@@ -111 +111 @@
 
 /*
-  Encapsulation of conversion between MIME and OS/2 PM clipboard.
+  Encapsulation of conversion between MIME and OS/2 PM clipboard formats and
+  between MIME and Direct Manipulation (DND) objects.
 */
 
 typedef unsigned long ULONG;
+
+class QPMCoopDragWorker;
 
 class Q_GUI_EXPORT QPMMime
 {
 public:
+
+#if !defined(QT_NO_DRAGANDDROP)
+
+    class DragWorker
+    {
+    public:
+        DragWorker() : data(0) {}
+        virtual ~DragWorker() {}
+
+        const QMimeData *source() const { return src; }
+
+        virtual void init() {}
+        // methods always implemented
+        virtual bool cleanup( bool isCancelled) = 0;
+        virtual bool isExclusive() const = 0;
+        virtual ULONG itemCount() const = 0;
+        virtual HWND hwnd() const = 0;
+        // methods implemented if isExclusive() == TRUE and itemCount() == 0
+        virtual DRAGINFO *createDragInfo(const char *name, USHORT supportedOps)
+                                        { return NULL; }
+        // methods implemented if itemCount() >= 0
+        virtual QByteArray composeFormatString() { return QByteArray(); }
+        virtual bool prepare(const char *drm, const char *drf, DRAGITEM *item,
+                             ULONG itemIndex) { return FALSE; }
+        virtual void defaultFileType(const char *&type, const char *&ext) {};
+
+    private:
+        const QMimeData *src;
+        friend class QPMCoopDragWorker;
+        friend class QDragManager;
+    };
+
+    class DefaultDragWorker : public DragWorker, public QPMObjectWindow
+    {
+    private:
+        DefaultDragWorker(bool exclusive);
+    public:
+        virtual ~DefaultDragWorker();
+
+        // DragpWorker interface
+        bool cleanup(bool isCancelled);
+        bool isExclusive() const;
+        ULONG itemCount() const;
+        HWND hwnd() const { return QPMObjectWindow::hwnd(); }
+        QByteArray composeFormatString();
+        bool prepare(const char *drm, const char *drf, DRAGITEM *item,
+                     ULONG itemIndex);
+        void defaultFileType(const char *&type, const char *&ext);
+
+        // QPMObjectWindow interface
+        MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2);
+
+        class Provider
+        {
+        public:
+            virtual const char *format( const char *drf ) const = 0;
+            virtual bool provide(const char *drf, const QByteArray &allData,
+                                 ULONG itemIndex, QByteArray &itemData) = 0;
+            virtual void fileType(const char *drf, const char *&type,
+                                  const char *&ext) {};
+        };
+
+        bool addProvider(const char *drf, Provider *provider,
+                         ULONG itemCount = 1);
+
+        static bool canRender(const char *drm);
+
+    private:
+        struct Data;
+        Data *d;
+        friend class QPMMime;
+    };
+
+    class DropWorker
+    {
+    public:
+        DropWorker() : nfo(0) {}
+        virtual ~DropWorker() {}
+
+        DRAGINFO *info() const { return nfo; }
+
+        virtual void init() {}
+        virtual void cleanup(bool isAccepted, bool isActAccepted) {}
+        virtual bool isExclusive() const = 0;
+
+        virtual bool hasFormat(const QString &mimeType) const = 0;
+        virtual QStringList formats() const = 0;
+        virtual QVariant retrieveData(const QString &mimeType, QVariant::Type type) const = 0;
+
+    private:
+        DRAGINFO *nfo;
+        friend class QPMDragData;
+    };
+
+    class DefaultDropWorker : public DropWorker, public QPMObjectWindow
+    {
+    private:
+        DefaultDropWorker();
+    public:
+        virtual ~DefaultDropWorker();
+
+        // DropWorker interface
+        void cleanup(bool isAccepted, bool isActAccepted);
+        bool isExclusive() const;
+        bool hasFormat(const QString &mimeType) const;
+        QStringList formats() const;
+        QVariant retrieveData(const QString &mimeType, QVariant::Type type) const;
+
+        // QPMObjectWindow interface
+        MRESULT message(ULONG msg, MPARAM mp1, MPARAM mp2);
+
+        class Provider
+        {
+        public:
+            virtual const char *drf(const QString &mimeType) const = 0;
+            virtual bool provide(const QString &mimeType, ULONG itemIndex,
+                                 const QByteArray &itemData,
+                                 QByteArray &allData) = 0;
+        };
+
+        bool addProvider(const QString &mimeType, Provider *provider);
+        bool addExclusiveProvider(const QString &mimeType, Provider *provider);
+
+        static bool canRender(DRAGITEM *item, const char *drf );
+        static bool getSupportedRMFs(DRAGITEM *item, QPtrList<QStrList> &list);
+
+    private:
+        struct Data;
+        Data *d;
+        friend class QPMMime;
+    };
+
+#endif // !QT_NO_DRAGANDDROP
+
     QPMMime();
     virtual ~QPMMime();
@@ -139 +276 @@
                                        QVariant::Type preferredType) const = 0;
 
+#if !defined(QT_NO_DRAGANDDROP)
+    // Direct Manipulation (DND) converter interface
+    virtual DragWorker *dragWorkerFor(const QString &mimeType,
+                                      QMimeData *mimeData) { return 0; }
+    virtual DropWorker *dropWorkerFor(DRAGINFO *info) { return 0; }
+#endif // !QT_NO_DRAGANDDROP
+
 protected:
 
@@ -148 +292 @@
 
     static QString formatName(ULONG format);
+
+#if !defined(QT_NO_DRAGANDDROP)
+    static QByteArray queryHSTR(HSTR hstr);
+    static QByteArray querySourceNameFull(DRAGITEM *item);
+    static bool canTargetRenderAsOS2File(DRAGITEM *item, QByteArray *fullName = 0);
+    static bool parseRMFs(HSTR rmfs, QList<QList<QByteArray> > &list);
+    static bool parseRMF(HSTR rmf, QByteArray &mechanism, QByteArray &format);
+
+    static DefaultDragWorker *defaultCoopDragWorker();
+    static DefaultDragWorker *defaultExclDragWorker();
+    static DefaultDropWorker *defaultDropWorker();
+#endif // !QT_NO_DRAGANDDROP
 
 private:

trunk/src/gui/kernel/qmime_pm.cpp

@@ -60 +60 @@
 #include "qdir.h"
 
-#define QMIME_DEBUG
+#define QDND_DEBUG // in pair with qdnd_pm.cpp
+
+#ifdef QDND_DEBUG
+#   define DEBUG(a) qDebug a
+#else
+#   define DEBUG(a) do {} while(0)
+#endif
 
 QT_BEGIN_NAMESPACE
+
+#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"
+
+/*! \internal
+  According to my tests, DrgFreeDragtransfer() appears to be bogus: when the
+  drag source attempts to free the DRAGTRANSFER structure passed to it in
+  DM_RENDERPREPARE/DM_RENDER by another process, the shared memory object is not
+  actually released until DrgFreeDragtransfer() is called for the second time.
+  This method tries to fix this problem.
+
+  \note The problem (and the solution) was not tested on platforms other than
+  eCS!
+*/
+void qt_DrgFreeDragtransfer(DRAGTRANSFER *xfer)
+{
+    Q_ASSERT(xfer);
+    if (xfer) {
+        BOOL ok = DrgFreeDragtransfer(xfer);
+        Q_ASSERT(ok);
+        if (ok) {
+            ULONG size = ~0, flags = 0;
+            APIRET rc = DosQueryMem(xfer, &size, &flags);
+            Q_ASSERT(rc == 0);
+            if (rc == 0 && !(flags & PAG_FREE)) {
+                PID pid;
+                TID tid;
+                ok = WinQueryWindowProcess(xfer->hwndClient, &pid, &tid);
+                Q_ASSERT(ok);
+                if (ok) {
+                    PPIB ppib = 0;
+                    DosGetInfoBlocks(0, &ppib);
+                    if (ppib->pib_ulpid != pid) {
+                        DEBUG(() << "qt_DrgFreeDragtransfer: Will free xfer"
+                                 << xfer << "TWICE (other process)!");
+                        DrgFreeDragtransfer(xfer);
+                    }
+                }
+            }
+        }
+    }
+}
+
+#define SEA_TYPE ".TYPE"
+
+/*! \internal
+  Sets a single .TYPE EA vaule on a given fle.
+*/
+static void qt_SetFileTypeEA(const char *name, const char *type)
+{
+    #pragma pack(1)
+
+    struct MY_FEA2 {
+        ULONG   oNextEntryOffset;  /*  Offset to next entry. */
+        BYTE    fEA;               /*  Extended attributes flag. */
+        BYTE    cbName;            /*  Length of szName, not including NULL. */
+        USHORT  cbValue;           /*  Value length. */
+        CHAR    szName[0];         /*  Extended attribute name. */
+        /* EA value follows here */
+    };
+
+    struct MY_FEA2LIST {
+        ULONG   cbList;            /*  Total bytes of structure including full list. */
+        MY_FEA2 list[0];           /*  Variable-length FEA2 structures. */
+    };
+
+    struct MY_FEA2_VAL {
+        USHORT  usEAType;          /* EA value type (one of EAT_* constants) */
+        USHORT  usValueLen;        /* Length of the value data following */
+        CHAR    aValueData[0];     /* value data */
+    };
+
+    struct MY_FEA2_MVMT {
+        USHORT      usEAType;      /* Always EAT_MVMT */
+        USHORT      usCodePage;    /* 0 - default */
+        USHORT      cbNumEntries;  /* Number of MYFEA2_VAL structs following */
+        MY_FEA2_VAL aValues[0];    /* MYFEA2_VAL value structures */
+    };
+
+    #pragma pack()
+
+    uint typeLen = qstrlen(type);
+    uint valLen = sizeof(MY_FEA2_VAL) + typeLen;
+    uint mvmtLen = sizeof(MY_FEA2_MVMT) + valLen;
+    uint fea2Len = sizeof(MY_FEA2) + sizeof(SEA_TYPE);
+    uint fullLen = sizeof(MY_FEA2LIST) + fea2Len + mvmtLen;
+
+    uchar *eaData = new uchar[fullLen];
+
+    MY_FEA2LIST *fea2List = (MY_FEA2LIST *)eaData;
+    fea2List->cbList = fullLen;
+
+    MY_FEA2 *fea2 = fea2List->list;
+    fea2->oNextEntryOffset = 0;
+    fea2->fEA = 0;
+    fea2->cbName = sizeof(SEA_TYPE) - 1;
+    fea2->cbValue = mvmtLen;
+    strcpy(fea2->szName, SEA_TYPE);
+
+    MY_FEA2_MVMT *mvmt = (MY_FEA2_MVMT *)(fea2->szName + sizeof(SEA_TYPE));
+    mvmt->usEAType = EAT_MVMT;
+    mvmt->usCodePage = 0;
+    mvmt->cbNumEntries = 1;
+
+    MY_FEA2_VAL *val = mvmt->aValues;
+    val->usEAType = EAT_ASCII;
+    val->usValueLen = typeLen;
+    memcpy(val->aValueData, type, typeLen);
+
+    EAOP2 eaop2;
+    eaop2.fpGEA2List = 0;
+    eaop2.fpFEA2List = (FEA2LIST *)fea2List;
+    eaop2.oError = 0;
+
+    APIRET rc = DosSetPathInfo(name, FIL_QUERYEASIZE,
+                               &eaop2, sizeof(eaop2), 0);
+#ifndef QT_NO_DEBUG
+    if (rc)
+        qWarning("qt_SetFileTypeEA: DosSetPathInfo failed with %ld", rc);
+#endif
+
+    delete[] eaData;
+}
+
+static int hex_to_int(uchar c)
+{
+    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
+    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
+    if (c >= '0' && c <= '9') return c - '0';
+    return -1;
+}
+
+static inline int hex_to_int(char c)
+{
+    return hex_to_int((uchar) c);
+}
+
+// -----------------------------------------------------------------------------
+
+struct QPMMime::DefaultDragWorker::Data
+{
+    Data(bool excl) : exclusive(excl) {}
+
+    struct Request
+    {
+        Request(ULONG i, Provider *p, const char *m, const char *f)
+            : index(i), provider(p), drm(m), drf(f)
+            , xfer(0), rendered(false), sharedMem(0) {}
+
+        ~Request()
+        {
+            // free memory allocated for the target that requested DRM_SHAREDMEM
+            if (sharedMem)
+                DosFreeMem(sharedMem);
+            Q_ASSERT(!xfer);
+        }
+
+        ULONG index;
+        Provider *provider;
+        QCString drm;
+        QCString drf;
+        DRAGTRANSFER *xfer;
+        bool rendered;
+        PVOID sharedMem;
+    };
+
+    inline bool isInitialized() { return providers.count() != 0; }
+    void cleanupRequests();
+
+    struct DrfProvider
+    {
+        DrfProvider() : prov(0) {}
+        DrfProvider(const char *d, Provider *p) : drf(d), prov(p) {}
+        const QByteArray drf;
+        Provider * const prov;
+    };
+
+    typedef QList<DrfProvider> DrfProviderList;
+
+    Provider *providerFor(const char *drf)
+    {
+        foreach (const DrfProvider &dp, providers)
+            if (qstrcmp(dp.drf, drf) == 0)
+                return dp.prov;
+        return 0;
+    }
+
+    const bool exclusive : 1;
+    DrfProviderList providers;
+
+    ULONG itemCnt;
+    QHash<ULONG, Request*> requests;
+    bool renderOk : 1;
+};
+
+void QPMMime::DefaultDragWorker::Data::cleanupRequests()
+{
+    if (requests.count()) {
+#ifndef QT_NO_DEBUG
+        qWarning("In the previous DnD session, the drop target sent "
+                 "DM_RENDERPREPARE/DM_RENDER\n"
+                 "for some drag item but didn't send DM_ENDCONVERSATION!");
+#endif
+        qDeleteAll(requests);
+        requests.clear();
+    }
+}
+
+QPMMime::DefaultDragWorker::DefaultDragWorker(bool exclusive)
+    : d(new Data(exclusive))
+{
+    d->itemCnt = 0;
+    d->renderOk = true;
+}
+
+QPMMime::DefaultDragWorker::~DefaultDragWorker()
+{
+    d->cleanupRequests();
+    delete d;
+}
+
+bool QPMMime::DefaultDragWorker::cleanup(bool isCancelled)
+{
+    // the return value is: true if the source-side Move for the given
+    // drag object should be *dis*allowed, false otherwise (including cases
+    // when this DragWorker didn't participate to the conversation at all)
+
+    // sanity check
+    Q_ASSERT(d->isInitialized());
+    if (!d->isInitialized())
+        return true;
+
+    bool moveDisallowed = false;
+
+    DEBUG(() << "DefaultDragWorker: Session ended (cancelled" << isCancelled
+             << "requests.left" << d->requests.count() << ")");
+
+    if (d->requests.count()) {
+        // always disallow Move if not all requests got DM_ENDCONVERSATION
+        moveDisallowed = true;
+    } else {
+        // disallow Move if rendering of some item failed
+        moveDisallowed = !d->renderOk;
+    }
+
+    DEBUG(() << "DefaultDragWorker: moveDisallowed" << moveDisallowed);
+
+    // Note: remaining requests will be lazily deleted by cleanupRequests()
+    // when a new DND session is started
+
+    d->renderOk = true;
+    d->itemCnt = 0;
+
+    // Indicate we're cleaned up (i.e. the DND session is finished)
+    d->providers.clear();
+
+    return moveDisallowed;
+}
+
+bool QPMMime::DefaultDragWorker::isExclusive() const
+{
+    return d->exclusive;
+}
+
+ULONG QPMMime::DefaultDragWorker::itemCount() const
+{
+    return d->itemCnt;
+}
+
+QByteArray QPMMime::DefaultDragWorker::composeFormatString()
+{
+    QByteArray formats;
+
+    // sanity checks
+    Q_ASSERT(d->isInitialized());
+    if (!d->isInitialized())
+        return formats;
+
+    bool first = true;
+    foreach(const Data::DrfProvider &p, d->providers) {
+        if (first)
+            first = false;
+        else
+            formats += ",";
+        formats += p.drf;
+    }
+
+    Q_ASSERT(!formats.isNull());
+    if (formats.isNull())
+        return formats;
+
+    // DRM_SHAREDMEM comes first to prevent native DRM_OS2FILE
+    // rendering on the target side w/o involving the source.
+    // Also, we add <DRM_SHAREDMEM,DRF_POINTERDATA> just like WPS does it
+    // (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">";
+
+    DEBUG(() << "DefaultDragWorker: formats" << formats
+             << ", itemCnt" << d->itemCnt);
+
+    return formats;
+}
+
+bool QPMMime::DefaultDragWorker::prepare(const char *drm, const char *drf,
+                                          DRAGITEM *item, ULONG itemIndex)
+{
+    // sanity checks
+    Q_ASSERT(d->isInitialized());
+    if (!d->isInitialized())
+        return false;
+
+    Q_ASSERT(item && itemIndex < d->itemCnt);
+    if (!item || itemIndex >= d->itemCnt)
+        return false;
+
+    DEBUG(() << "DefaultDragWorker: Preparing item" <<  itemIndex << "(id "
+             << item->ulItemID << ") for <" << drm << "," << drf ">");
+
+    Provider *p = d->providerFor(drf);
+
+    if (!canRender(drm) || p == NULL) {
+        DEBUG(() << "DefaultDragWorker: Cannot render the given RMF");
+        return false;
+    }
+
+    Data::Request *req = d->requests.value(item->ulItemID);
+
+    if (req) {
+        // this item has been already prepared, ensure it has also been
+        // rendered already
+        Q_ASSERT(req->index == itemIndex);
+        Q_ASSERT(req->rendered);
+        if (req->index != itemIndex || !req->rendered)
+            return false;
+        // remove the old request to free resources
+        delete d->requests.take(item->ulItemID);
+    }
+
+    // store the request
+    req = new Data::Request(itemIndex, p, drm, drf);
+    d->requests.insert(item->ulItemID, req);
+
+    return true;
+}
+
+void QPMMime::DefaultDragWorker::defaultFileType(const char *&type,
+                                                 const char *&ext)
+{
+    Q_ASSERT(d->providers.count());
+    if (d->providers.count()) {
+        Provider *p = d->providers.first().prov;
+        Q_ASSERT(p);
+        if (p)
+            p->fileType(d->providers.first().drf, type, ext);
+    }
+}
+
+MRESULT QPMMime::DefaultDragWorker::message(ULONG msg, MPARAM mp1, MPARAM mp2)
+{
+    if (msg == DM_RENDER) {
+        DRAGTRANSFER *xfer = (DRAGTRANSFER *) mp1;
+
+        // sanity checks
+        Q_ASSERT(d->isInitialized());
+        Q_ASSERT(xfer);
+        if (!d->isInitialized() || !xfer)
+            return (MRESULT)FALSE;
+
+        Q_ASSERT(xfer->hwndClient && xfer->pditem);
+        if (!xfer->hwndClient || !xfer->pditem)
+            return (MRESULT)FALSE;
+
+        Data::Request *req = d->requests.value(xfer->pditem->ulItemID);
+
+        // check that this item has been prepared (should always be the case
+        // because the target would never know our hwnd() otherwise)
+        Q_ASSERT(req); // prepared
+        Q_ASSERT(!req->xfer); // no DM_RENDER requested
+        if (!req || req->xfer)
+            return (MRESULT)FALSE;
+
+        DEBUG(() << "DefaultDragWorker: Got DM_RENDER to"
+                 << queryHSTR(xfer->hstrSelectedRMF) << "for item" << req->index
+                 << "(id " << xfer->pditem->ulItemID << ")");
+
+        QCString drm, drf;
+        if (!parseRMF(xfer->hstrSelectedRMF, drm, drf))
+            Q_ASSERT(/* parseRMF() = */ FALSE);
+
+        if (req->drm != drm || req->drf != drf) {
+            xfer->fsReply = DMFL_RENDERRETRY;
+            return (MRESULT)FALSE;
+        }
+
+        // indicate that DM_RENDER was requested
+        req->xfer = xfer;
+
+        DEBUG(() << "DefaultDragWorker: Will render from ["
+                 << req->provider->format(drf) << "] using provider"
+                 << req->provider);
+
+        // We would lile to post WM_USER to ourselves to do actual rendering
+        // after we return from DM_RENDER. But we are inside DrgDrag() at this
+        // point (our DND implementation is fully synchronous by design), so
+        // PM will not  deliver this message to us until we return from
+        // DrgDrag(). Thus, we have to send it.
+
+        WinSendMsg(hwnd(), WM_USER, MPFROMLONG(xfer->pditem->ulItemID),
+                                     MPFROMP(req));
+
+        return (MRESULT)TRUE;
+    }
+
+    if (msg == WM_USER) {
+        // sanity checks
+        Q_ASSERT(d->isInitialized());
+        if (!d->isInitialized())
+            return (MRESULT)FALSE;
+
+        ULONG itemId = LONGFROMMP(mp1);
+
+        // sanity checks
+        Data::Request *req = d->requests.value(itemId);
+        Q_ASSERT(req); // prepared
+        Q_ASSERT(req->xfer != NULL); // DM_RENDER requested
+        Q_ASSERT(!req->rendered); // not yet rendered
+        Q_ASSERT((Data::Request *) PVOIDFROMMP(mp2) == req);
+        if (!req || req->xfer == NULL || req->rendered ||
+             (Data::Request *) PVOIDFROMMP(mp2) != req)
+            return (MRESULT)FALSE;
+
+        Q_ASSERT(source() && req->provider && req->index < d->itemCnt);
+        if (!source() || !req->provider || req->index >= d->itemCnt)
+            return (MRESULT)FALSE;
+
+        DEBUG(() << "DefaultDragWorker: Got DO_RENDER for item " << req->index
+                 << "(id " << req->xfer->pditem->ulItemID << ")"
+                 << "provider"<< req->provider << "drm" << req->drm.data()
+                 << "drf" << req->drf.data());
+
+        bool renderOk = false;
+        QByteArray allData =
+            source()->encodedData(req->provider->format(req->drf));
+        QByteArray itemData;
+
+        renderOk = req->provider->provide(req->drf, allData,
+                                          req->index, itemData);
+
+        if (renderOk) {
+            enum DRM { OS2File, SharedMem } drmType;
+            if (qstrcmp(req->drm, DRM_SHAREDMEM) == 0) drmType = SharedMem;
+            else drmType = OS2File;
+
+            if (drmType == OS2File) {
+                QCString renderToName = queryHSTR(req->xfer->hstrRenderToName);
+                Q_ASSERT(!renderToName.isEmpty());
+                renderOk = !renderToName.isEmpty();
+                if (renderOk) {
+                    DEBUG(() << "DefaultDragWorker: Will write to" << renderToName);
+                    QFile file(QFile::decodeName(renderToName));
+                    renderOk = file.open(IO_WriteOnly);
+                    if (renderOk) {
+                        Q_LONG written =
+                            file.writeBlock(itemData.data(), itemData.size());
+                        renderOk = written == (Q_LONG) itemData.size() &&
+                                   file.status() == IO_Ok;
+                        file.close();
+                        if (renderOk && req->xfer->pditem->hstrType) {
+                            // since WPS ignores hstrType, write it manually
+                            // to the .TYPE EA of the created file
+                            qt_SetFileTypeEA(renderToName,
+                                queryHSTR(req->xfer->pditem->hstrType));
+                        }
+                    }
+                }
+            } else {
+                PID pid;
+                TID tid;
+                bool isSameProcess = false;
+                renderOk = WinQueryWindowProcess(req->xfer->hwndClient,
+                                                 &pid, &tid);
+                if (renderOk) {
+                    PPIB ppib = NULL;
+                    DosGetInfoBlocks(NULL, &ppib);
+                    isSameProcess = ppib->pib_ulpid == pid;
+
+                    ULONG sz = itemData.size() + sizeof (ULONG);
+                    char *ptr = NULL;
+                    APIRET rc = isSameProcess ?
+                                DosAllocMem((PPVOID) &ptr, sz,
+                                            PAG_COMMIT | PAG_READ | PAG_WRITE) :
+                                DosAllocSharedMem((PPVOID) &ptr, NULL, sz,
+                                                  OBJ_GIVEABLE | PAG_COMMIT |
+                                                  PAG_READ | PAG_WRITE);
+                    renderOk = rc == 0;
+                    if (renderOk && !isSameProcess) {
+                        rc = DosGiveSharedMem(ptr, pid, PAG_READ);
+                        renderOk = rc == 0;
+                    }
+                    if (renderOk) {
+                        *(ULONG *) ptr = itemData.size();
+                        memcpy(ptr + sizeof (ULONG), itemData.data(),
+                               itemData.size());
+                        req->xfer->hstrRenderToName = (HSTR) ptr;
+                        req->sharedMem = ptr;
+                        DEBUG(() << "DefaultDragWorker: Created shared memory "
+                                    "object" << ptr);
+#ifndef QT_NO_DEBUG
+                    } else {
+                        qWarning("DefaultDragWorker: DosAllocSharedMem/"
+                                 "DosGiveSharedMem failed with %ld", rc);
+#endif
+                    }
+#ifndef QT_NO_DEBUG
+                } else {
+                    qWarning("DefaultDragWorker: WinQueryWindowProcess failed"
+                             "with 0x%lX", WinGetLastError(NULLHANDLE));
+#endif
+                }
+            }
+        }
+
+        req->rendered = true;
+        // cumulative render result
+        d->renderOk &= renderOk;
+
+        DEBUG(() << "DefaultDragWorker: renderOk" << renderOk
+                 << "overall.renderOk" << d->renderOk);
+
+        // note that we don't allow the target to retry
+        USHORT reply = renderOk ? DMFL_RENDEROK : DMFL_RENDERFAIL;
+        DrgPostTransferMsg(req->xfer->hwndClient, DM_RENDERCOMPLETE,
+                           req->xfer, reply, 0, false);
+
+        // DRAGTRANSFER is no more necessary, free it early
+        qt_DrgFreeDragtransfer(req->xfer);
+#if defined(QT_DEBUG_DND)
+        {
+            ULONG size = ~0, flags = 0;
+            DosQueryMem(req->xfer, &size, &flags);
+            DEBUG(("DefaultDragWorker: Freed DRAGTRANSFER: "
+                   "req->xfer %p size %lu (0x%08lX) flags 0x%08lX",
+                   req->xfer, size, size, flags);
+        }
+#endif
+        req->xfer = NULL;
+
+        return (MRESULT)FALSE;
+    }
+
+    if (msg == DM_ENDCONVERSATION) {
+        // we don't check that isInitialized() is true here, because WPS
+        // (and probably some other apps) may send this message after
+        // cleanup() is called up on return from DrgDrag
+
+        ULONG itemId = LONGFROMMP(mp1);
+        ULONG flags = LONGFROMMP(mp2);
+
+        // sanity check (don't assert, see above)
+        Data::Request *req = d->requests.value(itemId);
+        Q_ASSERT(req);
+        if (!req)
+            return (MRESULT)FALSE;
+
+        DEBUG(() << "DefaultDragWorker: Got DM_ENDCONVERSATION for item " << req->index
+                 << " (id " << itemId << ") provider" << req->provider
+                 << "drm" << req->drm << "drf" << req->drf
+                 << "rendered" << req->rendered << "outdated" << !d->isInitialized());
+
+        // proceed further only if it's not an outdated request
+        // from the previous DND session
+        if (d->isInitialized()) {
+            if (!req->rendered) {
+                // we treat cancelling the render request (for any reason)
+                // as a failure
+                d->renderOk = false;
+            } else {
+                // the overall success is true only if target says Okay
+                d->renderOk &= flags == DMFL_TARGETSUCCESSFUL;
+            }
+        }
+
+        // delete the request
+        delete d->requests.take(itemId);
+
+        return (MRESULT)FALSE;
+    }
+
+    return (MRESULT)FALSE;
+}
+
+bool QPMMime::DefaultDragWorker::addProvider(const char *drf, Provider *provider,
+                                             ULONG itemCnt /* = 1 */)
+{
+    // make sure remaining requests from the previous DND session are deleted
+    d->cleanupRequests();
+
+    Q_ASSERT(drf && provider && itemCnt >= 1);
+    if (drf && provider && itemCnt >= 1) {
+        if (d->providers.count() == 0) {
+            // first provider
+            d->itemCnt = itemCnt;
+            d->providers.insert(Data::DrfProvider(drf, provider));
+            return true;
+        }
+        // next provider, must not be exclusive and itemCnt must match
+        if (!d->exclusive && d->itemCnt == itemCnt) {
+            // ensure there are no dups (several providers for the same drf)
+            if (!d->providerFor(drf))
+                d->providers.insert(Data::DrfProvider(drf, provider));
+            return true;
+        }
+    }
+    return false;
+}
+
+// static
+bool QPMMime::DefaultDragWorker::canRender(const char *drm)
+{
+    return qstrcmp(drm, DRM_SHAREDMEM) == 0 ||
+           qstrcmp(drm, DRM_OS2FILE) == 0;
+}
+
+//------------------------------------------------------------------------------
+
+struct QPMMime::DefaultDropWorker::Data
+{
+    struct MimeProvider
+    {
+        MimeProvider() : prov(NULL) {}
+        MimeProvider(const QString &m, Provider *p) : mime(m), prov(p) {}
+        const QString mime;
+        Provider * const prov;
+    };
+
+    typedef QList<MimeProvider> MimeProviderList;
+
+    Provider *providerFor(const QString &mime)
+    {
+        foreach (const MimeProvider &p, providers) {
+            if (p.mime == mime)
+                return p.prov;
+        }
+        return NULL;
+    }
+
+    bool exclusive : 1;
+    MimeProviderList providers;
+
+    bool sending_DM_RENDER : 1;
+    bool got_DM_RENDERCOMPLETE : 1;
+    USHORT flags_DM_RENDERCOMPLETE;
+    int waiting_DM_RENDERCOMPLETE;
+};
+
+QPMMime::DefaultDropWorker::DefaultDropWorker() : d(new Data())
+{
+    d->exclusive = false;
+    d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
+    d->flags_DM_RENDERCOMPLETE = 0;
+    d->waiting_DM_RENDERCOMPLETE = 0;
+}
+
+QPMMime::DefaultDropWorker::~DefaultDropWorker()
+{
+    delete d;
+}
+
+void QPMMime::DefaultDropWorker::cleanup(bool isAccepted, bool isActAccepted)
+{
+    if (d->waiting_DM_RENDERCOMPLETE != 0) {
+#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->providers.clear();
+    d->exclusive = false;
+    d->sending_DM_RENDER = d->got_DM_RENDERCOMPLETE = false;
+    d->flags_DM_RENDERCOMPLETE = 0;
+    d->waiting_DM_RENDERCOMPLETE = 0;
+}
+
+bool QPMMime::DefaultDropWorker::isExclusive() const
+{
+    return d->exclusive;
+}
+
+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;
+    }
+
+    static bool srandDone = false;
+    if (!srandDone) {
+        srand(time(NULL));
+        srandDone = true;
+    }
+
+    ULONG num = rand();
+    enum { Attempts = 100 };
+    int attempts = Attempts;
+
+    QCString tmpName;
+    do {
+        tmpName.sprintf("%s\\%08lX.tmp", tmpDir, num);
+        if (!QFile::exists(QFile::decodeName(tmpName)))
+            break;
+        num = rand();
+    } while (--attempts > 0);
+
+    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;
+
+    Q_ASSERT(info());
+    if (!info())
+        return data;
+
+    ULONG itemCount = DrgQueryDragitemCount(info());
+    Q_ASSERT(itemCount);
+    if (!itemCount)
+        return data;
+
+    Provider *provider = d->providerFor(format);
+    if (!provider)
+        return data;
+
+    const char *drf = provider->drf(format);
+    Q_ASSERT(drf);
+    if (!drf)
+        return data;
+
+    // Note: Allocating and freeing DRAGTRANSFER structures is a real mess. It's
+    // absolutely unclear how they can be reused for multiple items and/or render
+    // requests. My practice shows, that they cannot be reused at all, especially
+    // when the source and the target are the same process: if we have multiple
+    // items and use the same DRAGTRANSFER for all of them, the source will call
+    // DrgFreeDragtransfer() every time that will eventually destroy the memory
+    // object before the target finishes to work with it, so that the next
+    // DrgFreeDragtransfer() will generate a segfault in PMCTLS. Also note that
+    // using a number > 1 as an argument to DrgAllocDragtransfer() won't help
+    // because that will still allocate a single memory object. Thus, we will
+    // always allocate a new struct per every item. It seems to work.
+
+    QCString renderToName = composeTempFileName();
+    HSTR hstrRenderToName = DrgAddStrHandle(renderToName);
+
+    HSTR rmfOS2File =
+        DrgAddStrHandle(QCString().sprintf("<"DRM_OS2FILE",%s>", drf));
+    HSTR rmfSharedMem =
+        DrgAddStrHandle(QCString().sprintf("<"DRM_SHAREDMEM",%s>", drf));
+
+    MRESULT mrc;
+    bool renderOk = false;
+
+    DRAGTRANSFER *xfer = NULL;
+    QCString srcFileName;
+
+    QByteArray allData, itemData;
+
+    for (ULONG i = 0; i < itemCount; ++i) {
+        DRAGITEM *item = DrgQueryDragitemPtr(info(), i);
+        Q_ASSERT(item);
+        if (!item) {
+            renderOk = false;
+            break;
+        }
+
+        enum { None, OS2File, SharedMem } drm = None;
+        bool needToTalk = true;
+
+        // determine the mechanism to use (prefer DRM_SHAREDMEM)
+
+        if (DrgVerifyRMF(item, DRM_SHAREDMEM, drf) &&
+             DrgVerifyRMF(item, DRM_SHAREDMEM, DRF_POINTERDATA))
+            drm = SharedMem;
+        if (DrgVerifyRMF(item, DRM_OS2FILE, drf)) {
+            srcFileName = querySourceNameFull(item);
+            // If the source provides the full file name, we prefer DRM_OS2FILE
+            // even if there is also DRM_SHAREDMEM available because we don't
+            // need to do any communication in this case at all. This will help
+            // with some native drag sources (such as DragText) that cannot send
+            // DM_RENDERCOMPLETE synchronously (before we return from DM_DROP)
+            // and would hang otherwise.
+            if (!srcFileName.isEmpty()) {
+                needToTalk = false;
+                drm = OS2File;
+            } else if (drm == None) {
+                srcFileName = renderToName;
+                drm = OS2File;
+            }
+        }
+        Q_ASSERT(drm != None);
+        if (drm == None) {
+            renderOk = false;
+            break;
+        }
+
+        if (needToTalk) {
+            // need to perform a conversation with the source,
+            // allocate a new DRAGTRANSFER structure for each item
+            xfer = DrgAllocDragtransfer(1);
+            Q_ASSERT(xfer);
+            if (!xfer) {
+                renderOk = false;
+                break;
+            }
+
+            xfer->cb = sizeof(DRAGTRANSFER);
+            xfer->hwndClient = hwnd();
+            xfer->ulTargetInfo = (ULONG) info();
+            xfer->usOperation = info()->usOperation;
+
+            xfer->pditem = item;
+            if (drm == OS2File) {
+                xfer->hstrSelectedRMF = rmfOS2File;
+                xfer->hstrRenderToName = hstrRenderToName;
+            } else {
+                xfer->hstrSelectedRMF = rmfSharedMem;
+                xfer->hstrRenderToName = 0;
+            }
+
+            DEBUG(() << "DefaultDropWorker: Will use"
+                     << queryHSTR(xfer->hstrSelectedRMF) << "to render item" << item);
+
+            mrc = (MRESULT)TRUE;
+            if ((item->fsControl & DC_PREPARE) |
+                 (item->fsControl & DC_PREPAREITEM)) {
+                DEBUG(("DefaultDropWorker: Sending DM_RENDERPREPARE to 0x%08lX...",
+                       info()->hwndSource));
+                mrc = DrgSendTransferMsg(info()->hwndSource, DM_RENDERPREPARE,
+                                         MPFROMP (xfer), 0);
+                DEBUG(("DefaultDropWorker: Finisned sending DM_RENDERPREPARE\n"
+                       " mrc %p xfer->fsReply 0x%08hX", mrc, xfer->fsReply);
+                renderOk = (BOOL) mrc;
+            }
+
+            if ((BOOL) mrc) {
+                DEBUG(("DefaultDropWorker: Sending DM_RENDER to 0x%08lX...",
+                       item->hwndItem));
+                d->sending_DM_RENDER = true;
+                mrc = DrgSendTransferMsg(item->hwndItem, DM_RENDER,
+                                         MPFROMP (xfer), 0);
+                d->sending_DM_RENDER = false;
+                DEBUG(("DefaultDropWorker: Finisned Sending DM_RENDER\n"
+                       " mrc %p xfer->fsReply 0x%hX got_DM_RENDERCOMPLETE %d",
+                       mrc, xfer->fsReply, d->got_DM_RENDERCOMPLETE));
+
+                if (!(BOOL) mrc || d->got_DM_RENDERCOMPLETE) {
+                    if (d->got_DM_RENDERCOMPLETE)
+                        renderOk = (d->flags_DM_RENDERCOMPLETE & DMFL_RENDEROK);
+                    else
+                        renderOk = false;
+                } else {
+                    // synchronously wait for DM_RENDERCOMPLETE
+                    d->waiting_DM_RENDERCOMPLETE = qApp->loopLevel() + 1;
+                    DEBUG(() << "DefaultDropWorker: Waiting for DM_RENDERCOMPLETE...");
+                    int level = qApp->eventLoop()->enterLoop();
+                    DEBUG(("DefaultDropWorker: Finished waiting for "
+                           "DM_RENDERCOMPLETE (%d)\n"
+                           " got_DM_RENDERCOMPLETE %d usFS 0x%hX",
+                           level, d->got_DM_RENDERCOMPLETE, d->flags_DM_RENDERCOMPLETE));
+                    Q_UNUSED(level);
+                    // JFTR: at this point, cleanup() might have been called,
+                    // as a result of either program exit or getting another
+                    // DM_DRAGOVER (if the source app has crashed) before getting
+                    // 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);
+                }
+
+                d->got_DM_RENDERCOMPLETE = false;
+            }
+        } else {
+            DEBUG(() << "DefaultDropWorker: Source supports <" << DRM_OS2FILE
+                     << "," << drf << "> and provides a file" << srcFileName
+                     << "for item" << item << "(no need to render)");
+            renderOk = true;
+        }
+
+        if (renderOk) {
+            if (drm == OS2File) {
+                DEBUG(() << "DefaultDragWorker: Will read from" << srcFileName);
+                QFile file(QFile::decodeName(srcFileName));
+                renderOk = file.open(IO_ReadOnly);
+                if (renderOk) {
+                    itemData = file.readAll();
+                    renderOk = file.status() == IO_Ok;
+                    file.close();
+                }
+                bool ok = file.remove();
+                Q_ASSERT((ok = ok));
+            } else {
+                Q_ASSERT(xfer->hstrRenderToName);
+                renderOk = xfer->hstrRenderToName != 0;
+                if (renderOk) {
+                    const char *ptr = (const char *) xfer->hstrRenderToName;
+                    ULONG size = ~0;
+                    ULONG flags = 0;
+                    APIRET rc = DosQueryMem((PVOID) ptr, &size, &flags);
+                    renderOk = rc == 0;
+                    if (renderOk) {
+                        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) ==
+                                 (PAG_COMMIT | PAG_READ | PAG_BASE));
+                        renderOk = flags & (PAG_COMMIT | PAG_READ | PAG_BASE) ==
+                                   (PAG_COMMIT | PAG_READ | PAG_BASE);
+#ifndef QT_NO_DEBUG
+                    } else {
+                        qWarning("DefaultDropWorker: DosQueryMem failed with %ld", rc);
+#endif
+                    }
+                    if (renderOk) {
+                        ULONG realSize = *(ULONG *) ptr;
+                        DEBUG(() << "DefaultDropWorker: realSize" << realSize);
+                        Q_ASSERT(realSize <= size);
+                        renderOk = realSize <= size;
+                        if (renderOk) {
+                            itemData.resize(realSize);
+                            memcpy(itemData.data(), ptr + sizeof (ULONG), realSize);
+                        }
+                    }
+                    // free memory only if it is given by another process,
+                    // otherwise DefaultDragWorker will free it
+                    if (flags & PAG_SHARED)
+                        DosFreeMem((PVOID) xfer->hstrRenderToName);
+                }
+            }
+        }
+
+        if (renderOk)
+            renderOk = provider->provide(format, i, itemData, allData);
+
+        if (needToTalk) {
+            // free the DRAGTRANSFER structure
+            DrgFreeDragtransfer(xfer);
+#if defined(QT_DEBUG_DND)
+            {
+                ULONG size = ~0, flags = 0;
+                DosQueryMem(xfer, &size, &flags);
+                DEBUG(("DefaultDropWorker: Freed DRAGTRANSFER: "
+                       "xfer=%p, size=%lu(0x%08lX), flags=0x%08lX",
+                       xfer, size, size, flags));
+            }
+#endif
+            xfer = NULL;
+        }
+
+        if (!renderOk)
+            break;
+    }
+
+    DEBUG(() << "DefaultDropWorker: renderOk" << renderOk);
+
+    DrgDeleteStrHandle(rmfSharedMem);
+    DrgDeleteStrHandle(rmfOS2File);
+    DrgDeleteStrHandle(hstrRenderToName);
+
+    if (renderOk)
+        data = allData;
+
+    return data;
+}
+
+MRESULT QPMMime::DefaultDropWorker::message(ULONG msg, MPARAM mp1, MPARAM mp2)
+{
+    switch (msg) {
+        case DM_RENDERCOMPLETE: {
+            // sanity check
+            Q_ASSERT(info());
+            if (!info())
+                return (MRESULT)FALSE;
+
+            DEBUG("DefaultDropWorker: Got DM_RENDERCOMPLETE");
+            d->got_DM_RENDERCOMPLETE = true;
+            d->flags_DM_RENDERCOMPLETE = SHORT1FROMMP(mp2);
+
+            if (d->sending_DM_RENDER)
+            {
+                DRAGTRANSFER *xfer = (DRAGTRANSFER *) mp1;
+#ifndef QT_NO_DEBUG
+                qWarning("Drag item 0x%08lX sent DM_RENDERCOMPLETE w/o first "
+                         "replying to DM_RENDER!\n"
+                         "Contact the drag source developer.",
+                         xfer->pditem->hwndItem);
+#endif
+                return (MRESULT)FALSE;
+            }
+
+            // stop synchronous waiting for DM_RENDERCOMPLETE
+            if (d->waiting_DM_RENDERCOMPLETE != 0)
+                qApp->eventLoop()->exitLoop();
+            return (MRESULT)FALSE;
+        }
+        default:
+            break;
+    }
+
+    return (MRESULT)FALSE;
+}
+
+bool QPMMime::DefaultDropWorker::addProvider(const char *format,
+                                             Provider *provider)
+{
+    Q_ASSERT(format && provider);
+    if (format && 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));
+        return true;
+    }
+    return false;
+}
+
+bool QPMMime::DefaultDropWorker::addExclusiveProvider(const char *format,
+                                                      Provider *provider)
+{
+    Q_ASSERT(format && provider);
+    if (format && provider && !d->exclusive) {
+        d->exclusive = true;
+        d->providers.clear();
+        d->providers.insert(Data::MimeProvider(format, provider));
+        return true;
+    }
+    return false;
+}
+
+// static
+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));
+}
+
+// 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)
+{
+    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();
+            continue;
+        }
+        if (qstrcmp(drm, DRM_SHAREDMEM) == 0) {
+            const char *drf = mech->next();
+            // accept DRM_SHAREDMEM only if there is DRF_POINTERDATA
+            for(; drf; drf = mech->next()) {
+                if (qstrcmp(drf, DRF_POINTERDATA) == 0)
+                    break;
+            }
+            if (drf) {
+                mech = list.next();
+                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();
+    }
+
+    return true;
+}
+
+#endif // !QT_NO_DRAGANDDROP
+
+//------------------------------------------------------------------------------
 
 class QPMMimeList
@@ -159 +1307 @@
     if (!cf) {
 #ifndef QT_NO_DEBUG
-        qWarning("QPMMime: WinAddAtom failed with %lX",
+        qWarning("QPMMime: WinAddAtom failed with 0x%lX",
                  WinGetLastError(NULLHANDLE));
 #endif