StWindow, Windows - fix enhanced scroll input

Author: gkv311

StCore/StWindowImpl.cpp

@@ -97,6 +97,10 @@ StWindowImpl::StWindowImpl(const StHandle<StResourceManager>& theResMgr,
   myIsMouseMoved(false) {
     stMemZero(&attribs, sizeof(attribs));
     stMemZero(&signals, sizeof(signals));
+    myStEvent   .Type = stEvent_None;
+    myStEvent2  .Type = stEvent_None;
+    myStEventAux.Type = stEvent_None;
+    myScrollAcc.reset();
     attribs.IsNoDecor      = false;
     attribs.IsStereoOutput = false;
     attribs.IsGlStereo     = false;

StCore/StWindowImpl.h

@@ -477,6 +477,7 @@ class StWindowImpl {
     StEvent        myStEvent;          //!< temporary event object (to be used in message loop thread)
     StEvent        myStEvent2;         //!< temporary event object (to be used in message loop thread)
     StEvent        myStEventAux;       //!< extra temporary event object (to be used in StWindow creation thread)
+    StScrollEvent  myScrollAcc;        //!< extra temporary event object accumulating mouse scroll events
     int            myAlignDL;          //!< extra window shift applied for alignment (left)
     int            myAlignDR;          //!< extra window shift applied for alignment (right)
     int            myAlignDT;          //!< extra window shift applied for alignment (top)

StCore/StWindowImplWin.cpp

@@ -875,25 +875,32 @@ LRESULT StWindowImpl::stWndProc(HWND theWin, UINT uMsg, WPARAM wParam, LPARAM lP
             return 0;
         }
         case WM_MOUSEWHEEL:    // vertical wheel
-        //case WM_MOUSEHWHEEL:   // horizontal wheel (only Vista+)
+        case WM_MOUSEHWHEEL:   // horizontal wheel (only Vista+)
         {
             const StRectI_t aWinRect = getPlacement();
             int aMouseXPx = int(short(LOWORD(lParam))) - aWinRect.left();
             int aMouseYPx = int(short(HIWORD(lParam))) - aWinRect.top();
 
-            int aZDelta = GET_WHEEL_DELTA_WPARAM(wParam); // / WHEEL_DELTA;
-            //if(GET_X_LPARAM(lParam) != 0)
-
-            myStEvent.Type = stEvent_Scroll;
-            myStEvent.Scroll.Time   = getEventTime(myEvent.time);
-            myStEvent.Scroll.PointX = double(aMouseXPx) / double(aWinRect.width());
-            myStEvent.Scroll.PointY = double(aMouseYPx) / double(aWinRect.height());
-            myStEvent.Scroll.StepsX = 0;
-            myStEvent.Scroll.StepsY = (aZDelta > 0) ? 1 : -1;
-            myStEvent.Scroll.DeltaX = 0.0;
-            myStEvent.Scroll.DeltaY = 10.0f * myStEvent.Scroll.StepsY;
-            myStEvent.Scroll.IsFromMultiTouch = false;
-
+            const bool  isVert   = (uMsg == WM_MOUSEWHEEL);
+            const int   aZDelta  = GET_WHEEL_DELTA_WPARAM(wParam);
+            const float aDeltaSt = 10.0f * (float(aZDelta) / float(WHEEL_DELTA));
+
+            myStEvent.Scroll.init(getEventTime(myEvent.time),
+                                  double(aMouseXPx) / double(aWinRect.width()),
+                                  double(aMouseYPx) / double(aWinRect.height()),
+                                  !isVert ? aDeltaSt : 0.0f,
+                                   isVert ? aDeltaSt : 0.0f,
+                                  false);
+            if((myStEvent.Scroll.Time - myScrollAcc.Time) > 0.1
+             || std::abs(aMouseXPx - (int)myScrollAcc.PointX) > 10
+             || std::abs(aMouseYPx - (int)myScrollAcc.PointY) > 10) {
+                myScrollAcc.reset();
+            }
+            myScrollAcc.Time = myStEvent.Scroll.Time;
+            myScrollAcc.PointX = aMouseXPx;
+            myScrollAcc.PointY = aMouseYPx;
+            myStEvent.Scroll.StepsX = myScrollAcc.accumulateStepsX(!isVert ? aZDelta : 0, WHEEL_DELTA);
+            myStEvent.Scroll.StepsY = myScrollAcc.accumulateStepsY( isVert ? aZDelta : 0, WHEEL_DELTA);
             myEventsBuffer.append(myStEvent);
             return 0;
         }

StOutPageFlip/StDXNVWindow.cpp

@@ -112,19 +112,22 @@ LRESULT StDXNVWindow::wndProcFunction(HWND   theWnd,
                                       LPARAM theParamL) {
     // we do stupid checks here...
     if(myStWin->isFullScreen() && myStWin->isStereoOutput()) {
-        if(theMsg == WM_MOUSEWHEEL) {
-            int zDelta = GET_WHEEL_DELTA_WPARAM(theParamW);
+        if(theMsg == WM_MOUSEWHEEL
+        || theMsg == WM_MOUSEHWHEEL) {
+            const bool  isVert   = (theMsg == WM_MOUSEWHEEL);
+            const int   aZDelta  = GET_WHEEL_DELTA_WPARAM(theParamW);
+            const int   aNbSteps = (aZDelta > 0) ? 1 : -1;
+            const float aDeltaSt = 10.0f * (float(aZDelta) / float(WHEEL_DELTA));
             const StPointD_t aPnt = myStWin->getMousePos();
             StEvent anEvent;
-            anEvent.Type = stEvent_Scroll;
-            anEvent.Scroll.Time   = 0.0; //getEventTime(myEvent.time);
-            anEvent.Scroll.PointX = aPnt.x();
-            anEvent.Scroll.PointY = aPnt.y();
-            anEvent.Scroll.StepsX = 0;
-            anEvent.Scroll.StepsY = (zDelta > 0) ? 1 : -1;
-            anEvent.Scroll.DeltaX = 0.0;
-            anEvent.Scroll.DeltaY = 10.0f * anEvent.Scroll.StepsY;
-            anEvent.Scroll.IsFromMultiTouch = false;
+            anEvent.Scroll.init(0.0, //getEventTime(myEvent.time);
+                                aPnt.x(),
+                                aPnt.y(),
+                                !isVert ? aDeltaSt : 0.0f,
+                                 isVert ? aDeltaSt : 0.0f,
+                                false);
+            anEvent.Scroll.StepsX = !isVert ? aNbSteps : 0;
+            anEvent.Scroll.StepsY =  isVert ? aNbSteps : 0;
             myStWin->post(anEvent);
         }
 

include/StCore/StEvent.h

@@ -186,6 +186,65 @@ struct StScrollEvent {
     float         DeltaY;           //!< precise  delta for vertical   scroll
     bool          IsFromMultiTouch; //!< when true, scrolling is simulated from multi-touch gesture by system (OS X) and touches will come in parallel
 
+    /**
+     * Reset event.
+     */
+    void reset() {
+        Type  = stEvent_Scroll;
+        Time  = 0.0;
+        PointX = 0.0;
+        PointY = 0.0;
+        StepsX = 0;
+        StepsY = 0;
+        DeltaX = 0.0f;
+        DeltaY = 0.0f;
+        IsFromMultiTouch = false;
+    }
+
+    /**
+     * Initialize event.
+     */
+    void init(double theTime,
+              double thePointX,
+              double thePointY,
+              float  theDeltaX,
+              float  theDeltaY,
+              bool   theIsFromMultiTouch) {
+        Type  = stEvent_Scroll;
+        Time  = theTime;
+        PointX = thePointX;
+        PointY = thePointY;
+        StepsX = 0;
+        StepsY = 0;
+        DeltaX = theDeltaX;
+        DeltaY = theDeltaY;
+        IsFromMultiTouch = theIsFromMultiTouch;
+    }
+
+    /**
+     * Compute accumulated integer steps from X scroll event.
+     */
+    int accumulateStepsX(int theInc, int theStepSize) { return accumulateSteps(StepsX, theInc, theStepSize); }
+
+    /**
+     * Compute accumulated integer steps from Y scroll event.
+     */
+    int accumulateStepsY(int theInc, int theStepSize) { return accumulateSteps(StepsY, theInc, theStepSize); }
+
+    /**
+     * Compute accumulated integer steps from scroll event.
+     */
+    static int accumulateSteps(int& theAcc, int theInc, int theStepSize) {
+        theAcc += theInc;
+        int aNbSteps = 0;
+        for(; theAcc <= -theStepSize; theAcc += theStepSize) {
+            --aNbSteps;
+        }
+        for(; theAcc >= theStepSize; theAcc -= theStepSize) {
+            ++aNbSteps;
+        }
+        return aNbSteps;
+    }
 };
 
 /**