Changeset 442

Timestamp:

Dec 28, 2009, 2:50:23 AM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: A bunch of updates to the DND code (the drop site party).

Location:

trunk/src/gui/kernel

Files:

• qdnd_pm.cpp (modified) (17 diffs)
• qmime.h (modified) (6 diffs)
• qmime_pm.cpp (modified) (2 diffs)

trunk/src/gui/kernel/qdnd_pm.cpp

@@ -78 +78 @@
     ~QPMDragData();
 
-    void initialize( DRAGINFO *di );
-    void reset( bool isAccepted, bool isActAccepted );
-    void reset() { reset( FALSE, FALSE ); }
-
-    void setDropped( bool d ) { dropped = d; }
+    void initialize();
+    void reset();
+    void reset() { reset(); }
+
+    void setDropped() { dropped = d; }
     bool isDropped() const { return dropped; }
 
@@ -100 +100 @@
 
     DRAGINFO *di;
-    // @todo later
-//  QPtrList<QPMMime::DropWorker> workers;
+    QList<QPMMime::DropWorker*> workers;
 };
 
@@ -118 +117 @@
 
     QDragManager *manager = QDragManager::self();
-    Q_ASSERT(manager->dropData->d == this);
-    manager->dropData->d = 0;
+    if (manager) {
+        Q_ASSERT(manager->dropData->d == this);
+        manager->dropData->d = 0;
+    }
 }
 
@@ -140 +141 @@
     gotWorkers = true;
 
-    // @todo later
-#if 0
-    // go through all convertors and collect DropWorkers to use
-    QPtrList<QPMMime> mimes = QPMMime::all();
-    for ( QPMMime *mime = mimes.first(); mime; mime = mimes.next() ) {
-        QPMMime::DropWorker *wrk = mime->dropWorkerFor( di );
-        if ( wrk ) {
-            if ( wrk->isExclusive() ) {
+    // go through all converters and collect DropWorkers to use
+    foreach (QPMMime *mime, QPMMime::all()) {
+        QPMMime::DropWorker *wrk = mime->dropWorkerFor(di);
+        if (wrk) {
+            if (wrk->isExclusive()) {
                 // ignore all other workers if some of them identified itself
                 // as exclusive
                 workers.clear();
-                workers.append( wrk );
+                workers.append();
                 break;
             }
-            // ensure there are no duplicates
-            if ( !workers.containsRef( wrk ) )
-                workers.append( wrk );
+            // ensure there are no duplicates
+            if ()
+                workers.append();
         }
     }
@@ -163 +161 @@
 
     // init all workers
-    for ( QPMMime::DropWorker *w = workers.first(); w; w = workers.next() ) {
+    for) {
         w->nfo = di;
         w->init();
     }
-#endif
-}
-
-void QPMDragData::reset(bool isAccepted, bool isActAccepted)
+}
+
+void QPMDragData::reset(bool isAccepted)
 {
     if (!initialized)
         return;
 
-    // @todo later
-#if 0
     // cleanup all workers
-    for ( QPMMime::DropWorker *w = workers.first(); w; w = workers.next() ) {
-        w->cleanup( isAccepted, isActAccepted );
-        w->nfo = NULL;
+    for) {
+        w->cleanup();
+        w->nfo = ;
     }
 
     workers.clear();
-#endif
-    di = NULL;
-    initialized = dropped = gotWorkers = FALSE;
+    di = 0;
+    initialized = dropped = gotWorkers = false;
 }
 
 bool QPMDragData::hasFormat_sys(const QString &mimeType)
 {
+
+
+
+
+
+
+
     return false;
 }
@@ -196 +197 @@
 QStringList QPMDragData::formats_sys()
 {
-    return QStringList();
+    QStringList mimes;
+
+    if (!gotWorkers)
+        initWorkers();
+
+    foreach (QPMMime::DropWorker *w, workers)
+        mimes << w->formats();
+
+    return mimes;
 }
 
@@ -208 +217 @@
         return result;
 
+
+
+
+
+
+
+
+
+
+
     return result;
 }
 
-// @todo later
-#if 0
-class QPMDropEvent : public QDropEvent
-{
-public:
-    QPMDropEvent( const QPoint &pos, QPMDragData *data )
-        : QDropEvent( pos ) { d = data; }
-
-    inline bool isTrulyAccepted() const { return accpt; }
-    inline bool isActionTrulyAccepted() const { return accptact; }
-};
-
-class QPMDragEnterEvent : public QDragEnterEvent
-{
-public:
-    QPMDragEnterEvent( const QPoint &pos, QPMDragData *data )
-        : QDragEnterEvent( pos ) { d = data; }
-
-    inline bool isTrulyAccepted() const { return accpt; }
-    inline bool isActionTrulyAccepted() const { return accptact; }
-};
-
-class QPMDragMoveEvent : public QDragMoveEvent
-{
-public:
-    QPMDragMoveEvent( const QPoint &pos, QPMDragData *data )
-        : QDragMoveEvent( pos ) { d = data; }
-
-    inline bool isTrulyAccepted() const { return accpt; }
-    inline bool isActionTrulyAccepted() const { return accptact; }
-};
-
-bool QDropEvent::provides( const char* mimeType ) const
-{
-    QPMDragData *data = static_cast<QPMDragData *> (d);
-    Q_ASSERT( data );
-    if ( !data )
-        return FALSE;
-
-    return data->provides( mimeType );
-}
-
-const char *QDropEvent::format( int fn ) const
-{
-    QPMDragData *data = static_cast<QPMDragData *> (d);
-    Q_ASSERT( data );
-    if ( !data )
-        return NULL;
-
-    return data->format( fn );
-}
-
-QByteArray QDropEvent::encodedData( const char *format ) const
-{
-    QByteArray array;
-
-    QPMDragData *data = static_cast<QPMDragData *> (d);
-    Q_ASSERT( data );
-
-    if ( !data || !data->isDropped() ) {
-        // This is a QDragEnterEvent/QDragMoveEvent subclass; we cannot provide
-        // any MIME contents yet because it's impossible to do data transfers
-        // before DM_DROP is sent. Return shortly.
-        return array;
-    }
-
-    array = data->encodedData( format );
-    return array;
-}
-#endif
+static Qt::DropActions toQDragDropActions(USHORT ops)
+{
+    Qt::DropActions actions = Qt::IgnoreAction;
+    if (ops & DO_LINKABLE)
+        actions |= Qt::LinkAction;
+    if (ops & DO_COPYABLE)
+        actions |= Qt::CopyAction;
+    if (ops & DO_MOVEABLE)
+        actions |= Qt::MoveAction;
+    return actions;
+}
+
+static Qt::DropAction toQDragDropAction(USHORT op)
+{
+    if (op == DO_LINK)
+        return Qt::LinkAction;
+    if (op == DO_COPY)
+        return Qt::CopyAction;
+    if (op == DO_MOVE)
+        return Qt::MoveAction;
+    return Qt::IgnoreAction;
+}
+
+static USHORT toPmDragDropOp(Qt::DropActions action)
+{
+    if (action & Qt::LinkAction)
+        return DO_LINK;
+    if (action & Qt::CopyAction)
+        return DO_COPY;
+    if (action & Qt::MoveAction)
+        return DO_MOVE;
+    return DO_UNKNOWN;
+}
 
 /*!
@@ -288 +270 @@
 MRESULT qt_dispatchDragAndDrop(QWidget *widget, const QMSG &qmsg)
 {
+
+
     static HWND lastDragOverHwnd = 0; // last target window
     static USHORT lastDragOverOp = 0; // last DM_DRAGOVER operation
-    static USHORT lastRealOp = 0; // last real op (never DO_DEFAULT or DO_UNKNOWN)
-    static USHORT defaultOp = 0; // default op for DO_DEFAULT or DO_UNKNOWN
 
     static USHORT supportedOps = 0; // operations supported by all items
-    static bool sourceAllowsOp = FALSE; // does source allow requested operation
-
-    static bool lastAccept = FALSE; // last reply from the target
-    static bool lastAcceptAction = FALSE; // last action reply from the target
+
+    static USHORT lastDropReply = DOR_NEVERDROP; // last reply to DM_DRAGOVER
+    static USHORT lastOpRequest = DO_UNKNOWN; // last op requested in DM_DRAGOVER
+
+    static Qt::DropAction lastProposedAction = Qt::IgnoreAction; // last proposed action
+    static QRect lastAnswerRect; // last accepted rectangle from the target
+    // @todo use lastAnswerRect to compress DM_DRAGOVER events
 
     static QPMDragData dragData;
@@ -305 +290 @@
     BOOL ok = FALSE;
 
-    switch( qmsg.msg ) {
+    switch) {
         case DM_DRAGOVER: {
+
+
+
             bool first = lastDragOverHwnd != qmsg.hwnd;
             if (first) {
                 // the first DM_DRAGOVER message
                 lastDragOverHwnd = qmsg.hwnd;
-                lastAccept = lastAcceptAction = FALSE;
+                lastDropReply = DOR_NEVERDROP;
+                lastOpRequest = DO_UNKNOWN;
+                lastProposedAction = Qt::IgnoreAction;
+                lastAnswerRect = QRect();
                 supportedOps = DO_COPYABLE | DO_MOVEABLE | DO_LINKABLE;
                 // ensure drag data is reset (just in case of a wrong msg flow...)
@@ -355 +346 @@
                         // items don't have even a single common operation...
                         dropReply = DOR_NEVERDROP;
-                    } else {
-                        // determine the default operation
-                        // (in order MOVE, COPY, LINK, for compatibility with Win32)
-                        if      (supportedOps & DO_MOVEABLE) defaultOp = DO_MOVE;
-                        else if (supportedOps & DO_COPYABLE) defaultOp = DO_COPY;
-                        else if (supportedOps & DO_LINKABLE) defaultOp = DO_LINK;
-                        else Q_ASSERT(false); // should never happen
                     }
                 }
@@ -367 +351 @@
 
             if (dropReply != DOR_NEVERDROP) {
+
+
 
                 if (first || lastDragOverOp != info->usOperation) {
                     // the current drop operation was changed by a modifier key
                     lastDragOverOp = info->usOperation;
-                    lastRealOp = info->usOperation;
-                    if (lastRealOp == DO_DEFAULT || lastRealOp == DO_UNKNOWN) {
+                    ealOp = info->usOperation;
+                    if (ealOp == DO_UNKNOWN) {
                         // the default operation is requested
-                        lastRealOp = defaultOp;
+                        ;
                     }
                     sourceAllowsOp =
-                        ((supportedOps & DO_MOVEABLE) && lastRealOp == DO_MOVE) ||
-                        ((supportedOps & DO_COPYABLE) && lastRealOp == DO_COPY) ||
-                        ((supportedOps & DO_LINKABLE) && lastRealOp == DO_LINK);
+                        ((supportedOps & DO_MOVEABLE) && ealOp == DO_MOVE) ||
+                        ((supportedOps & DO_COPYABLE) && ealOp == DO_COPY) ||
+                        ((supportedOps & DO_LINKABLE) && ealOp == DO_LINK);
                 }
 
@@ -387 +373 @@
                 // the drop. Other platforms seem to do the same.
 
-                // convert the operation to an Action
-                Qt::DropAction action = Qt::CopyAction;
-                if      (lastRealOp == DO_COPY) action = Qt::CopyAction;
-                else if (lastRealOp == DO_MOVE) action = Qt::MoveAction;
-                else if (lastRealOp == DO_LINK) action = Qt::LinkAction;
-                else Q_ASSERT(false); // should never happen
-
                 // flip y coordinate
                 QPoint pnt(info->xDrop, info->yDrop);
@@ -399 +378 @@
                 pnt = widget->mapFromGlobal(pnt);
 
-                // initialize drag data used in QPMDrag.../QPMDrop... events
-                if (first)
+                QDragManager *manager = QDragManager::self();
+                QMimeData *data = manager->source() ? manager->dragPrivate()->data : manager->dropData;
+
+                Qt::DropAction action = toQDragDropAction(lastOpRequest);
+
+                if (first) {
                     dragData.initialize(info);
-
-                // @todo later
-#if 0
-                QDropEvent *de = NULL;
-                QPMDragEnterEvent *dee = NULL;
-                QPMDragMoveEvent *dme = NULL;
-
-                if (first)
-                    de = dee = new QPMDragEnterEvent(pnt, &dragData);
-                else
-                    de = dme = new QPMDragMoveEvent(pnt, &dragData);
-
-                de->setAction(action);
-                de->accept(lastAccept);
-                de->acceptAction(lastAcceptAction);
-
-                QApplication::sendEvent(widget, de);
-
-                // if not allowed or not accepted, always reply DOR_NODROP
-                // to have DM_DRAGOVER delivered to us again in any case
-
-                dropReply = sourceAllowsOp && de->isAccepted() ?
-                            DOR_DROP : DOR_NODROP;
-
-                lastAccept = dee ? dee->isTrulyAccepted() :
-                                   dme->isTrulyAccepted();
-                lastAcceptAction = dee ? dee->isActionTrulyAccepted() :
-                                         dme->isActionTrulyAccepted();
-                delete de;
-#endif
+                    QDragEnterEvent dee(pnt, toQDragDropActions(supportedOps), data,
+                                        QApplication::mouseButtons(),
+                                        QApplication::keyboardModifiers());
+                    QApplication::sendEvent(widget, &dee);
+                    // if not allowed or not accepted, always reply DOR_NODROP
+                    // to have DM_DRAGOVER delivered to us again in any case
+                    if (sourceAllowsOp && dee.isAccepted()) {
+                        dropReply = DOR_DROP;
+                        action = dee.dropAction();
+                        lastAnswerRect = dee.answerRect();
+                    } else {
+                        dropReply = DOR_NODROP;
+                    }
+                }
+
+                // note: according to the Qt documentation, the move event
+                // is sent immediately after the enter event, do so (only if
+                // the target accepts it)
+                if (!first || dropReply == DOR_DROP) {
+                    QDragEnterEvent dme(pnt, toQDragDropActions(supportedOps), data,
+                                        QApplication::mouseButtons(),
+                                        QApplication::keyboardModifiers());
+                    // accept by default, since enter event was accepted.
+                    dme.setDropAction(action);
+                    dme.accept();
+                    QApplication::sendEvent(widget, &dme);
+                    if (sourceAllowsOp && dme.isAccepted()) {
+                        dropReply = DOR_DROP;
+                        action = dme.dropAction();
+                    } else {
+                        dropReply = DOR_NODROP;
+                    }
+                }
+
+                lastDropReply = dropReply;
+                lastOpRequest = toPmDragDropOp(action);
             }
 
             DrgFreeDraginfo(info);
 
-            return MRFROM2SHORT(dropReply, lastRealOp);
+            return MRFROM2SHORT(dropReply, last);
         }
         case DM_DRAGLEAVE: {
+
+
             // Odin32 apps produce incorrect message flow, ignore
             Q_ASSERT(lastDragOverHwnd != 0);
@@ -455 +446 @@
         }
         case DM_DROP: {
+
+
             // Odin32 apps produce incorrect message flow, ignore
             Q_ASSERT(lastDragOverHwnd != 0);
@@ -462 +455 @@
             // Odin32 apps send DM_DROP even if we replied DOR_NEVERDROP or
             // DOR_NODROP, simulate DM_DRAGLEAVE
-            Q_ASSERT(lastAccept || lastAcceptAction);
-            if (!lastAccept && !lastAcceptAction) {
+            Q_ASSERT(last);
+            if () {
                 WinSendMsg(qmsg.hwnd, DM_DRAGLEAVE, 0, 0);
                 return 0;
@@ -480 +473 @@
                 return MRFROM2SHORT(DOR_NEVERDROP, 0);
 
-            Q_ASSERT(lastRealOp == info->usOperation);
-
-            // convert the operation to an Action
-            Qt::DropAction action = Qt::CopyAction;
-            if      (lastRealOp == DO_COPY ) action = Qt::CopyAction;
-            else if (lastRealOp == DO_MOVE ) action = Qt::MoveAction;
-            else if (lastRealOp == DO_LINK ) action = Qt::LinkAction;
-            else Q_ASSERT(false); // should never happen
+            Q_ASSERT(lastOpRequest == info->usOperation);
 
             // flip y coordinate
             QPoint pnt(info->xDrop, info->yDrop);
             pnt.setY(QApplication::desktop()->height() - (pnt.y() + 1));
+
+
+
+
+
+
 
             dragData.setDropped(true);
 
-            // @todo later
-#if 0
-            QPMDropEvent de(widget->mapFromGlobal(pnt), &dragData);
-            de.setAction(action);
-            de.accept(lastAccept);
-            de.acceptAction(lastAcceptAction);
+            QDropEvent de(pnt, action, data, QApplication::mouseButtons(),
+                          QApplication::keyboardModifiers());
+            if (lastDropReply == DOR_DROP)
+                de.setDropAction(action);
 
             QApplication::sendEvent(widget, &de);
 
-            dragData.reset(de.isTrulyAccepted(), de.isActionTrulyAccepted());
-
-            // If the target has accepted the particular Drop action (using
-            // acceptProposedAction() rather than just accept()), it means that
-            // it will perform the necessary operation on its own (for example,
-            // will delete the source if the accepted action is Move). In this
-            // case, we always send DMFL_TARGETFAIL to the source to prevent it
-            // from doing the same on its side.
-
-            ULONG targetReply =
-                de.isTrulyAccepted() && !de.isActionTrulyAccepted() ?
+            if (lastDropReply == DOR_DROP)
+                de.accept();
+
+            dragData.reset(de.isAccepted());
+
+            ULONG targetReply = de.isAccepted() ?
                 DMFL_TARGETSUCCESSFUL : DMFL_TARGETFAIL;
-#else
-            ULONG targetReply = DMFL_TARGETFAIL;
-#endif
+
+            if (de.isAccepted() && de.dropAction() == Qt::TargetMoveAction) {
+                // Qt::TargetMoveAction means that the target will move the
+                // object (e.g. copy it to itself and delete from the source).
+                // In this case, we always send DMFL_TARGETFAIL to the source to
+                // prevent it from doing the same on its side.
+                targetReply = DMFL_TARGETFAIL;
+            }
 
             // send DM_ENDCONVERSATION for every item
@@ -528 +518 @@
                     continue;
                 // it is possible that this item required DM_RENDERPREPARE but
-                // returned FALSE in reply to it (so hwndItem may be NULL)
+                // returned  in reply to it (so hwndItem may be NULL)
                 if (!item->hwndItem)
                     continue;

trunk/src/gui/kernel/qmime.h

@@ -121 +121 @@
 #endif
 
+
 class QPMCoopDragWorker;
 
@@ -141 +142 @@
         virtual void init() {}
         // methods always implemented
-        virtual bool cleanup( bool isCancelled) = 0;
+        virtual bool cleanup(bool isCancelled) = 0;
         virtual bool isExclusive() const = 0;
         virtual ULONG itemCount() const = 0;
@@ -210 +211 @@
 
         virtual void init() {}
-        virtual void cleanup(bool isAccepted, bool isActAccepted) {}
+        virtual void cleanup(bool isAccepted) {}
         virtual bool isExclusive() const = 0;
 
@@ -230 +231 @@
 
         // DropWorker interface
-        void cleanup(bool isAccepted, bool isActAccepted);
+        void cleanup(bool isAccepted);
         bool isExclusive() const;
         bool hasFormat(const QString &mimeType) const;
@@ -294 +295 @@
     static void unregisterMimeType(ULONG mimeId);
 
+
+
     static ULONG allocateMemory(size_t size);
     static void freeMemory(ULONG addr);
@@ -315 +318 @@
     friend class QClipboardData;
     friend class QClipboard;
+
 
     struct Match

trunk/src/gui/kernel/qmime_pm.cpp

@@ -743 +743 @@
 }
 
-void QPMMime::DefaultDropWorker::cleanup(bool isAccepted, bool isActAccepted)
+void QPMMime::DefaultDropWorker::cleanup(bool isAccepted)
 {
     if (d->eventLoop.isRunning()) {
@@ -1306 +1306 @@
 {
     WinDeleteAtom(WinQuerySystemAtomTable(), mimeId);
+
+
+
+
+
+
+
+
+
 }