MCL/sf/mw/qt: comparison src/gui/kernel/qapplication

equal deleted inserted replaced

-:56cd8111b7f7
+:41300fa6a67c
 static PtrWTGet ptrWTGet = 0;
 static PACKET localPacketBuf[QT_TABLET_NPACKETQSIZE];  // our own tablet packet queue.
 HCTX qt_tablet_context;  // the hardware context for the tablet (like a window handle)
 bool qt_tablet_tilt_support;
-static void tabletInit(UINT wActiveCsr, HCTX hTab);
+#ifndef QT_NO_TABLETEVENT
+static void tabletInit(const quint64 uniqueId, const UINT csr_type, HCTX hTab);
+static void tabletUpdateCursor(QTabletDeviceData &tdd, const UINT currentCursor);
 static void initWinTabFunctions();        // resolve the WINTAB api functions
+#endif // QT_NO_TABLETEVENT
 #ifndef QT_NO_ACCESSIBILITY
 extern IAccessible *qt_createWindowsAccessible(QAccessibleInterface *object);
 #endif // QT_NO_ACCESSIBILITY
 extern bool qt_tabletChokeMouse;
 extern QWidget* qt_get_tablet_widget();
 extern bool qt_sendSpontaneousEvent(QObject*, QEvent*);
 extern QRegion qt_dirtyRegion(QWidget *);
-typedef QHash<UINT, QTabletDeviceData> QTabletCursorInfo;
+typedef QHash<quint64, QTabletDeviceData> QTabletCursorInfo;
 Q_GLOBAL_STATIC(QTabletCursorInfo, tCursorInfo)
 QTabletDeviceData currentTabletPointer;
 // from qregion_win.cpp
 extern HRGN qt_tryCreateRegion(QRegion::RegionType type, int left, int top, int right, int bottom);
 QApplicationPrivate::setSystemFont(systemFont);
 QFont smallerFont = systemFont;
 if (qt_wince_is_mobile()) {
 smallerFont.setPointSize(systemFont.pointSize()-1);
 QApplication::setFont(smallerFont, "QTabBar");
+smallerFont.setBold(true);
+QApplication::setFont(smallerFont, "QAbstractButton");
 }
 #endif// Q_WS_WINCE
 }
 static void qt_win_read_cleartype_settings()
 // QFont::locale_init();  ### Uncomment when it does something on Windows
 if (QApplication::desktopSettingsAware())
 qt_set_windows_resources();
+#ifndef QT_NO_TABLETEVENT
 initWinTabFunctions();
+#endif // QT_NO_TABLETEVENT
 QApplicationPrivate::inputContext = new QWinInputContext(0);
 // Read the initial cleartype settings...
 qt_win_read_cleartype_settings();
 qt_win_owndc_required = false;
 #if defined(Q_WS_WINCE_WM) && defined(QT_WINCE_GESTURES)
 priv->GetGestureInfo = (PtrGetGestureInfo) &TKGetGestureInfo;
 priv->GetGestureExtraArgs = (PtrGetGestureExtraArgs) &TKGetGestureExtraArguments;
 #elif !defined(Q_WS_WINCE)
+#if !defined(QT_NO_NATIVE_GESTURES)
 priv->GetGestureInfo =
 (PtrGetGestureInfo)QLibrary::resolve(QLatin1String("user32"),
 "GetGestureInfo");
 priv->GetGestureExtraArgs =
 (PtrGetGestureExtraArgs)QLibrary::resolve(QLatin1String("user32"),
 (PtrSetGestureConfig)QLibrary::resolve(QLatin1String("user32"),
 "SetGestureConfig");
 priv->GetGestureConfig =
 (PtrGetGestureConfig)QLibrary::resolve(QLatin1String("user32"),
 "GetGestureConfig");
+#endif // QT_NO_NATIVE_GESTURES
 priv->BeginPanningFeedback =
 (PtrBeginPanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
 "BeginPanningFeedback");
 priv->UpdatePanningFeedback =
 (PtrUpdatePanningFeedback)QLibrary::resolve(QLatin1String("uxtheme"),
 break;
 #ifndef Q_WS_WINCE
 case WM_ENTERSIZEMOVE:
 autoCaptureWnd = hwnd;
-QApplicationPrivate::inSizeMove = true;
 break;
 case WM_EXITSIZEMOVE:
 autoCaptureWnd = 0;
-QApplicationPrivate::inSizeMove = false;
 break;
 #endif
 case WM_MOVE:                                // move window
 case WM_SIZE:                                // resize window
 result = widget->translateConfigEvent(msg);
 result = widget->translateTabletEvent(msg, localPacketBuf, nPackets);
 }
 }
 break;
 case WT_PROXIMITY:
-if (ptrWTPacketsGet) {
-bool enteredProximity = LOWORD(lParam) != 0;
+#ifndef QT_NO_TABLETEVENT
-PACKET proximityBuffer[QT_TABLET_NPACKETQSIZE];
+if (ptrWTPacketsGet && ptrWTInfo) {
-int totalPacks = ptrWTPacketsGet(qt_tablet_context, QT_TABLET_NPACKETQSIZE, proximityBuffer);
+const bool enteredProximity = LOWORD(lParam) != 0;
-if (totalPacks > 0 && enteredProximity) {
+PACKET proximityBuffer[1]; // we are only interested in the first packet in this case
-uint currentCursor = proximityBuffer[0].pkCursor;
+const int totalPacks = ptrWTPacketsGet(qt_tablet_context, 1, proximityBuffer);
-if (!tCursorInfo()->contains(currentCursor))
+if (totalPacks > 0) {
-tabletInit(currentCursor, qt_tablet_context);
+const UINT currentCursor = proximityBuffer[0].pkCursor;
-currentTabletPointer = tCursorInfo()->value(currentCursor);
+UINT csr_physid;
+ptrWTInfo(WTI_CURSORS + currentCursor, CSR_PHYSID, &csr_physid);
+UINT csr_type;
+ptrWTInfo(WTI_CURSORS + currentCursor, CSR_TYPE, &csr_type);
+const UINT deviceIdMask = 0xFF6; // device type mask && device color mask
+quint64 uniqueId = (csr_type & deviceIdMask);
+uniqueId = (uniqueId << 32) | csr_physid;
+// initialising and updating the cursor should be done in response to
+// WT_CSRCHANGE. We do it in WT_PROXIMITY because some wintab never send
+// the event WT_CSRCHANGE even if asked with CXO_CSRMESSAGES
+const QTabletCursorInfo *const globalCursorInfo = tCursorInfo();
+if (!globalCursorInfo->contains(uniqueId))
+tabletInit(uniqueId, csr_type, qt_tablet_context);
+currentTabletPointer = globalCursorInfo->value(uniqueId);
+tabletUpdateCursor(currentTabletPointer, currentCursor);
 }
 qt_tabletChokeMouse = false;
-#ifndef QT_NO_TABLETEVENT
 QTabletEvent tabletProximity(enteredProximity ? QEvent::TabletEnterProximity
 : QEvent::TabletLeaveProximity,
 QPoint(), QPoint(), QPointF(), currentTabletPointer.currentDevice, currentTabletPointer.currentPointerType, 0, 0,
 0, 0, 0, 0, 0, currentTabletPointer.llId);
 QApplication::sendEvent(qApp, &tabletProximity);
-#endif // QT_NO_TABLETEVENT
+}
-}
+#endif // QT_NO_TABLETEVENT
 break;
 #ifdef Q_WS_WINCE_WM
 case WM_SETFOCUS: {
 HIMC hC;
 hC = ImmGetContext(hwnd);
 QApplicationPrivate *qAppPriv = QApplicationPrivate::instance();
 BOOL bResult = false;
 if (qAppPriv->GetGestureInfo)
 bResult = qAppPriv->GetGestureInfo((HANDLE)msg.lParam, &gi);
 if (bResult) {
-//                if (gi.dwID == GID_BEGIN) {
+if (gi.dwID == GID_BEGIN) {
-//                    // find the alien widget for the gesture position.
+// find the alien widget for the gesture position.
-//                    // This might not be accurate as the position is the center
+// This might not be accurate as the position is the center
-//                    // point of two fingers for multi-finger gestures.
+// point of two fingers for multi-finger gestures.
-//                    QPoint pt(gi.ptsLocation.x, gi.ptsLocation.y);
+QPoint pt(gi.ptsLocation.x, gi.ptsLocation.y);
-//                    QWidget *w = widget->childAt(widget->mapFromGlobal(pt));
+QWidget *w = widget->childAt(widget->mapFromGlobal(pt));
-//                    qAppPriv->gestureWidget = w ? w : widget;
+qAppPriv->gestureWidget = w ? w : widget;
-//                }
+}
-//                if (qAppPriv->gestureWidget)
+if (qAppPriv->gestureWidget)
-//                    static_cast<QETWidget*>(qAppPriv->gestureWidget)->translateGestureEvent(msg, gi);
+static_cast<QETWidget*>(qAppPriv->gestureWidget)->translateGestureEvent(msg, gi);
-//                if (qAppPriv->CloseGestureInfoHandle)
+if (qAppPriv->CloseGestureInfoHandle)
-//                    qAppPriv->CloseGestureInfoHandle((HANDLE)msg.lParam);
+qAppPriv->CloseGestureInfoHandle((HANDLE)msg.lParam);
-//                if (gi.dwID == GID_END)
+if (gi.dwID == GID_END)
-//                    qAppPriv->gestureWidget = 0;
+qAppPriv->gestureWidget = 0;
-//            } else {
+} else {
-//                DWORD dwErr = GetLastError();
+DWORD dwErr = GetLastError();
-//                if (dwErr > 0)
+if (dwErr > 0)
-//                    qWarning() << "translateGestureEvent: error = " << dwErr;
+qWarning() << "translateGestureEvent: error = " << dwErr;
 }
 result = true;
 break;
 }
 default:
 // Windows Wintab to QTabletEvent translation
 //
 // the following is adapted from the wintab syspress example (public domain)
 /* -------------------------------------------------------------------------- */
-static void tabletInit(UINT wActiveCsr, HCTX hTab)
+// Initialize the "static" information of a cursor device (pen, airbrush, etc).
-{
+// The QTabletDeviceData is initialized with the data that do not change in time
+// (number of button, type of device, etc) but do not initialize the variable data
+// (e.g.: pen or eraser)
+#ifndef QT_NO_TABLETEVENT
+static void tabletInit(const quint64 uniqueId, const UINT csr_type, HCTX hTab)
+{
+Q_ASSERT(ptrWTInfo);
+Q_ASSERT(ptrWTGet);
+Q_ASSERT(!tCursorInfo()->contains(uniqueId));
 /* browse WinTab's many info items to discover pressure handling. */
-if (ptrWTInfo && ptrWTGet) {
+AXIS np;
-AXIS np;
+LOGCONTEXT lc;
-LOGCONTEXT lc;
-BYTE wPrsBtn;
+/* get the current context for its device variable. */
-BYTE logBtns[32];
+ptrWTGet(hTab, &lc);
-UINT size;
+/* get the size of the pressure axis. */
-/* discover the LOGICAL button generated by the pressure channel. */
+QTabletDeviceData tdd;
-/* get the PHYSICAL button from the cursor category and run it */
+tdd.llId = uniqueId;
-/* through that cursor's button map (usually the identity map). */
-wPrsBtn = (BYTE)-1;
+ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_NPRESSURE, &np);
-ptrWTInfo(WTI_CURSORS + wActiveCsr, CSR_NPBUTTON, &wPrsBtn);
+tdd.minPressure = int(np.axMin);
-size = ptrWTInfo(WTI_CURSORS + wActiveCsr, CSR_BUTTONMAP, &logBtns);
+tdd.maxPressure = int(np.axMax);
-if ((UINT)wPrsBtn < size)
-wPrsBtn = logBtns[wPrsBtn];
+ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_TPRESSURE, &np);
+tdd.minTanPressure = int(np.axMin);
-/* get the current context for its device variable. */
+tdd.maxTanPressure = int(np.axMax);
-ptrWTGet(hTab, &lc);
+LOGCONTEXT lcMine;
-/* get the size of the pressure axis. */
-QTabletDeviceData tdd;
+/* get default region */
-ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_NPRESSURE, &np);
+ptrWTInfo(WTI_DEFCONTEXT, 0, &lcMine);
-tdd.minPressure = int(np.axMin);
-tdd.maxPressure = int(np.axMax);
+tdd.minX = 0;
+tdd.maxX = int(lcMine.lcInExtX) - int(lcMine.lcInOrgX);
-ptrWTInfo(WTI_DEVICES + lc.lcDevice, DVC_TPRESSURE, &np);
-tdd.minTanPressure = int(np.axMin);
+tdd.minY = 0;
-tdd.maxTanPressure = int(np.axMax);
+tdd.maxY = int(lcMine.lcInExtY) - int(lcMine.lcInOrgY);
-LOGCONTEXT lcMine;
+tdd.minZ = 0;
+tdd.maxZ = int(lcMine.lcInExtZ) - int(lcMine.lcInOrgZ);
-	/* get default region */
-ptrWTInfo(WTI_DEFCONTEXT, 0, &lcMine);
+const uint cursorTypeBitMask = 0x0F06; // bitmask to find the specific cursor type (see Wacom FAQ)
+if (((csr_type & 0x0006) == 0x0002) && ((csr_type & cursorTypeBitMask) != 0x0902)) {
-tdd.minX = 0;
+tdd.currentDevice = QTabletEvent::Stylus;
-tdd.maxX = int(lcMine.lcInExtX) - int(lcMine.lcInOrgX);
+} else {
+switch (csr_type & cursorTypeBitMask) {
-tdd.minY = 0;
-tdd.maxY = int(lcMine.lcInExtY) - int(lcMine.lcInOrgY);
-tdd.minZ = 0;
-tdd.maxZ = int(lcMine.lcInExtZ) - int(lcMine.lcInOrgZ);
-int csr_type,
-csr_physid;
-ptrWTInfo(WTI_CURSORS + wActiveCsr, CSR_TYPE, &csr_type);
-ptrWTInfo(WTI_CURSORS + wActiveCsr, CSR_PHYSID, &csr_physid);
-tdd.llId = csr_type & 0x0F06;
-tdd.llId = (tdd.llId << 24) | csr_physid;
-#ifndef QT_NO_TABLETEVENT
-if (((csr_type & 0x0006) == 0x0002) && ((csr_type & 0x0F06) != 0x0902)) {
-tdd.currentDevice = QTabletEvent::Stylus;
-} else {
-switch (csr_type & 0x0F06) {
 case 0x0802:
 tdd.currentDevice = QTabletEvent::Stylus;
 break;
 case 0x0902:
 tdd.currentDevice = QTabletEvent::Airbrush;
 case 0x0804:
 tdd.currentDevice = QTabletEvent::RotationStylus;
 break;
 default:
 tdd.currentDevice = QTabletEvent::NoDevice;
 }
 }
+tCursorInfo()->insert(uniqueId, tdd);
-switch (wActiveCsr % 3) {
+}
-case 2:
-tdd.currentPointerType = QTabletEvent::Eraser;
-break;
-case 1:
-tdd.currentPointerType = QTabletEvent::Pen;
-break;
-case 0:
-tdd.currentPointerType = QTabletEvent::Cursor;
-break;
-default:
-tdd.currentPointerType = QTabletEvent::UnknownPointer;
-}
 #endif // QT_NO_TABLETEVENT
-tCursorInfo()->insert(wActiveCsr, tdd);
-}
+// Update the "dynamic" informations of a cursor device (pen, airbrush, etc).
-}
+// The dynamic information is the information of QTabletDeviceData that can change
+// in time (eraser or pen if a device is turned around).
+#ifndef QT_NO_TABLETEVENT
+static void tabletUpdateCursor(QTabletDeviceData &tdd, const UINT currentCursor)
+{
+switch (currentCursor % 3) { // %3 for dual track
+case 0:
+tdd.currentPointerType = QTabletEvent::Cursor;
+break;
+case 1:
+tdd.currentPointerType = QTabletEvent::Pen;
+break;
+case 2:
+tdd.currentPointerType = QTabletEvent::Eraser;
+break;
+default:
+tdd.currentPointerType = QTabletEvent::UnknownPointer;
+}
+}
+#endif // QT_NO_TABLETEVENT
 bool QETWidget::translateTabletEvent(const MSG &msg, PACKET *localPacketBuf,
 int numPackets)
 {
 Q_UNUSED(msg);
 }
 return sendEvent;
 }
 extern bool qt_is_gui_used;
+#ifndef QT_NO_TABLETEVENT
 static void initWinTabFunctions()
 {
 #if defined(Q_OS_WINCE)
 return;
 #else
 ptrWTOverlap = (PtrWTEnable)library.resolve("WTOverlap");
 ptrWTPacketsGet = (PtrWTPacketsGet)library.resolve("WTPacketsGet");
 }
 #endif // Q_OS_WINCE
 }
+#endif // QT_NO_TABLETEVENT
 //
 // Paint event translation
 //

changeset 3	41300fa6a67c
parent 0	1918ee327afb
child 4	3b1da2848fc7