Changeset 458 for trunk/src/gui/kernel/qdnd_pm.cpp

Timestamp:

Jan 21, 2010, 12:46:24 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: DnD: Added support for drag sources that don't support synchronous data rendering (such as EPM). At present, these applications must be hard coded in qdnd_pm.cpp using the EXE name and the window class name.

File:

• trunk/src/gui/kernel/qdnd_pm.cpp (modified) (10 diffs)

trunk/src/gui/kernel/qdnd_pm.cpp

@@ -53 +53 @@
 #include "qdesktopwidget.h"
 #include "qfile.h"
+#include "qfileinfo.h"
 #include "qdnd_p.h"
 #include "qdebug.h"
@@ -90 +91 @@
     void reset() { reset(false); }
 
-    void setDropped(bool d) { dropped = d; }
-    bool isDropped() const { return dropped; }
+    void setInFakeDrop(bool d) { fakeDrop = d; }
+    bool inFakeDrop() const { return fakeDrop; }
 
     DRAGINFO *info() const { return di; }
+    bool canSyncRender() const { return canSyncRndr; }
 
     bool hasFormat_sys(const QString &mimeType);
@@ -106 +108 @@
 
     bool initialized : 1;
-    bool dropped : 1;
+    bool fakeDrop : 1;
     bool gotWorkers : 1;
+    bool canSyncRndr : 1;
 
     DRAGINFO *di;
@@ -125 +128 @@
 
 QPMDragData::QPMDragData()
-    : initialized(false), dropped(false)
-    , gotWorkers(false), di(NULL)
+    : initialized(false), fakeDrop(false)
+    , gotWorkers(false), canSyncRndr(false), di(NULL)
     , lastDragOverWidget(0), lastDragOverOp(0)
     , supportedOps(0), sourceAllowsOp(false)
@@ -147 +150 @@
     initialized = true;
     di = info;
+
+    // Detect if the source supports synchronous rendering which means it can
+    // process DM_RENDER and reply with DM_RENDERCOMPLETE from within both
+    // DM_DRAGOVER and DM_DROP (i.e. while it is running the DnD session with
+    // DrgDrag()). Mozilla apps are known to only support synchronous rendering
+    // (an attempt to send DM_RENDER to them after DM_DROP will crash them).
+    // By the contrast, EPM only supports asyncronous rendering (it will hang
+    // if we send DM_RENDER and/or wait for DM_RENDERCOMPLETE before returning
+    // from DM_DRAGOVER/DM_DROP). WPS (e.g. desktop folders) seem to support
+    // both (we prefer the syncrhonous rendering in such cases since it lets
+    // Qt apps access dragged data right from QDragEnterEvent/QDragLeaveEvent
+    // and QDropEvent message handlers which is used by many of them for better
+    // visualization.
+
+    // get class name
+    QByteArray className(256, '\0');
+    LONG classNameLen = WinQueryClassName(info->hwndSource,
+                                          className.size(), className.data());
+    className.truncate(classNameLen);
+
+    DEBUG(("QPMDragData::initialize: info->hwndSource %08lX className \"%s\"",
+           info->hwndSource, QString::fromLocal8Bit(className).toUtf8().data()));
+
+    // get EXE name
+    PID pid = 0;
+    TID tid = 0;
+    QByteArray exePath(CCHMAXPATH, '\0');
+    BOOL ok = WinQueryWindowProcess(info->hwndSource, &pid, &tid);
+    if (ok) {
+        QByteArray buf(4192, '\0');
+        APIRET arc = DosQuerySysState(QS_PROCESS, 0, pid, tid,
+                                      buf.data(), buf.size());
+        if (arc == NO_ERROR) {
+            qsGrec_t *grec = *(qsGrec_t **)buf.data();
+            qsPrec_t *prec = (qsPrec_t *)((ULONG)grec + sizeof(qsGrec_t));
+            arc = DosQueryModuleName(prec->hMte, exePath.size(), exePath.data());
+            if (arc == NO_ERROR)
+                exePath.truncate(qstrlen(exePath));
+        }
+    }
+
+    DEBUG(("QPMDragData::initialize: pid %lu exePath \"%s\"",
+           pid, QString::fromLocal8Bit(exePath).toUtf8().data()));
+
+    QString exeName = QFileInfo(QFile::decodeName(exePath)).fileName();
+
+    // start with a positive
+    canSyncRndr = true;
+
+    if (exeName.toUpper() == QLatin1String("EPM.EXE") &&
+        qstrcmp(className, "FileWnd") == 0) {
+        // EPM only supports async rendering
+        canSyncRndr = false;
+    }
+
+    DEBUG(("QPMDragData::initialize: canSyncRender %d", canSyncRndr));
 }
 
@@ -196 +255 @@
     workers.clear();
     di = 0;
-    initialized = dropped = gotWorkers = false;
+    initialized = fakeDrop = gotWorkers = canSyncRndr = false;
 }
 
@@ -229 +288 @@
     QVariant result;
 
-    // we may only do data transfer after DM_DROP is sent. Return shortly.
-    if (!isDropped())
+    // If the source doesn't support synchronous rendering, we may only do data
+    // transfer after DM_DROP is processed by us. Return shortly.
+    if (!canSyncRender() && !inFakeDrop())
         return result;
 
@@ -360 +420 @@
 void QDragManager::sendDropEvent(QWidget *receiver, QEvent *event)
 {
+    // Note: inDrag = true causes QWidget::getPS() to return a special HPS for
+    // drawing during DnD. However, if we send the message from a fake DM_DROP
+    // that we post to ourselves to render data after the DnD session ends
+    // (inFakeDrop = true), a normal HPS has to be used.
+
+    bool inFakeDrop = dropData->d->inFakeDrop();
+
     Q_ASSERT(!inDrag);
-    inDrag = true;
+    if (!inFakeDrop)
+        inDrag = true;
+
     QApplication::sendEvent(receiver, event);
-    // make sure that all issued update requests are handled before we
-    // return from the DM_DRAGOVER/DM_DRAGLEAVE/DM_DROP message; otherwise
-    // we'll get screen corruption due to unexpected screen updates while
-    // dragging
-    QApplication::sendPostedEvents(0, QEvent::UpdateRequest);
-    inDrag = false;
+
+    if (!inFakeDrop) {
+        // make sure that all issued update requests are handled before we
+        // return from the DM_DRAGOVER/DM_DRAGLEAVE/DM_DROP message; otherwise
+        // we'll get screen corruption due to unexpected screen updates while
+        // dragging
+        QApplication::sendPostedEvents(0, QEvent::UpdateRequest);
+        inDrag = false;
+    }
 }
 
@@ -561 +633 @@
             DEBUG(("DM_DROP: hwnd %lX di %p", qmsg.hwnd, qmsg.mp1));
 
-            // Odin32 apps produce incorrect message flow, ignore
-            Q_ASSERT(dragData->lastDragOverWidget != 0);
-            if (dragData->lastDragOverWidget == 0)
-                return 0;
-
-            // Odin32 apps send DM_DROP even if we replied DOR_NEVERDROP or
-            // DOR_NODROP, simulate DM_DRAGLEAVE
-            Q_ASSERT(dragData->lastDropReply == DOR_DROP);
-            if (dragData->lastDropReply != DOR_DROP) {
-                QMSG qmsg2 = qmsg;
-                qmsg2.msg = DM_DRAGLEAVE;
-                dispatchDragAndDrop(widget, qmsg2);
-                return 0;
+            // sanity
+            Q_ASSERT(!dragData->canSyncRender() || qmsg.mp1);
+
+            DRAGINFO *info = 0;
+
+            if (dragData->canSyncRender() || qmsg.mp1) {
+                // Odin32 apps produce incorrect message flow, ignore
+                Q_ASSERT(dragData->lastDragOverWidget != 0);
+                if (dragData->lastDragOverWidget == 0)
+                    return 0;
+
+                // Odin32 apps send DM_DROP even if we replied DOR_NEVERDROP or
+                // DOR_NODROP, simulate DM_DRAGLEAVE
+                Q_ASSERT(dragData->lastDropReply == DOR_DROP);
+                if (dragData->lastDropReply != DOR_DROP) {
+                    QMSG qmsg2 = qmsg;
+                    qmsg2.msg = DM_DRAGLEAVE;
+                    dispatchDragAndDrop(widget, qmsg2);
+                    return 0;
+                }
+
+                // sanity
+                Q_ASSERT((DRAGINFO *)qmsg.mp1 == dragData->info());
+
+                info = (DRAGINFO *)qmsg.mp1;
+                ok = DrgAccessDraginfo(info);
+                Q_ASSERT(ok && info);
+                if (!ok || !info)
+                    return 0;
+
+                if (!dragData->canSyncRender()) {
+                    // The source doesn't support syncrhonous rendering (i.e.
+                    // it won't issue DM_RENDERCOMPLETE until we return from
+                    // DM_DROP) so we have to post a message to ourselves to do
+                    // it asynchronously. For simplicity, we reuse DM_DRAG with
+                    // mp1 = 0 for this purpose.
+                    WinPostMsg(qmsg.hwnd, DM_DROP, 0, 0);
+                    return 0;
+                }
+            } else {
+                // we're in a fake DM_DROP we posted above
+                dragData->setInFakeDrop(true);
+                info = dragData->info();
+                Q_ASSERT(info);
             }
-
-            DRAGINFO *info = (DRAGINFO *)qmsg.mp1;
-            ok = DrgAccessDraginfo(info);
-            Q_ASSERT(ok && info);
-            if (!ok || !info)
-                return 0;
 
             // flip y coordinate
@@ -597 +694 @@
 
             QMimeData *data = manager->source() ? manager->dragPrivate()->data : manager->dropData;
-
-            dragData->setDropped(true);
 
             QDropEvent de(pnt, dragData->lastAction, data, mouseButtons(),