Differential D8801 Diff 23819 libs/ui/input/wintab/kis_tablet_support_win8.cpp

Changeset View

Standalone View

View Options

libs/ui/input/wintab/kis_tablet_support_win8.cpp

Show First 20 Lines • Show All 288 Lines • ▼ Show 20 Line(s)288{
289 // int pointerId; 289​ // int pointerId;
290 // POINTER_PEN_INFO penInfo; 290​ // POINTER_PEN_INFO penInfo;
291 HWND hwnd; 291​ HWND hwnd;
292 HANDLE deviceHandle; 292​ HANDLE deviceHandle;
293 QPointer<QWidget> activeWidget; // Current widget receiving events 293​ QPointer<QWidget> activeWidget; // Current widget receiving events
294 qreal oneOverDpr; // 1 / devicePixelRatio of activeWidget 294​ qreal oneOverDpr; // 1 / devicePixelRatio of activeWidget
295 bool widgetIsCaptured; // Current widget is capturing a pen cown event 295​ bool widgetIsCaptured; // Current widget is capturing a pen cown event
296 bool widgetIsIgnored; // Pen events should be ignored until pen up 296​ bool widgetIsIgnored; // Pen events should be ignored until pen up
297​ bool widgetAcceptsPenEvent; // Whether the widget accepts pen events
297 298​
298 bool isCaptured() const { 299​ bool isCaptured() const {
299 return widgetIsCaptured; 300​ return widgetIsCaptured;
300 } 301​ }
301}; 302​};
302 303​
303QHash<int, PenPointerItem> penPointers; 304​QHash<int, PenPointerItem> penPointers;
304// int primaryPenPointerId; 305​// int primaryPenPointerId;
▲ Show 20 Lines • Show All 314 Lines • ▼ Show 20 Line(s)616{
619 ); 620​ );
620 QTabletEvent ev = makeProximityTabletEvent(eventType, penInfo); 621​ QTabletEvent ev = makeProximityTabletEvent(eventType, penInfo);
621 ev.setAccepted(false); 622​ ev.setAccepted(false);
622 ev.setTimestamp(penInfo.pointerInfo.dwTime); 623​ ev.setTimestamp(penInfo.pointerInfo.dwTime);
623 QCoreApplication::sendEvent(qApp, &ev); 624​ QCoreApplication::sendEvent(qApp, &ev);
624 return ev.isAccepted(); 625​ return ev.isAccepted();
625} 626​}
626 627​
627bool sendPositionalTabletEvent(QWidget *target, const QEvent::Type eventType, const POINTER_PEN_INFO &penInfo, const PointerDeviceItem &device, const PenPointerItem &penPointerItem) 628​void synthesizeMouseEvent(const QTabletEvent &ev, const POINTER_PEN_INFO &penInfo)
629​{
630​ // Update the cursor position
631​ BOOL result = SetCursorPos(penInfo.pointerInfo.ptPixelLocationRaw.x, penInfo.pointerInfo.ptPixelLocationRaw.y);
632​ if (!result) {
633​ dbgInput << "SetCursorPos failed, err" << GetLastError();
634​ return;
635​ }
636​ // Send mousebutton down/up events. Windows stores the button state.
637​ DWORD inputDataFlags = 0;
638​ switch (ev.type()) {
639​ case QEvent::TabletPress:
640​ switch (ev.button()) {
641​ case Qt::LeftButton:
642​ inputDataFlags = MOUSEEVENTF_LEFTDOWN;
643​ break;
644​ case Qt::RightButton:
645​ inputDataFlags = MOUSEEVENTF_RIGHTDOWN;
646​ break;
647​ default:
648​ return;
649​ }
650​ break;
651​ case QEvent::TabletRelease:
652​ switch (ev.button()) {
653​ case Qt::LeftButton:
654​ inputDataFlags = MOUSEEVENTF_LEFTUP;
655​ break;
656​ case Qt::RightButton:
657​ inputDataFlags = MOUSEEVENTF_RIGHTUP;
658​ break;
659​ default:
660​ return;
661​ }
662​ break;
663​ case QEvent::TabletMove:
664​ default:
665​ return;
666​ }
667​ INPUT inputData = {};
668​ inputData.type = INPUT_MOUSE;
669​ inputData.mi.dwFlags = inputDataFlags;
670​ inputData.mi.dwExtraInfo = 0xFF515700 | 0x01; // https://msdn.microsoft.com/en-us/library/windows/desktop/ms703320%28v=vs.85%29.aspx
671​ UINT result2 = SendInput(1, &inputData, sizeof(inputData));
672​ if (result2 != 1) {
673​ dbgInput << "SendInput failed, err" << GetLastError();
674​ return;
675​ }
676​}
677​
678​bool sendPositionalTabletEvent(QWidget *target, const QEvent::Type eventType, const POINTER_PEN_INFO &penInfo, const PointerDeviceItem &device, const PenPointerItem &penPointerItem, const bool shouldSynthesizeMouseEvent)
628{ 679​{
629 KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE( 680​ KIS_SAFE_ASSERT_RECOVER_RETURN_VALUE(
630 eventType == QEvent::TabletMove || eventType == QEvent::TabletPress || eventType == QEvent::TabletRelease, 681​ eventType == QEvent::TabletMove || eventType == QEvent::TabletPress || eventType == QEvent::TabletRelease,
631 false 682​ false
632 ); 683​ );
633 QTabletEvent ev = makePositionalTabletEvent(target, eventType, penInfo, device, penPointerItem); 684​ QTabletEvent ev = makePositionalTabletEvent(target, eventType, penInfo, device, penPointerItem);
634 ev.setAccepted(false); 685​ ev.setAccepted(false);
635 ev.setTimestamp(penInfo.pointerInfo.dwTime); 686​ ev.setTimestamp(penInfo.pointerInfo.dwTime);
636 QCoreApplication::sendEvent(target, &ev); 687​ QCoreApplication::sendEvent(target, &ev);
637 return ev.isAccepted(); 688​ if (!shouldSynthesizeMouseEvent) {
689​ // For pen update with multiple updates, only the last update should
690​ // be used to synthesize a mouse event.
691​ return false;
692​ }
693​ // This is some specialized code to handle synthesizing of mouse events from
694​ // the pen events. Issues being:
695​ // 1. We must accept the pointer down/up and the intermediate update events
696​ // to indicate that we want all the pen pointer events for painting,
697​ // otherwise Windows may do weird stuff and skip passing pointer events.
698​ // 2. Some Qt and Krita code uses QCursor::pos() which calls GetCursorPos to
699​ // get the cursor position. This doesn't work nicely before ver 1709 and
700​ // doesn't work at all on ver 1709 if the pen events are handled, so we
701​ // need some way to nudge the cursor on the OS level.
702​ // It appears that using the same way (as in synthesizeMouseEvent) to nudge
703​ // the cursor does work fine for when painting on canvas (which handles
704​ // the QTabletEvent), but not for other widgets because it introduces a lag
705​ // with mouse move events on move start and immediately after mouse down.
706​ // The resolution is to simulate mouse movement with our own code only for
707​ // handled pen events, which is what the following code does.
708​ if (ev.type() == QEvent::TabletMove && ev.buttons() == Qt::NoButton) {
709​ // Let Windows synthesize mouse hover events
710​ return false;
711​ }
712​ if (ev.type() == QEvent::TabletPress && !ev.isAccepted()) {
713​ // On pen down event, if the widget doesn't handle the event, let
714​ // Windows translate the event to touch, mouse or whatever
715​ return false;
716​ }
717​ if (ev.type() != QEvent::TabletPress && !penPointerItem.widgetAcceptsPenEvent) {
718​ // For other events, if the previous pen down event wasn't handled by
719​ // the widget, continue to let Windows translate the event
720​ return false;
721​ }
722​ // Otherwise, we synthesize our mouse events
723​ synthesizeMouseEvent(ev, penInfo);
724​ return true; // and tell Windows that we do want the pen events.
638} 725​}
639 726​
640bool handlePenEnterMsg(const POINTER_PEN_INFO &penInfo) 727​bool handlePenEnterMsg(const POINTER_PEN_INFO &penInfo)
641{ 728​{
642 PointerFlagsWrapper pointerFlags = PointerFlagsWrapper::fromPenInfo(penInfo); 729​ PointerFlagsWrapper pointerFlags = PointerFlagsWrapper::fromPenInfo(penInfo);
643 if (!pointerFlags.isPrimary()) { 730​ if (!pointerFlags.isPrimary()) {
644 // Don't handle non-primary pointer messages for now 731​ // Don't handle non-primary pointer messages for now
645 dbgTablet << "Pointer" << penInfo.pointerInfo.pointerId 732​ dbgTablet << "Pointer" << penInfo.pointerInfo.pointerId
Show All 15 Lines
661 int pointerId = penInfo.pointerInfo.pointerId; 748​ int pointerId = penInfo.pointerInfo.pointerId;
662 PenPointerItem penPointerItem; 749​ PenPointerItem penPointerItem;
663 penPointerItem.hwnd = penInfo.pointerInfo.hwndTarget; 750​ penPointerItem.hwnd = penInfo.pointerInfo.hwndTarget;
664 penPointerItem.deviceHandle = penInfo.pointerInfo.sourceDevice; 751​ penPointerItem.deviceHandle = penInfo.pointerInfo.sourceDevice;
665 penPointerItem.activeWidget = nullptr; 752​ penPointerItem.activeWidget = nullptr;
666 penPointerItem.oneOverDpr = 1.0; 753​ penPointerItem.oneOverDpr = 1.0;
667 penPointerItem.widgetIsCaptured = false; 754​ penPointerItem.widgetIsCaptured = false;
668 penPointerItem.widgetIsIgnored = false; 755​ penPointerItem.widgetIsIgnored = false;
756​ penPointerItem.widgetAcceptsPenEvent = false;
669 // penPointerItem.pointerId = pointerId; 757​ // penPointerItem.pointerId = pointerId;
670 758​
671 penPointers.insert(pointerId, penPointerItem); 759​ penPointers.insert(pointerId, penPointerItem);
672 // primaryPenPointerId = pointerId; 760​ // primaryPenPointerId = pointerId;
673 761​
674 // penEnter 762​ // penEnter
675 sendProximityTabletEvent(QEvent::TabletEnterProximity, penInfo); 763​ sendProximityTabletEvent(QEvent::TabletEnterProximity, penInfo);
676 764​
Show All 16 Lines769{
693 // penLeave 781​ // penLeave
694 sendProximityTabletEvent(QEvent::TabletLeaveProximity, penInfo); 782​ sendProximityTabletEvent(QEvent::TabletLeaveProximity, penInfo);
695 783​
696 penPointers.remove(penInfo.pointerInfo.pointerId); 784​ penPointers.remove(penInfo.pointerInfo.pointerId);
697 785​
698 return false; 786​ return false;
699} 787​}
700 788​
701bool handleSinglePenUpdate(PenPointerItem &penPointerItem, const POINTER_PEN_INFO &penInfo, const PointerDeviceItem &device) 789​bool handleSinglePenUpdate(PenPointerItem &penPointerItem, const POINTER_PEN_INFO &penInfo, const PointerDeviceItem &device, const bool shouldSynthesizeMouseEvent)
702{ 790​{
703 QWidget *targetWidget; 791​ QWidget *targetWidget;
704 if (penPointerItem.isCaptured()) { 792​ if (penPointerItem.isCaptured()) {
705 if (penPointerItem.widgetIsIgnored) { 793​ if (penPointerItem.widgetIsIgnored) {
706 return false; 794​ return false;
707 } 795​ }
708 targetWidget = penPointerItem.activeWidget; 796​ targetWidget = penPointerItem.activeWidget;
709 if (!targetWidget) { 797​ if (!targetWidget) {
Show All 30 Lines800 } else {
740 targetWidget = hwndWidget->childAt(posInHwndWidget); 828​ targetWidget = hwndWidget->childAt(posInHwndWidget);
741 if (!targetWidget) { 829​ if (!targetWidget) {
742 // dbgTablet << "No childQWidget at cursor position"; 830​ // dbgTablet << "No childQWidget at cursor position";
743 targetWidget = hwndWidget; 831​ targetWidget = hwndWidget;
744 } 832​ }
745 // penPointerItem.activeWidget = targetWidget; 833​ // penPointerItem.activeWidget = targetWidget;
746 } 834​ }
747 835​
748 bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletMove, penInfo, device, penPointerItem); 836​ bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletMove, penInfo, device, penPointerItem, shouldSynthesizeMouseEvent);
749 if (!handled) { ​
750 // dbgTablet << "Target widget doesn't want pen events"; ​
751 } ​
752 return handled; 837​ return handled;
753} 838​}
754 839​
755bool handlePenUpdateMsg(const POINTER_PEN_INFO &penInfo) 840​bool handlePenUpdateMsg(const POINTER_PEN_INFO &penInfo)
756{ 841​{
757 auto currentPointerIt = penPointers.find(penInfo.pointerInfo.pointerId); 842​ auto currentPointerIt = penPointers.find(penInfo.pointerInfo.pointerId);
758 if (currentPointerIt == penPointers.end()) { 843​ if (currentPointerIt == penPointers.end()) {
759 // dbgTablet << "Pointer" << penInfo.pointerInfo.pointerId << "wasn't being handled"; 844​ // dbgTablet << "Pointer" << penInfo.pointerInfo.pointerId << "wasn't being handled";
760 return false; 845​ return false;
761 } 846​ }
762 847​
763 const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice); 848​ const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice);
764 if (devIt == penDevices.end()) { 849​ if (devIt == penDevices.end()) {
765 dbgTablet << "Device not registered???"; 850​ dbgTablet << "Device not registered???";
766 return false; 851​ return false;
767 } 852​ }
768 853​
769 // UINT32 entriesCount = 0; 854​ // UINT32 entriesCount = 0;
770 // if (!api.GetPointerPenInfoHistory(penInfo.pointerInfo.pointerId, &entriesCount, nullptr)) { 855​ // if (!api.GetPointerPenInfoHistory(penInfo.pointerInfo.pointerId, &entriesCount, nullptr)) {
771 // dbgTablet << "GetPointerPenInfoHistory (getting count) failed"; 856​ // dbgTablet << "GetPointerPenInfoHistory (getting count) failed";
772 // return false; 857​ // return false;
773 // } 858​ // }
774 UINT32 entriesCount = penInfo.pointerInfo.historyCount; 859​ UINT32 entriesCount = penInfo.pointerInfo.historyCount;
775 // dbgTablet << "entriesCount:" << entriesCount; 860​ // dbgTablet << "entriesCount:" << entriesCount;
861​ bool handled = false;
776 if (entriesCount != 1) { 862​ if (entriesCount != 1) {
777 QVector<POINTER_PEN_INFO> penInfoArray(entriesCount); 863​ QVector<POINTER_PEN_INFO> penInfoArray(entriesCount);
778 if (!api.GetPointerPenInfoHistory(penInfo.pointerInfo.pointerId, &entriesCount, penInfoArray.data())) { 864​ if (!api.GetPointerPenInfoHistory(penInfo.pointerInfo.pointerId, &entriesCount, penInfoArray.data())) {
779 dbgTablet << "GetPointerPenInfoHistory failed"; 865​ dbgTablet << "GetPointerPenInfoHistory failed";
780 return false; 866​ return false;
781 } 867​ }
782 bool handled = false; 868​ bool handled = false;
783 // The returned array is in reverse chronological order 869​ // The returned array is in reverse chronological order
784 const auto rbegin = penInfoArray.rbegin(); 870​ const auto rbegin = penInfoArray.rbegin();
785 const auto rend = penInfoArray.rend(); 871​ const auto rend = penInfoArray.rend();
872​ const auto rlast = rend - 1; // Only synthesize mouse event for the last one
786 for (auto it = rbegin; it != rend; ++it) { 873​ for (auto it = rbegin; it != rend; ++it) {
787 handled |= handleSinglePenUpdate(*currentPointerIt, *it, *devIt); // Bitwise OR doesn't short circuit 874​ handled |= handleSinglePenUpdate(*currentPointerIt, *it, *devIt, it == rlast); // Bitwise OR doesn't short circuit
788 } 875​ }
789 return handled; ​
790 } else { 876​ } else {
791 return handleSinglePenUpdate(*currentPointerIt, penInfo, *devIt); 877​ handled = handleSinglePenUpdate(*currentPointerIt, penInfo, *devIt, true);
792 } 878​ }
879​ return handled;
793} 880​}
794 881​
795bool handlePenDownMsg(const POINTER_PEN_INFO &penInfo) 882​bool handlePenDownMsg(const POINTER_PEN_INFO &penInfo)
796{ 883​{
797 // PointerFlagsWrapper pointerFlags = PointerFlagsWrapper::fromPenInfo(penInfo); 884​ // PointerFlagsWrapper pointerFlags = PointerFlagsWrapper::fromPenInfo(penInfo);
798 // if (!pointerFlags.isPrimary()) { 885​ // if (!pointerFlags.isPrimary()) {
799 // // Don't handle non-primary pointer messages for now 886​ // // Don't handle non-primary pointer messages for now
800 // return false; 887​ // return false;
▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Line(s)
846 933​
847 // penDown 934​ // penDown
848 const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice); 935​ const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice);
849 if (devIt == penDevices.end()) { 936​ if (devIt == penDevices.end()) {
850 dbgTablet << "Device not registered???"; 937​ dbgTablet << "Device not registered???";
851 return false; 938​ return false;
852 } 939​ }
853 940​
854 bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletPress, penInfo, *devIt, *currentPointerIt); 941​ bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletPress, penInfo, *devIt, *currentPointerIt, true);
942​ currentPointerIt->widgetAcceptsPenEvent = handled;
855 if (!handled) { 943​ if (!handled) {
856 // dbgTablet << "QWidget did not handle tablet down event"; 944​ // dbgTablet << "QWidget did not handle tablet down event";
857 } 945​ }
858 return handled; 946​ return handled;
859} 947​}
860 948​
861bool handlePenUpMsg(const POINTER_PEN_INFO &penInfo) 949​bool handlePenUpMsg(const POINTER_PEN_INFO &penInfo)
862{ 950​{
Show All 23 Lines
886 } 974​ }
887 975​
888 const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice); 976​ const auto devIt = penDevices.find(penInfo.pointerInfo.sourceDevice);
889 if (devIt == penDevices.end()) { 977​ if (devIt == penDevices.end()) {
890 dbgTablet << "Device not registered???"; 978​ dbgTablet << "Device not registered???";
891 return false; 979​ return false;
892 } 980​ }
893 981​
894 bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletRelease, penInfo, *devIt, penPointerItem); 982​ bool handled = sendPositionalTabletEvent(targetWidget, QEvent::TabletRelease, penInfo, *devIt, penPointerItem, true);
895 983​
896 // dbgTablet << "QWidget" << currentPointerIt->activeWidget->windowTitle() << "is releasing capture to pointer" << penInfo.pointerInfo.pointerId; 984​ // dbgTablet << "QWidget" << currentPointerIt->activeWidget->windowTitle() << "is releasing capture to pointer" << penInfo.pointerInfo.pointerId;
897 penPointerItem.widgetIsCaptured = false; 985​ penPointerItem.widgetIsCaptured = false;
986​ penPointerItem.widgetAcceptsPenEvent = false;
898 return handled; 987​ return handled;
899} 988​}
900 989​
901bool handlePointerMsg(const MSG &msg) 990​bool handlePointerMsg(const MSG &msg)
902{ 991​{
903 if (!api.isLoaded()) { 992​ if (!api.isLoaded()) {
904 qWarning() << "Windows 8 Pointer Input API functions not loaded"; 993​ qWarning() << "Windows 8 Pointer Input API functions not loaded";
905 return false; 994​ return false;
▲ Show 20 Lines • Show All 68 Lines • ▼ Show 20 Line(s)1062 case WM_POINTERDOWN:
974 return handlePenDownMsg(penInfo); 1063​ return handlePenDownMsg(penInfo);
975 case WM_POINTERUP: 1064​ case WM_POINTERUP:
976 return handlePenUpMsg(penInfo); 1065​ return handlePenUpMsg(penInfo);
977 case WM_POINTERENTER: 1066​ case WM_POINTERENTER:
978 return handlePenEnterMsg(penInfo); 1067​ return handlePenEnterMsg(penInfo);
979 case WM_POINTERLEAVE: 1068​ case WM_POINTERLEAVE:
980 return handlePenLeaveMsg(penInfo); 1069​ return handlePenLeaveMsg(penInfo);
981 case WM_POINTERUPDATE: 1070​ case WM_POINTERUPDATE:
982 // HACK: Force further processing to force Windows to generate mouse move events 1071​ return handlePenUpdateMsg(penInfo);
983 handlePenUpdateMsg(penInfo); ​
984 return false; ​
985 case WM_POINTERCAPTURECHANGED: 1072​ case WM_POINTERCAPTURECHANGED:
986 // TODO: Should this event be handled? 1073​ // TODO: Should this event be handled?
987 dbgTablet << "FIXME: WM_POINTERCAPTURECHANGED isn't handled"; 1074​ dbgTablet << "FIXME: WM_POINTERCAPTURECHANGED isn't handled";
988 break; 1075​ break;
989 } 1076​ }
990 1077​
991 return false; 1078​ return false;
992} 1079​}
993 1080​
994} // namespace 1081​} // namespace