Changeset 108

Timestamp:

Aug 12, 2009, 10:18:10 PM (16 years ago)

Author:

Dmitry A. Kuminov

Message:

gui: Added mouse event translation, various message handling.

Location:

trunk/src/gui/kernel

Files:

• qapplication_pm.cpp (modified) (9 diffs)
• qcursor.h (modified) (1 diff)
• qcursor_p.h (modified) (1 diff)
• qcursor_pm.cpp (modified) (2 diffs)
• qwidget_pm.cpp (modified) (2 diffs)
• qwindowdefs_pm.h (modified) (1 diff)

trunk/src/gui/kernel/qapplication_pm.cpp ¶

@@ -51 +51 @@
 #include "qcolormap.h"
 #include "qpixmapcache.h"
+#include "qdesktopwidget.h"
 
 #include "qset.h"
@@ -68 +69 @@
 static HWND      curWin         = 0;            // current window
 static HPS       displayPS      = 0;            // display presentation space
+
+#if !defined (QT_NO_SESSIONMANAGER)
+
+// Session management
+static bool     sm_blockUserInput    = FALSE;
+
+//#define DEBUG_SESSIONMANAGER
+
+#endif
 
 static bool replayPopupMouseEvent = false; // replay handling when popups close
@@ -82 +92 @@
 extern QDesktopWidget *qt_desktopWidget;
 static QPointer<QWidget> popupButtonFocus;
-static bool     qt_try_modal(QWidget *, QMSG *, int& ret);
+static bool     qt_try_modal(QWidget*, QMSG*, MRESULT&);
 
 QWidget *qt_button_down = 0; // widget got last button-down
@@ -88 +98 @@
 
 static HWND autoCaptureWnd = NULLHANDLE;
+static bool autoCaptureReleased = FALSE;
 static void setAutoCapture(HWND); // automatic capture
 static void releaseAutoCapture();
@@ -107 +118 @@
 //  QWidgetPrivate *dptr() { return d_func(); }
 //  QRect frameStrut() const { return d_func()->frameStrut(); }
-//  bool        winEvent(QMSG *m, long *r) { return QWidget::winEvent(m, r); }
+    bool        pmEvent(QMSG *m, MRESULT *r) { return QWidget::pmEvent(m, r); }
 //  void        markFrameStrutDirty() { data->fstrut_dirty = 1; }
-//  bool        translateMouseEvent(const MSG &msg);
-//  bool        translateWheelEvent(const MSG &msg);
-//  bool        translatePaintEvent(const MSG &msg);
+    bool        translateMouseEvent(const QMSG &qmsg);
+#ifndef QT_NO_WHEELEVENT
+    bool        translateWheelEvent(const QMSG &qmsg);
+#endif
+    bool        translatePaintEvent(const QMSG &qmsg);
 //  bool        translateConfigEvent(const MSG &msg);
 //  bool        translateCloseEvent(const MSG &msg);
@@ -254 +267 @@
 class QGuiEventDispatcherPM : public QEventDispatcherPM
 {
-    Q_DECLARE_PRIVATE(QEventDispatcherPM)
 public:
     QGuiEventDispatcherPM(QObject *parent = 0);
@@ -424 +436 @@
 MRESULT EXPENTRY QtWndProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
 {
-    // message handling indicators: if handled is true at the end of message
-    // processing, no default window proc is called but rc is returned.
-    bool handled = false;
-    MRESULT rc = (MRESULT) FALSE;
-    QETWidget *widget = 0;
-    HWND hwndC = NULLHANDLE;
-
     do {
+        if (!qApp) // unstable app state
+            break;
+#if 0
+        // make sure we show widgets (e.g. scrollbars) when the user resizes
+        if (qApp->loopLevel())
+            qApp->sendPostedEvents(0, QEvent::ShowWindowRequest);
+#endif
+
+        MRESULT rc = (MRESULT) FALSE;
+        QETWidget *widget = 0;
+
+        bool isTranslatableMouseEvent =
+            (msg >= WM_MOUSEFIRST && msg <= WM_MOUSELAST) ||
+            (msg >= WM_EXTMOUSEFIRST && msg <= WM_EXTMOUSELAST);
+
+        QMSG qmsg; // create QMSG structure
+        qmsg.hwnd = hwnd;
+        qmsg.msg = msg;
+        qmsg.mp1 = mp1;
+        qmsg.mp2 = mp2;
+        qmsg.time = WinQueryMsgTime(0);
+
+        if (isTranslatableMouseEvent || msg == WM_CONTEXTMENU) {
+            qmsg.ptl.x = (short)SHORT1FROMMP(mp1);
+            qmsg.ptl.y = (short)SHORT2FROMMP(mp1);
+            WinMapWindowPoints(qmsg.hwnd, HWND_DESKTOP, &qmsg.ptl, 1);
+        } else {
+            WinQueryMsgPos(0, &qmsg.ptl);
+        }
+        // flip y coordinate
+        qmsg.ptl.y = QApplication::desktop()->height() - (qmsg.ptl.y + 1);
+
+        // send through app filter
+        if (qApp->filterEvent(&qmsg, reinterpret_cast<long *>(&rc)))
+            return rc;
+
+        switch(msg) {
+
+        case WM_BUTTON1DOWN:
+        case WM_BUTTON2DOWN:
+        case WM_BUTTON3DOWN:
+            if (ignoreNextMouseReleaseEvent)
+                ignoreNextMouseReleaseEvent = false;
+            break;
+        case WM_BUTTON1UP:
+        case WM_BUTTON2UP:
+        case WM_BUTTON3UP:
+            if (ignoreNextMouseReleaseEvent) {
+                ignoreNextMouseReleaseEvent = false;
+                if (qt_button_down && qt_button_down->internalWinId() == autoCaptureWnd) {
+                    releaseAutoCapture();
+                    qt_button_down = 0;
+                }
+                return (MRESULT)TRUE;
+            }
+            break;
+
+        default:
+            break;
+        }
+
+        if (!widget)
+            widget = (QETWidget*)QWidget::find(hwnd);
+        if (!widget) // don't know this widget
+            break;
+
+        if (app_do_modal) { // modal event handling
+            if (!qt_try_modal(widget, &qmsg, rc))
+                return rc;
+        }
+
+        if (widget->pmEvent(&qmsg, &rc)) // send through widget filter
+            return rc;
+
+        if (isTranslatableMouseEvent) {
+            if (qApp->activePopupWidget() != 0) { // in popup mode
+                QWidget *w = QApplication::widgetAt(qmsg.ptl.x, qmsg.ptl.y);
+                if (w) {
+                    POINTL ptl = { SHORT1FROMMP(qmsg.mp1), SHORT2FROMMP(qmsg.mp1) };
+                    WinMapWindowPoints(qmsg.hwnd, w->winId(), &ptl, 1);
+                    qmsg.mp1 = MPFROM2SHORT(ptl.x, ptl.y);
+                    widget = (QETWidget*)w;
+                }
+            }
+            if (widget->translateMouseEvent(qmsg)) // mouse event
+                return (MRESULT)TRUE;
+#ifndef QT_NO_WHEELEVENT
+        } else if (msg == WM_VSCROLL || msg == WM_HSCROLL) {
+            if (widget->translateWheelEvent(qmsg))
+                return (MRESULT)TRUE;
+#endif
+#ifndef QT_NO_DRAGANDDROP
+        } else if (msg >= WM_DRAGFIRST && msg <= WM_DRAGLAST) {
+            return qt_dispatchDragAndDrop(widget, qmsg);
+#endif
+        } else {
+            switch(msg) {
+
+            case WM_SHOW: {
+                // @todo there is some more processing in Qt4, see
+                // WM_SHOWWINDOW in Win32 sources
+                if (!SHORT1FROMMP(mp1) && autoCaptureWnd == widget->internalWinId())
+                    releaseAutoCapture();
+                break;
+            }
+
+#ifndef QT_NO_CONTEXTMENU
+            case WM_CONTEXTMENU: {
+                if (SHORT2FROMMP(mp2)) {
+                    // keyboard event
+                    QWidget *fw = qApp->focusWidget();
+                    if (fw && fw->isEnabled()) {
+                        QContextMenuEvent e(QContextMenuEvent::Keyboard,
+                                            QPoint(5, 5),
+                                            fw->mapToGlobal(QPoint(5, 5)), 0);
+                        if (qt_sendSpontaneousEvent(fw, &e))
+                            return (MRESULT)TRUE;
+                    }
+                } else {
+                    // mouse event
+                    if (widget->translateMouseEvent(qmsg))
+                        return (MRESULT)TRUE;
+                }
+                break;
+            }
+#endif
+
+            default:
+                break;
+            }
+        }
+
+    } while(0);
+
+    return WinDefWindowProc(hwnd, msg, mp1, mp2);
+}
+
+PFNWP QtOldFrameProc = 0;
+
+MRESULT EXPENTRY QtFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
+{
+    do {
+        if (!qApp) // unstable app state
+            break;
+#if 0
+        // make sure we show widgets (e.g. scrollbars) when the user resizes
+        if (qApp->loopLevel())
+            qApp->sendPostedEvents(0, QEvent::ShowWindowRequest);
+#endif
+
+        HWND hwndC = WinWindowFromID(hwnd, FID_CLIENT);
+        QETWidget *widget = (QETWidget*)QWidget::find(hwndC);
+        if (!widget) // don't know this widget
+            break;
+
         switch(msg) {
         default:
             break;
         }
-        if (handled)
-            return rc;
-    } while(0);
-
-    return WinDefWindowProc(hwnd, msg, mp1, mp2);
-}
-
-PFNWP QtOldFrameProc = 0;
-
-MRESULT EXPENTRY QtFrameProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
-{
-    // message handling indicators: if handled is true at the end of message
-    // processing, no default window proc is called but rc is returned.
-    bool handled = false;
-    MRESULT rc = (MRESULT) FALSE;
-    QETWidget *widget = 0;
-    HWND hwndC = NULLHANDLE;
-
-    do {
-        switch(msg) {
-        default:
-            break;
-        }
-        if (handled)
-            return rc;
     } while(0);
 
@@ -499 +634 @@
 }
 
+bool qt_try_modal(QWidget *widget, QMSG *qmsg, MRESULT& rc)
+{
+    // @todo implement
+    return false;
+}
+
 /*****************************************************************************
   Popup widget mechanism
@@ -527 +668 @@
  *****************************************************************************/
 
+// State holder for LWIN/RWIN and ALTGr keys
+// (ALTGr is also necessary since OS/2 doesn't report ALTGr as KC_ALT)
+static int qt_extraKeyState = 0;
+
+static int mouseButtonState()
+{
+    int state = 0;
+
+    if (WinGetKeyState(HWND_DESKTOP, VK_BUTTON1) & 0x8000)
+        state |= Qt::LeftButton;
+    if (WinGetKeyState(HWND_DESKTOP, VK_BUTTON2) & 0x8000)
+        state |= Qt::RightButton;
+    if (WinGetKeyState(HWND_DESKTOP, VK_BUTTON3) & 0x8000)
+        state |= Qt::MidButton;
+
+    return state;
+}
+
+//
+// Auto-capturing for mouse press and mouse release
+//
+
+static void setAutoCapture(HWND h)
+{
+    if (autoCaptureWnd)
+        releaseAutoCapture();
+    autoCaptureWnd = h;
+
+    if (!mouseButtonState()) {
+        // all buttons released, we don't actually capture the mouse
+        // (see QWidget::translateMouseEvent())
+        autoCaptureReleased = true;
+    } else {
+        autoCaptureReleased = false;
+        WinSetCapture(HWND_DESKTOP, h);
+    }
+}
+
+static void releaseAutoCapture()
+{
+    if (autoCaptureWnd) {
+        if (!autoCaptureReleased) {
+            WinSetCapture(HWND_DESKTOP, NULLHANDLE);
+            autoCaptureReleased = true;
+        }
+        autoCaptureWnd = NULLHANDLE;
+    }
+}
+
+//
+// Mouse event translation
+//
+
+static ushort mouseTbl[] = {
+    WM_MOUSEMOVE,           QEvent::MouseMove,                  0,
+    WM_BUTTON1DOWN,         QEvent::MouseButtonPress,       Qt::LeftButton,
+    WM_BUTTON1UP,           QEvent::MouseButtonRelease,     Qt::LeftButton,
+    WM_BUTTON1DBLCLK,   QEvent::MouseButtonDblClick,    Qt::LeftButton,
+    WM_BUTTON2DOWN,         QEvent::MouseButtonPress,       Qt::RightButton,
+    WM_BUTTON2UP,           QEvent::MouseButtonRelease,     Qt::RightButton,
+    WM_BUTTON2DBLCLK,   QEvent::MouseButtonDblClick,    Qt::RightButton,
+    WM_BUTTON3DOWN,         QEvent::MouseButtonPress,       Qt::MidButton,
+    WM_BUTTON3UP,           QEvent::MouseButtonRelease,     Qt::MidButton,
+    WM_BUTTON3DBLCLK,   QEvent::MouseButtonDblClick,    Qt::MidButton,
+    WM_CONTEXTMENU,     QEvent::ContextMenu,            0,
+    0,                          0,                                              0
+};
+
+static int translateButtonState(USHORT s, int type, int button)
+{
+    Q_UNUSED(button);
+
+    int bst = mouseButtonState();
+
+    if (type == QEvent::ContextMenu) {
+        if (WinGetKeyState(HWND_DESKTOP, VK_SHIFT) & 0x8000)
+            bst |= Qt::ShiftModifier;
+        if (WinGetKeyState(HWND_DESKTOP, VK_ALT) & 0x8000)
+            bst |= Qt::AltModifier;
+        if (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000)
+            bst |= Qt::ControlModifier;
+    } else {
+        if (s & KC_SHIFT)
+            bst |= Qt::ShiftModifier;
+        if ((s & KC_ALT))
+            bst |= Qt::AltModifier;
+        if (s & KC_CTRL)
+            bst |= Qt::ControlModifier;
+    }
+    if ((qt_extraKeyState & Qt::AltModifier))
+        bst |= Qt::AltModifier;
+    if (qt_extraKeyState & Qt::MetaModifier)
+        bst |= Qt::MetaModifier;
+
+    return bst;
+}
+
+bool QETWidget::translateMouseEvent(const QMSG &qmsg)
+{
+#if 0
+    static const char *msgNames[] = { // 11 items
+        "WM_MOUSEMOVE",
+        "WM_BUTTON1DOWN", "WM_BUTTON1UP", "WM_BUTTON1DBLCLK",
+        "WM_BUTTON2DOWN", "WM_BUTTON2UP", "WM_BUTTON2DBLCLK",
+        "WM_BUTTON3DOWN", "WM_BUTTON3UP", "WM_BUTTON3DBLCLK",
+        "WM_???"
+    };
+    int msgIdx = qmsg.msg - WM_MOUSEMOVE;
+    if (msgIdx < 0 || msgIdx > 9)
+        msgIdx = 10;
+    qDebug("%s (%04lX): [%08lX/%p:%s] %04hd,%04hd hit=%04hX fl=%04hX",
+           msgNames[msgIdx], qmsg.msg, qmsg.hwnd, this, widgetName(this),
+           SHORT1FROMMP(qmsg.mp1), SHORT2FROMMP(qmsg.mp1),
+           SHORT1FROMMP(qmsg.mp2), SHORT2FROMMP(qmsg.mp2));
+#endif
+
+    if (!isWindow() && testAttribute(Qt::WA_NativeWindow))
+        Q_ASSERT(internalWinId() != NULLHANDLE);
+
+    static QPoint pos;                          // window pos (y flipped)
+    static POINTL gpos = { -1, -1 };            // global pos (y flipped)
+    QEvent::Type type;                                      // event parameters
+    int    button;
+    int    state;
+    int    i;
+
+    // candidate for the double click event
+    static HWND dblClickCandidateWin = 0;
+
+#if !defined (QT_NO_SESSIONMANAGER)
+    if (sm_blockUserInput) //block user interaction during session management
+        return true;
+#endif
+
+    // Compress mouse move events
+    if (qmsg.msg == WM_MOUSEMOVE) {
+        QMSG mouseMsg;
+        mouseMsg.msg = WM_NULL;
+        while (WinPeekMsg(0, &mouseMsg, qmsg.hwnd, WM_MOUSEMOVE,
+                          WM_MOUSEMOVE, PM_NOREMOVE)) {
+                if (mouseMsg.mp2 != qmsg.mp2)
+                    break; // leave the message in the queue because
+                           // the key state has changed
+                // Remove the mouse move message
+                WinPeekMsg(0, &mouseMsg, qmsg.hwnd, WM_MOUSEMOVE,
+                           WM_MOUSEMOVE, PM_REMOVE);
+        }
+        // Update the passed in QMSG structure with the
+        // most recent one.
+        if (mouseMsg.msg != WM_NULL) {
+            PQMSG pqmsg = (PQMSG)&qmsg;
+            pqmsg->mp1 = mouseMsg.mp1;
+            pqmsg->mp2 = mouseMsg.mp2;
+            pqmsg->time = mouseMsg.time;
+            pqmsg->ptl.x = (short)SHORT1FROMMP(mouseMsg.mp1);
+            pqmsg->ptl.y = (short)SHORT2FROMMP(mouseMsg.mp1);
+            WinMapWindowPoints(pqmsg->hwnd, HWND_DESKTOP, &pqmsg->ptl, 1);
+            // flip y coordinate
+            pqmsg->ptl.y = QApplication::desktop()->height() - (pqmsg->ptl.y + 1);
+        }
+    }
+
+    for (i = 0; mouseTbl[i] && (ULONG)mouseTbl[i] != qmsg.msg; i += 3)
+        ;
+    if (!mouseTbl[i])
+        return true;
+
+    type   = (QEvent::Type)mouseTbl[++i];   // event type
+    button = mouseTbl[++i];                             // which button
+    state  = translateButtonState(SHORT2FROMMP(qmsg.mp2), type, button); // button state
+
+    // It seems, that PM remembers only the WM_BUTTONxDOWN message (instead of
+    // the WM_BUTTONxDOWN + WM_BUTTONxUP pair) to detect whether the next button
+    // press should be converted to WM_BUTTONxDBLCLK or not. As a result, the
+    // window gets WM_BUTTONxDBLCLK even if it didn't receive the preceeding
+    // WM_BUTTONxUP (this happens if we issue WinSetCapture() on the first
+    // WM_BUTTONxDOWN), which is obviously wrong and makes problems for QWorkspace
+    // and QTitleBar system menu handlers that don't expect a double click after
+    // they opened a popup menu. dblClickCandidateWin is reset to 0 (see a ***
+    // remmark below) when WinSetCapture is issued that directs messages
+    // to a window other than one received the first WM_BUTTONxDOWN,
+    // so we can fix it here.  Note that if there is more than one popup window,
+    // WinSetCapture is issued only for the first of them, so this code doesn't
+    // prevent MouseButtonDblClick from being delivered to a popup when another
+    // popup gets closed on the first WM_BUTTONxDOWN (Qt/Win32 behaves in the
+    // same way, so it's left for compatibility).
+    if (type == QEvent::MouseButtonPress) {
+        dblClickCandidateWin = qmsg.hwnd;
+    } else if (type == QEvent::MouseButtonDblClick) {
+        if (dblClickCandidateWin != qmsg.hwnd)
+            type = QEvent::MouseButtonPress;
+        dblClickCandidateWin = 0;
+    }
+
+    const QPoint widgetPos = mapFromGlobal(QPoint(qmsg.ptl.x, qmsg.ptl.y));
+
+    QWidget *alienWidget = !internalWinId() ? this : childAt(widgetPos);
+    if (alienWidget && alienWidget->internalWinId())
+        alienWidget = 0;
+
+    if (type == QEvent::MouseMove) {
+        if (!(state & Qt::MouseButtonMask))
+            qt_button_down = 0;
+#ifndef QT_NO_CURSOR
+        QCursor *c = qt_grab_cursor();
+        if (!c)
+            c = QApplication::overrideCursor();
+        if (c) // application cursor defined
+            WinSetPointer(HWND_DESKTOP, c->handle());
+        else if (!qt_button_down) {
+            QWidget *w = alienWidget ? alienWidget : this;
+            while (!w->isWindow() && !w->isEnabled())
+                w = w->parentWidget();
+            WinSetPointer(HWND_DESKTOP, w->cursor().handle());
+        }
+#else
+        // pass the msg to the default proc to let it change the pointer shape
+        WinDefWindowProc(qmsg.hwnd, qmsg.msg, qmsg.mp1, qmsg.mp2);
+#endif
+
+        HWND id = effectiveWinId();
+        QWidget *mouseGrabber = QWidget::mouseGrabber();
+        QWidget *activePopupWidget = qApp->activePopupWidget();
+        if (mouseGrabber) {
+            if (!activePopupWidget || (activePopupWidget == this && !rect().contains(widgetPos)))
+                id = mouseGrabber->effectiveWinId();
+        } else if (type == QEvent::NonClientAreaMouseMove) {
+            id = 0;
+        }
+
+        if (curWin != id) { // new current window
+            // @todo
+            // add CS_HITTEST to our window classes and handle WM_HITTEST,
+            // otherwise disabled windows will not get mouse events?
+            if (id == 0) {
+                QWidget *leave = qt_last_mouse_receiver;
+                if (!leave)
+                    leave = QWidget::find(curWin);
+                QApplicationPrivate::dispatchEnterLeave(0, leave);
+                qt_last_mouse_receiver = 0;
+                curWin = 0;
+            } else {
+                QWidget *leave = 0;
+                if (curWin && qt_last_mouse_receiver)
+                    leave = qt_last_mouse_receiver;
+                else
+                    leave = QWidget::find(curWin);
+                QWidget *enter = alienWidget ? alienWidget : this;
+                if (mouseGrabber && activePopupWidget) {
+                    if (leave != mouseGrabber)
+                        enter = mouseGrabber;
+                    else
+                        enter = activePopupWidget == this ? this : mouseGrabber;
+                }
+                QApplicationPrivate::dispatchEnterLeave(enter, leave);
+                qt_last_mouse_receiver = enter;
+                curWin = enter ? enter->effectiveWinId() : 0;
+            }
+        }
+
+        // *** PM posts a dummy WM_MOUSEMOVE message (with the same, uncahnged
+        // pointer coordinates) after every WinSetCapture that actually changes
+        // the capture target. I.e., if the argument of WinSetCapture is
+        // NULLHANDLE, a window under the mouse pointer gets this message,
+        // otherwise the specified window gets it unless it is already under the
+        // pointer. We use this info to check whether the window can be a double
+        // click candidate (see above).
+        if (qmsg.ptl.x == gpos.x && qmsg.ptl.y == gpos.y) {
+            if (dblClickCandidateWin != qmsg.hwnd)
+                dblClickCandidateWin = 0;
+            return true;
+        }
+
+        gpos = qmsg.ptl;
+
+        Q_ASSERT(testAttribute(Qt::WA_WState_Created));
+
+        POINTL curPos = gpos;
+        WinMapWindowPoints(internalWinId(), HWND_DESKTOP, &gpos, 1);
+
+        pos.rx() = curPos.x;
+        pos.ry() = curPos.y;
+        pos = d_func()->mapFromWS(pos);
+    } else {
+        if (type == QEvent::MouseButtonPress && !isActiveWindow())
+            setActiveWindow();
+
+        gpos = qmsg.ptl;
+        pos = mapFromGlobal(QPoint(gpos.x, gpos.y));
+
+        // mouse button pressed
+        if (!qt_button_down && (type == QEvent::MouseButtonPress || type == QEvent::MouseButtonDblClick)) {
+            QWidget *tlw = window();
+            if (QWidget *child = tlw->childAt(mapTo(tlw, pos)))
+                qt_button_down = child;
+            else
+                qt_button_down = this;
+        }
+    }
+
+    // detect special button states
+    enum { Other, SinglePressed, AllReleased } btnState = Other;
+    int bs = state & Qt::MouseButtonMask;
+    if ((type == QEvent::MouseButtonPress ||
+         type == QEvent::MouseButtonDblClick) && bs == 0) {
+        btnState = SinglePressed;
+    } else if (type == QEvent::MouseButtonRelease && bs == button) {
+        btnState = AllReleased;
+    }
+
+    bool res = false;
+
+    if (qApp->d_func()->inPopupMode()) { // in popup mode
+        if (!autoCaptureReleased && btnState == AllReleased) {
+            // in order to give non-Qt windows the opportunity to see mouse
+            // messages while our popups are active we need to release the
+            // mouse capture which is absolute in OS/2. we do it directly
+            // (not through releaseAutoCapture()) in order to keep
+            // autoCaptureWnd nonzero to keep forwarding mouse move events
+            // (actually sent to one of Qt widgets) to the active popup.
+            autoCaptureReleased = true;
+            WinSetCapture(HWND_DESKTOP, 0);
+        } else if (autoCaptureReleased && btnState == SinglePressed) {
+            // set the mouse capture back if a button is pressed.
+            if ( autoCaptureWnd ) {
+                autoCaptureReleased = false;
+                WinSetCapture(HWND_DESKTOP, autoCaptureWnd);
+            }
+        }
+
+        replayPopupMouseEvent = false;
+        QWidget* activePopupWidget = qApp->activePopupWidget();
+        QWidget *target = activePopupWidget;
+        const QPoint globalPos(gpos.x, gpos.y);
+
+        if (target != this) {
+            if ((windowType() == Qt::Popup) && rect().contains(pos) && 0)
+                target = this;
+            else                                // send to last popup
+                pos = target->mapFromGlobal(globalPos);
+        }
+        QWidget *popupChild = target->childAt(pos);
+        bool releaseAfter = false;
+        switch (type) {
+            case QEvent::MouseButtonPress:
+            case QEvent::MouseButtonDblClick:
+                popupButtonFocus = popupChild;
+                break;
+            case QEvent::MouseButtonRelease:
+                releaseAfter = true;
+                break;
+            default:
+                break;                                // nothing for mouse move
+        }
+
+        if (target->isEnabled()) {
+            if (popupButtonFocus) {
+                target = popupButtonFocus;
+            } else if (popupChild) {
+                // forward mouse events to the popup child. mouse move events
+                // are only forwarded to popup children that enable mouse tracking.
+                if (type != QEvent::MouseMove || popupChild->hasMouseTracking())
+                    target = popupChild;
+            }
+
+            pos = target->mapFromGlobal(globalPos);
+#ifndef QT_NO_CONTEXTMENU
+            if (type == QEvent::ContextMenu) {
+                QContextMenuEvent e(QContextMenuEvent::Mouse, pos, globalPos, state);
+                res = QApplication::sendSpontaneousEvent(target, &e);
+                res = res && e.isAccepted();
+            }
+            else
+#endif
+            {
+                QMouseEvent e(type, pos, globalPos,
+                            Qt::MouseButton(button),
+                            Qt::MouseButtons(state & Qt::MouseButtonMask),
+                            Qt::KeyboardModifiers(state & Qt::KeyboardModifierMask));
+                res = QApplicationPrivate::sendMouseEvent(target, &e, alienWidget, this, &qt_button_down,
+                                                          qt_last_mouse_receiver);
+                res = res && e.isAccepted();
+            }
+        } else {
+            // close disabled popups when a mouse button is pressed or released
+            switch (type) {
+            case QEvent::MouseButtonPress:
+            case QEvent::MouseButtonDblClick:
+            case QEvent::MouseButtonRelease:
+                target->close();
+                break;
+            default:
+                break;
+            }
+        }
+
+        if (releaseAfter) {
+            popupButtonFocus = 0;
+            qt_button_down = 0;
+        }
+
+        if (type == QEvent::MouseButtonPress
+            && qApp->activePopupWidget() != activePopupWidget
+            && replayPopupMouseEvent) {
+            // the popup dissappeared. Replay the event
+            QWidget* w = QApplication::widgetAt(gpos.x, gpos.y);
+            if (w && !QApplicationPrivate::isBlockedByModal(w)) {
+                Q_ASSERT(w->testAttribute(Qt::WA_WState_Created));
+                HWND hwndTarget = w->effectiveWinId();
+                if (QWidget::mouseGrabber() == 0)
+                    setAutoCapture(hwndTarget);
+                if (!w->isActiveWindow())
+                    w->activateWindow();
+                POINTL pt = gpos;
+                WinMapWindowPoints(HWND_DESKTOP, hwndTarget, &pt, 1);
+                // flip y coordinate
+                pt.y = w->height() - (pt.y + 1);
+                WinPostMsg(hwndTarget, qmsg.msg,
+                           MPFROM2SHORT(pt.x, pt.y), qmsg.mp2);
+            }
+        }
+    } else { // not popup mode
+        if (btnState == SinglePressed && QWidget::mouseGrabber() == 0) {
+            Q_ASSERT(testAttribute(Qt::WA_WState_Created));
+            setAutoCapture(internalWinId());
+        } else if (btnState == AllReleased && QWidget::mouseGrabber() == 0) {
+            releaseAutoCapture();
+        }
+
+        const QPoint globalPos(gpos.x,gpos.y);
+        QWidget *widget = QApplicationPrivate::pickMouseReceiver(this, globalPos, pos, type,
+                                                                 Qt::MouseButtons(bs),
+                                                                 qt_button_down, alienWidget);
+        if (!widget)
+            return false; // don't send event
+
+#ifndef QT_NO_CONTEXTMENU
+        if (type == QEvent::ContextMenu) {
+            QContextMenuEvent e(QContextMenuEvent::Mouse, pos, globalPos, state);
+            res = QApplication::sendSpontaneousEvent(widget, &e);
+            res = res && e.isAccepted();
+        } else
+#endif
+        {
+            QMouseEvent e(type, pos, globalPos, Qt::MouseButton(button),
+                          Qt::MouseButtons(state & Qt::MouseButtonMask),
+                          Qt::KeyboardModifiers(state & Qt::KeyboardModifierMask));
+
+            res = QApplicationPrivate::sendMouseEvent(widget, &e, alienWidget, this, &qt_button_down,
+                                                      qt_last_mouse_receiver);
+            res = res && e.isAccepted();
+        }
+
+        if (type != QEvent::MouseMove)
+            pos.rx() = pos.ry() = -9999;        // init for move compression
+    }
+
+    return res;
+}
+
+#ifndef QT_NO_WHEELEVENT
+bool QETWidget::translateWheelEvent(const QMSG &qmsg)
+{
+    enum { WHEEL_DELTA = 120 };
+
+#ifndef QT_NO_SESSIONMANAGER
+    if (sm_blockUserInput) // block user interaction during session management
+        return true;
+#endif
+
+    // consume duplicate wheel events sent by the AMouse driver to emulate
+    // multiline scrolls. we need this since currently Qt (QScrollBar, for
+    // instance) maintains the number of lines to scroll per wheel rotation
+    // (including the special handling of CTRL and SHIFT modifiers) on its own
+    // and doesn't have a setting to tell it to be aware of system settings
+    // for the mouse wheel. if we had processed events as they are, we would
+    // get a confusing behavior (too many lines scrolled etc.).
+    {
+        int devh = QApplication::desktop()->height();
+        QMSG wheelMsg;
+        while (WinPeekMsg(0, &wheelMsg, qmsg.hwnd, qmsg.msg, qmsg.msg, PM_NOREMOVE)) {
+            // PM bug: ptl contains SHORT coordinates although fields are LONG
+            wheelMsg.ptl.x = (short) wheelMsg.ptl.x;
+            wheelMsg.ptl.y = (short) wheelMsg.ptl.y;
+            // flip y coordinate
+            wheelMsg.ptl.y = devh - (wheelMsg.ptl.y + 1);
+            if (wheelMsg.mp1 != qmsg.mp1 ||
+                wheelMsg.mp2 != qmsg.mp2 ||
+                wheelMsg.ptl.x != qmsg.ptl.x ||
+                wheelMsg.ptl.y != qmsg.ptl.y)
+                break;
+            WinPeekMsg(0, &wheelMsg, qmsg.hwnd, qmsg.msg, qmsg.msg, PM_REMOVE);
+        }
+    }
+
+    int delta;
+    USHORT cmd = SHORT2FROMMP(qmsg.mp2);
+    switch (cmd) {
+        case SB_LINEUP:
+        case SB_PAGEUP:
+            delta = WHEEL_DELTA;
+            break;
+        case SB_LINEDOWN:
+        case SB_PAGEDOWN:
+            delta = -WHEEL_DELTA;
+            break;
+        default:
+            return false;
+    }
+
+    int state = 0;
+    if (WinGetKeyState(HWND_DESKTOP, VK_SHIFT ) & 0x8000)
+        state |= Qt::ShiftModifier;
+    if (WinGetKeyState(HWND_DESKTOP, VK_ALT) & 0x8000 ||
+        (qt_extraKeyState & Qt::AltModifier))
+        state |= Qt::AltModifier;
+    if (WinGetKeyState(HWND_DESKTOP, VK_CTRL) & 0x8000)
+        state |= Qt::ControlModifier;
+    if (qt_extraKeyState & Qt::MetaModifier)
+        state |= Qt::MetaModifier;
+
+    Qt::Orientation orient;
+    // Alt inverts scroll orientation (Qt/Win32 behavior)
+    if (state & Qt::AltModifier)
+        orient = qmsg.msg == WM_VSCROLL ? Qt::Horizontal : Qt::Vertical;
+    else
+        orient = qmsg.msg == WM_VSCROLL ? Qt::Vertical : Qt::Horizontal;
+
+    QPoint globalPos(qmsg.ptl.x, qmsg.ptl.y);
+
+    // if there is a widget under the mouse and it is not shadowed
+    // by modality, we send the event to it first
+    MRESULT rc = FALSE;
+    QWidget* w = QApplication::widgetAt(globalPos);
+    if (!w || !qt_try_modal(w, (QMSG*)&qmsg, rc)) {
+        //synaptics touchpad shows its own widget at this position
+        //so widgetAt() will fail with that HWND, try child of this widget
+        w = this->childAt(this->mapFromGlobal(globalPos));
+        if (!w)
+            w = this;
+    }
+
+    // send the event to the widget or its ancestors
+    {
+        QWidget* popup = qApp->activePopupWidget();
+        if (popup && w->window() != popup)
+            popup->close();
+#ifndef QT_NO_WHEELEVENT
+        QWheelEvent e(w->mapFromGlobal(globalPos), globalPos, delta,
+                      Qt::MouseButtons(state & Qt::MouseButtonMask),
+                      Qt::KeyboardModifier(state & Qt::KeyboardModifierMask), orient);
+
+        if (QApplication::sendSpontaneousEvent(w, &e))
+#else
+        Q_UNUSED(orient);
+#endif //QT_NO_WHEELEVENT
+            return true;
+    }
+
+    // send the event to the widget that has the focus or its ancestors, if different
+    if (w != qApp->focusWidget() && (w = qApp->focusWidget())) {
+        QWidget* popup = qApp->activePopupWidget();
+        if (popup && w->window() != popup)
+            popup->close();
+#ifndef QT_NO_WHEELEVENT
+        QWheelEvent e(w->mapFromGlobal(globalPos), globalPos, delta,
+                      Qt::MouseButtons(state & Qt::MouseButtonMask),
+                      Qt::KeyboardModifier(state & Qt::KeyboardModifierMask), orient);
+        if (QApplication::sendSpontaneousEvent(w, &e))
+#endif //QT_NO_WHEELEVENT
+            return true;
+    }
+
+    return false;
+}
+#endif
+
 QT_END_NAMESPACE

trunk/src/gui/kernel/qcursor.h ¶

@@ -115 +115 @@
     HCURSOR handle() const;
     QCursor(HCURSOR cursor);
+#elif defined(Q_WS_PM)
+    HPOINTER handle() const;
+    QCursor(HPOINTER handle);
 #elif defined(Q_WS_X11)
     Qt::HANDLE handle() const;

trunk/src/gui/kernel/qcursor_p.h ¶

@@ -93 +93 @@
 #if defined (Q_WS_WIN)
     HCURSOR hcurs;
+#elif defined (Q_WS_PM)
+    HPOINTER hcurs;
 #elif defined (Q_WS_X11)
     XColor fg, bg;

trunk/src/gui/kernel/qcursor_pm.cpp ¶

@@ -60 +60 @@
 
 QCursorData::QCursorData(Qt::CursorShape s)
-  : cshape(s), bm(0), bmm(0), hx(0), hy(0) // @todo, hcurs(0)
+  : cshape(s), bm(0), bmm(0), hx(0), hy(0), hcurs(NULLHANDLE)
 {
     ref = 1;
@@ -79 +79 @@
     // @todo implement
     return 0;
+}
+
+HPOINTER QCursor::handle() const
+{
+    if (!QCursorData::initialized)
+        QCursorData::initialize();
+    if (!d->hcurs)
+        d->update();
+    return d->hcurs;
+}
+
+QCursor::QCursor(HPOINTER handle)
+{
+    d = new QCursorData(Qt::CustomCursor);
+    d->hcurs = handle;
 }
 

trunk/src/gui/kernel/qwidget_pm.cpp ¶

@@ -857 +857 @@
 
     if (flags & Qt::WindowTitleHint) {
-        title = topLevel ? qAppName().toLocal8Bit() : q->objectName().toLocal8Bit();
+        QString t = topLevel ? qAppName() : q->objectName();
+        t = t.left(1).toUpper() + t.mid(1).toLower();
+        title = t.toLocal8Bit();
     }
 
@@ -1186 +1188 @@
 }
 
+QCursor *qt_grab_cursor()
+{
+    return mouseGrbCur;
+}
+
 void QWidget::grabMouse()
 {

trunk/src/gui/kernel/qwindowdefs_pm.h ¶

@@ -59 +59 @@
 typedef LHANDLE HWND;
 typedef LHANDLE HPS;
+typedef LHANDLE HPOINTER;
 typedef struct _QMSG QMSG;
 typedef void *MRESULT;