Manually pass mouse wheel messages to TermControls

src/cascadia/TerminalControl/TermControl.cpp

@@ -1193,7 +1193,7 @@ namespace winrt::Microsoft::Terminal::TerminalControl::implementation
     }
 
     // Method Description:
-    // - Actually handle a scrolling event, with from a mouse wheel or a
+    // - Actually handle a scrolling event, wether from a mouse wheel or a
     //   touchpad scroll. Depending upon what modifier keys are pressed,
     //   different actions will take place.
     //   * Attempts to first dispatch the mouse scroll as a VT event

src/cascadia/TerminalCore/ControlKeyStates.hpp

@@ -48,7 +48,8 @@ class Microsoft::Terminal::Core::ControlKeyStates
     }
 
 #ifdef WINRT_Windows_System_H
-    ControlKeyStates(const winrt::Windows::System::VirtualKeyModifiers& modifiers) noexcept
+    ControlKeyStates(const winrt::Windows::System::VirtualKeyModifiers& modifiers) noexcept :
+        _value{ 0 }
     {
         // static_cast to a uint32_t because we can't use the WI_IsFlagSet
         // macro directly with a VirtualKeyModifiers

src/cascadia/WindowsTerminal/AppHost.cpp

@@ -362,18 +362,23 @@ void AppHost::_WindowMouseWheeled(const til::point coord, const int32_t delta)
             // If that element has implemented IMouseWheelListener, call OnMouseWheel on that element.
             if (auto control{ e.try_as<winrt::Microsoft::Terminal::TerminalControl::IMouseWheelListener>() })
             {
-                // Translate the event to the coordinate space of the control
-                // we're attempting to dispatch it to
-                const auto transform = e.TransformToVisual(nullptr);
-                const auto controlOrigin = transform.TransformPoint(til::point{ 0, 0 });
-                const til::point offsetPoint{ ::base::ClampSub(coord.x(), controlOrigin.X), ::base::ClampSub(coord.y(), controlOrigin.Y) };
-
-                if (control.OnMouseWheel(offsetPoint, delta))
+                try
                 {
-                    // If the element handled the mouse wheel event, don't
-                    // continue to iterate over the remaining controls.
-                    break;
+                    // Translate the event to the coordinate space of the control
+                    // we're attempting to dispatch it to
+                    const auto transform = e.TransformToVisual(nullptr);
+                    const til::point controlOrigin{ til::math::flooring, transform.TransformPoint(til::point{ 0, 0 }) };
+
+                    const til::point offsetPoint = coord - controlOrigin;
+
+                    if (control.OnMouseWheel(offsetPoint, delta))
+                    {
+                        // If the element handled the mouse wheel event, don't
+                        // continue to iterate over the remaining controls.
+                        break;
+                    }
                 }
+                CATCH_LOG();
             }
         }
     }

src/cascadia/WindowsTerminal/IslandWindow.cpp

@@ -327,37 +327,39 @@ void IslandWindow::OnSize(const UINT width, const UINT height)
         return 0;
     }
     case WM_MOUSEWHEEL:
-    {
-        // This whole handler is a hack for GH#979.
-        //
-        // On some laptops, their trackpads won't scroll inactive windows
-        // _ever_. With our entire window just being one giant XAML Island, the
-        // touchpad driver thinks our entire window is inactive, and won't
-        // scroll the XAML island. On those types of laptops, we'll get a
-        // WM_MOUSEWHEEL here, in our root window, when the trackpad scrolls.
-        // We're going to take that message and manually plumb it through to our
-        // TermControl's, or anything else that implements IMouseWheelListener.
-
-        // https://msdn.microsoft.com/en-us/library/windows/desktop/ms645617(v=vs.85).aspx
-        // Important! Do not use the LOWORD or HIWORD macros to extract the x-
-        // and y- coordinates of the cursor position because these macros return
-        // incorrect results on systems with multiple monitors. Systems with
-        // multiple monitors can have negative x- and y- coordinates, and LOWORD
-        // and HIWORD treat the coordinates as unsigned quantities.
-        const til::point eventPoint{ GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) };
-        // This mouse event is relative to the display origin, not the window. Convert here.
-        const til::rectangle windowRect{ GetWindowRect() };
-        const auto origin = windowRect.origin();
-        const auto relative = eventPoint - origin;
-        // Convert to logical scaling before raising the event.
-        const auto real = relative / GetCurrentDpiScale();
-
-        const short wheelDelta = static_cast<short>(HIWORD(wparam));
-
-        // Raise an event, so any listeners can handle the mouse wheel event manually.
-        _MouseScrolledHandlers(real, wheelDelta);
-        return 0;
-    }
+        try
+        {
+            // This whole handler is a hack for GH#979.
+            //
+            // On some laptops, their trackpads won't scroll inactive windows
+            // _ever_. With our entire window just being one giant XAML Island, the
+            // touchpad driver thinks our entire window is inactive, and won't
+            // scroll the XAML island. On those types of laptops, we'll get a
+            // WM_MOUSEWHEEL here, in our root window, when the trackpad scrolls.
+            // We're going to take that message and manually plumb it through to our
+            // TermControl's, or anything else that implements IMouseWheelListener.
+
+            // https://msdn.microsoft.com/en-us/library/windows/desktop/ms645617(v=vs.85).aspx
+            // Important! Do not use the LOWORD or HIWORD macros to extract the x-
+            // and y- coordinates of the cursor position because these macros return
+            // incorrect results on systems with multiple monitors. Systems with
+            // multiple monitors can have negative x- and y- coordinates, and LOWORD
+            // and HIWORD treat the coordinates as unsigned quantities.
+            const til::point eventPoint{ GET_X_LPARAM(lparam), GET_Y_LPARAM(lparam) };
+            // This mouse event is relative to the display origin, not the window. Convert here.
+            const til::rectangle windowRect{ GetWindowRect() };
+            const auto origin = windowRect.origin();
+            const auto relative = eventPoint - origin;
+            // Convert to logical scaling before raising the event.
+            const auto real = relative / GetCurrentDpiScale();
+
+            const short wheelDelta = static_cast<short>(HIWORD(wparam));
+
+            // Raise an event, so any listeners can handle the mouse wheel event manually.
+            _MouseScrolledHandlers(real, wheelDelta);
+            return 0;
+        }
+        CATCH_LOG();
     }
 
     // TODO: handle messages here...

src/inc/til/point.h

@@ -174,6 +174,12 @@ namespace til // Terminal Implementation Library. Also: "Today I Learned"
             return point{ x, y };
         }
 
+        point& operator/=(const point& other)
+        {
+            *this = *this / other;
+            return *this;
+        }
+
         template<typename T>
         point operator*(const T& scale) const
         {

src/til/ut_til/PointTests.cpp

@@ -710,4 +710,101 @@ class PointTests
             VERIFY_ARE_EQUAL(expected, pt / scale);
         }
     }
+
+    template<typename T>
+    struct PointTypeWith_xy
+    {
+        T x, y;
+    };
+    template<typename T>
+    struct PointTypeWith_XY
+    {
+        T X, Y;
+    };
+    TEST_METHOD(CastFromFloatWithMathTypes)
+    {
+        PointTypeWith_xy<float> xyFloatIntegral{ 1.f, 2.f };
+        PointTypeWith_xy<float> xyFloat{ 1.6f, 2.4f };
+        PointTypeWith_XY<double> XYDoubleIntegral{ 3., 4. };
+        PointTypeWith_XY<double> XYDouble{ 3.6, 4.4 };
+        Log::Comment(L"0.) Ceiling");
+        {
+            {
+                til::point converted{ til::math::ceiling, xyFloatIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::ceiling, xyFloat };
+                VERIFY_ARE_EQUAL((til::point{ 2, 3 }), converted);
+            }
+            {
+                til::point converted{ til::math::ceiling, XYDoubleIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+            {
+                til::point converted{ til::math::ceiling, XYDouble };
+                VERIFY_ARE_EQUAL((til::point{ 4, 5 }), converted);
+            }
+        }
+
+        Log::Comment(L"1.) Flooring");
+        {
+            {
+                til::point converted{ til::math::flooring, xyFloatIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::flooring, xyFloat };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::flooring, XYDoubleIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+            {
+                til::point converted{ til::math::flooring, XYDouble };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+        }
+
+        Log::Comment(L"2.) Rounding");
+        {
+            {
+                til::point converted{ til::math::rounding, xyFloatIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::rounding, xyFloat };
+                VERIFY_ARE_EQUAL((til::point{ 2, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::rounding, XYDoubleIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+            {
+                til::point converted{ til::math::rounding, XYDouble };
+                VERIFY_ARE_EQUAL((til::point{ 4, 4 }), converted);
+            }
+        }
+
+        Log::Comment(L"3.) Truncating");
+        {
+            {
+                til::point converted{ til::math::truncating, xyFloatIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::truncating, xyFloat };
+                VERIFY_ARE_EQUAL((til::point{ 1, 2 }), converted);
+            }
+            {
+                til::point converted{ til::math::truncating, XYDoubleIntegral };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+            {
+                til::point converted{ til::math::truncating, XYDouble };
+                VERIFY_ARE_EQUAL((til::point{ 3, 4 }), converted);
+            }
+        }
+    }
 };