react-native-windows 0.72.13 → 0.73.0-preview.1

package/Microsoft.ReactNative/Fabric/Composition/CompositionEventHandler.cpp

@@ -7,17 +7,24 @@
 
 #include <Fabric/FabricUIManagerModule.h>
 #include <IReactContext.h>
+#include <React.h>
 #include <Views/DevMenu.h>
 #include <Views/ShadowNodeBase.h>
 #include <windows.h>
 #include <windowsx.h>
+#include <winrt/Windows.UI.Input.h>
+#include "Composition.Input.h"
 #include "CompositionRootView.h"
 #include "CompositionViewComponentView.h"
 #include "RootComponentView.h"
 
+#ifdef USE_WINUI3
+#include <winrt/Microsoft.UI.Input.h>
+#endif
+
 namespace Microsoft::ReactNative {
 
-const PointerId MOUSE_POINTER_ID = 1; // TODO ensure this is something that does not conflict with pointer point IDs.
+const PointerId MOUSE_POINTER_ID = 1;
 
 bool IsMousePointerEvent(const facebook::react::PointerEvent &pointerEvent) {
   return pointerEvent.pointerId == MOUSE_POINTER_ID;
@@ -31,6 +38,14 @@ bool IsViewListeningToEvent(IComponentView *view, facebook::react::ViewEvents::O
   return false;
 }
 
+bool IsViewListeningToEvent(IComponentView *view, facebook::react::WindowsViewEvents::Offset eventType) {
+  if (view) {
+    auto const &viewProps = *std::static_pointer_cast<facebook::react::ViewProps const>(view->props());
+    return viewProps.windowsEvents[eventType];
+  }
+  return false;
+}
+
 bool IsAnyViewInPathListeningToEvent(
     std::vector<IComponentView *> &path,
     facebook::react::ViewEvents::Offset eventType) {
@@ -44,7 +59,7 @@ bool IsAnyViewInPathListeningToEvent(
 
 IComponentView *FindClosestFabricManagedTouchableView(IComponentView *componentView) {
   while (componentView) {
-    if (componentView->touchEventEmitter()) {
+    if (componentView->eventEmitter()) {
       return componentView;
     }
     componentView = componentView->parent();
@@ -72,17 +87,169 @@ facebook::react::SharedEventEmitter EventEmitterForComponent(
   return nullptr;
 }
 
-CompositionEventHandler::CompositionEventHandler(const winrt::Microsoft::ReactNative::ReactContext &context)
-    : m_context(context) {}
+struct CompositionKeyboardSource
+    : winrt::implements<CompositionKeyboardSource, winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource> {
+  CompositionKeyboardSource(CompositionEventHandler *outer) : m_outer(outer) {}
+
+  winrt::Windows::UI::Core::CoreVirtualKeyStates GetKeyState(winrt::Windows::System::VirtualKey key) noexcept {
+    if (!m_outer)
+      return winrt::Windows::UI::Core::CoreVirtualKeyStates::None;
+    return m_outer->GetKeyState(key);
+  }
+
+  void Disconnect() noexcept {
+    m_outer = nullptr;
+  }
+
+ private:
+  CompositionEventHandler *m_outer{nullptr};
+};
+
+#ifdef USE_WINUI3
+struct CompositionInputKeyboardSource : winrt::implements<
+                                            CompositionInputKeyboardSource,
+                                            winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource> {
+  CompositionInputKeyboardSource(winrt::Microsoft::UI::Input::InputKeyboardSource source) : m_source(source) {}
+
+  winrt::Windows::UI::Core::CoreVirtualKeyStates GetKeyState(winrt::Windows::System::VirtualKey key) noexcept {
+    if (!m_source)
+      return winrt::Windows::UI::Core::CoreVirtualKeyStates::None;
+
+    static_assert(
+        static_cast<winrt::Windows::UI::Core::CoreVirtualKeyStates>(
+            winrt::Microsoft::UI::Input::VirtualKeyStates::Down) ==
+        winrt::Windows::UI::Core::CoreVirtualKeyStates::Down);
+    static_assert(
+        static_cast<winrt::Windows::UI::Core::CoreVirtualKeyStates>(
+            winrt::Microsoft::UI::Input::VirtualKeyStates::Locked) ==
+        winrt::Windows::UI::Core::CoreVirtualKeyStates::Locked);
+    static_assert(
+        static_cast<winrt::Windows::UI::Core::CoreVirtualKeyStates>(
+            winrt::Microsoft::UI::Input::VirtualKeyStates::None) ==
+        winrt::Windows::UI::Core::CoreVirtualKeyStates::None);
+    return static_cast<winrt::Windows::UI::Core::CoreVirtualKeyStates>(m_source.GetKeyState(key));
+  }
+
+  void Disconnect() noexcept {
+    m_source = nullptr;
+  }
+
+ private:
+  winrt::Microsoft::UI::Input::InputKeyboardSource m_source{nullptr};
+};
+#endif
 
 CompositionEventHandler::CompositionEventHandler(
     const winrt::Microsoft::ReactNative::ReactContext &context,
     const winrt::Microsoft::ReactNative::CompositionRootView &CompositionRootView)
-    : CompositionEventHandler(context) {
+    : m_context(context) {
   m_compRootView = CompositionRootView;
+
+#ifdef USE_WINUI3
+  if (auto island = m_compRootView.Island()) {
+    auto pointerSource = winrt::Microsoft::UI::Input::InputPointerSource::GetForIsland(island);
+
+    m_pointerPressedToken =
+        pointerSource.PointerPressed([this](
+                                         winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                         winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+          if (SurfaceId() == -1)
+            return;
+
+          auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+              args.CurrentPoint());
+          onPointerPressed(pp, args.KeyModifiers());
+        });
+
+    m_pointerReleasedToken =
+        pointerSource.PointerReleased([this](
+                                          winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                          winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+          if (SurfaceId() == -1)
+            return;
+
+          auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+              args.CurrentPoint());
+          onPointerReleased(pp, args.KeyModifiers());
+        });
+
+    m_pointerMovedToken = pointerSource.PointerMoved([this](
+                                                         winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                                         winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          args.CurrentPoint());
+      onPointerMoved(pp, args.KeyModifiers());
+    });
+
+    m_pointerWheelChangedToken =
+        pointerSource.PointerWheelChanged([this](
+                                              winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                              winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+          if (SurfaceId() == -1)
+            return;
+
+          auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+              args.CurrentPoint());
+          onPointerWheelChanged(pp, args.KeyModifiers());
+        });
+
+    auto keyboardSource = winrt::Microsoft::UI::Input::InputKeyboardSource::GetForIsland(island);
+
+    m_keyDownToken = keyboardSource.KeyDown([this](
+                                                winrt::Microsoft::UI::Input::InputKeyboardSource const &source,
+                                                winrt::Microsoft::UI::Input::KeyEventArgs const &args) {
+      if (SurfaceId() == -1)
+        return;
+
+      auto focusedComponent = RootComponentView().GetFocusedComponent();
+      auto keyArgs = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
+          focusedComponent
+              ? focusedComponent->tag()
+              : static_cast<facebook::react::Tag>(
+                    winrt::get_self<winrt::Microsoft::ReactNative::implementation::CompositionRootView>(m_compRootView)
+                        ->GetTag()),
+          args);
+      auto keyboardSource = winrt::make<CompositionInputKeyboardSource>(source);
+      onKeyDown(keyboardSource, keyArgs);
+      winrt::get_self<CompositionInputKeyboardSource>(keyboardSource)->Disconnect();
+    });
+
+    m_keyUpToken = keyboardSource.KeyUp([this](
+                                            winrt::Microsoft::UI::Input::InputKeyboardSource const &source,
+                                            winrt::Microsoft::UI::Input::KeyEventArgs const &args) {
+      if (SurfaceId() == -1)
+        return;
+
+      auto focusedComponent = RootComponentView().GetFocusedComponent();
+      auto keyArgs = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
+          focusedComponent
+              ? focusedComponent->tag()
+              : static_cast<facebook::react::Tag>(
+                    winrt::get_self<winrt::Microsoft::ReactNative::implementation::CompositionRootView>(m_compRootView)
+                        ->GetTag()),
+          args);
+      auto keyboardSource = winrt::make<CompositionInputKeyboardSource>(source);
+      onKeyUp(keyboardSource, keyArgs);
+      winrt::get_self<CompositionInputKeyboardSource>(keyboardSource)->Disconnect();
+    });
+  }
+#endif
 };
 
-CompositionEventHandler::~CompositionEventHandler() {}
+CompositionEventHandler::~CompositionEventHandler() {
+#ifdef USE_WINUI3
+  if (auto island = m_compRootView.Island()) {
+    auto pointerSource = winrt::Microsoft::UI::Input::InputPointerSource::GetForIsland(island);
+    pointerSource.PointerPressed(m_pointerPressedToken);
+    pointerSource.PointerReleased(m_pointerReleasedToken);
+    pointerSource.PointerMoved(m_pointerMovedToken);
+    pointerSource.PointerWheelChanged(m_pointerWheelChangedToken);
+    auto keyboardSource = winrt::Microsoft::UI::Input::InputKeyboardSource::GetForIsland(island);
+    keyboardSource.KeyDown(m_keyDownToken);
+    keyboardSource.KeyUp(m_keyUpToken);
+  }
+#endif
+}
 
 facebook::react::SurfaceId CompositionEventHandler::SurfaceId() noexcept {
   return static_cast<facebook::react::SurfaceId>(
@@ -96,66 +263,98 @@ facebook::react::SurfaceId CompositionEventHandler::SurfaceId() noexcept {
   return static_cast<::Microsoft::ReactNative::RootComponentView &>(*(rootComponentViewDescriptor.view));
 }
 
-// For DM
-/*
-void CompositionEventHandler::PointerDown(facebook::react::SurfaceId surfaceId, uint32_t pointerId) {
-  if (std::shared_ptr<FabricUIManager> fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(
-          winrt::Microsoft::ReactNative::ReactPropertyBag(m_context->Properties()))) {
-    facebook::react::Point ptLocal;
+void CompositionEventHandler::onPointerWheelChanged(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  if (std::shared_ptr<FabricUIManager> fabricuiManager =
+          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
+    auto position = pointerPoint.Position();
 
+    facebook::react::Point ptLocal;
+    facebook::react::Point ptScaled = {static_cast<float>(position.X), static_cast<float>(position.Y)};
 
-  auto pp = winrt::Windows::UI::Input::PointerPoint::GetCurrentPoint(pointerId);
+    auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
 
+    if (tag == -1)
+      return;
 
-  auto rootComponentViewDescriptor = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(surfaceId);
-  auto tag = rootComponentViewDescriptor.view->hitTest({pp.Position().X, pp.Position().Y}, ptLocal);
+    auto targetComponentView = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view;
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        tag, pointerPoint, keyModifiers);
 
-  if (tag != -1) {
-  auto hitComponentViewDescriptor = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag);
-    static_cast<CompositionBaseComponentView &>(*hitComponentViewDescriptor.view).OnPointerDown(pp);
+    std::static_pointer_cast<CompositionBaseComponentView>(targetComponentView)->onPointerWheelChanged(args);
   }
+}
 
-  //fabricuiManager
-
+winrt::Windows::UI::Core::CoreVirtualKeyStates CompositionEventHandler::GetKeyState(
+    winrt::Windows::System::VirtualKey key) noexcept {
+  winrt::Windows::UI::Core::CoreVirtualKeyStates coreKeyState = winrt::Windows::UI::Core::CoreVirtualKeyStates::None;
+  SHORT keyState = ::GetKeyState(static_cast<int>(key));
+  if (keyState & 0x01) {
+    coreKeyState = winrt::Windows::UI::Core::CoreVirtualKeyStates::Locked;
+  }
+  if (keyState & 0x8000) {
+    coreKeyState = static_cast<winrt::Windows::UI::Core::CoreVirtualKeyStates>(
+        static_cast<int>(coreKeyState) | static_cast<int>(winrt::Windows::UI::Core::CoreVirtualKeyStates::Down));
   }
 
+  return coreKeyState;
 }
-*/
-
-void CompositionEventHandler::ScrollWheel(facebook::react::Point pt, uint32_t delta) {
-  if (std::shared_ptr<FabricUIManager> fabricuiManager =
-          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
-    facebook::react::Point ptLocal;
 
-    RootComponentView().ScrollWheel(
-        {static_cast<float>(pt.x / m_compRootView.ScaleFactor()),
-         static_cast<float>(pt.y / m_compRootView.ScaleFactor())},
-        delta);
+winrt::Windows::System::VirtualKeyModifiers GetKeyModifiers(uint64_t wParam) {
+  auto keyModifiers = winrt::Windows::System::VirtualKeyModifiers::None;
+  if ((wParam & MK_CONTROL) == MK_CONTROL) {
+    keyModifiers |= winrt::Windows::System::VirtualKeyModifiers::Control;
+  }
+  if ((wParam & MK_SHIFT) == MK_SHIFT) {
+    keyModifiers |= winrt::Windows::System::VirtualKeyModifiers::Shift;
+  }
+  if (::GetKeyState(VK_MENU) < 0) {
+    keyModifiers |= winrt::Windows::System::VirtualKeyModifiers::Menu;
   }
+  if (::GetKeyState(VK_LWIN) < 0 || ::GetKeyState(VK_RWIN) < 0) {
+    keyModifiers |= winrt::Windows::System::VirtualKeyModifiers::Windows;
+  }
+  return keyModifiers;
 }
 
 int64_t CompositionEventHandler::SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
   switch (msg) {
     case WM_LBUTTONDOWN: {
-      ButtonDown(msg, wParam, lParam);
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerPressed(pp, GetKeyModifiers(wParam));
       return 0;
     }
     case WM_POINTERDOWN: {
-      PointerPressed(msg, wParam, lParam);
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerPressed(pp, GetKeyModifiers(wParam));
       return 0;
     }
     case WM_LBUTTONUP: {
-      ButtonUp(msg, wParam, lParam);
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerReleased(pp, GetKeyModifiers(wParam));
       return 0;
     }
     case WM_POINTERUP: {
-      PointerUp(msg, wParam, lParam);
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerReleased(pp, GetKeyModifiers(wParam));
       return 0;
     }
     case WM_MOUSEMOVE: {
-      MouseMove(msg, wParam, lParam);
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerMoved(pp, GetKeyModifiers(wParam));
       return 0;
     }
+    case WM_MOUSEWHEEL: {
+      auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+          msg, wParam, lParam, m_compRootView.ScaleFactor());
+      onPointerWheelChanged(pp, GetKeyModifiers(wParam));
+    }
     case WM_CHAR:
     case WM_SYSCHAR: {
       // TODO full bubbling of events
@@ -164,53 +363,82 @@ int64_t CompositionEventHandler::SendMessage(uint32_t msg, uint64_t wParam, int6
         if (result)
           return result;
       }
+      break;
     }
     case WM_KEYDOWN:
     case WM_KEYUP:
     case WM_SYSKEYDOWN:
     case WM_SYSKEYUP: {
-      // TODO full bubbling of events
-      if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
-        auto result = focusedComponent->sendMessage(msg, wParam, lParam);
-        if (result)
-          return result;
+      auto focusedComponent = RootComponentView().GetFocusedComponent();
+      auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::KeyRoutedEventArgs>(
+          focusedComponent
+              ? focusedComponent->tag()
+              : static_cast<facebook::react::Tag>(
+                    winrt::get_self<winrt::Microsoft::ReactNative::implementation::CompositionRootView>(m_compRootView)
+                        ->GetTag()),
+          msg,
+          wParam,
+          lParam);
+      auto keyboardSource = winrt::make<CompositionKeyboardSource>(this);
+      if (msg == WM_KEYDOWN || msg == WM_SYSKEYDOWN) {
+        onKeyDown(keyboardSource, args);
+      } else {
+        onKeyUp(keyboardSource, args);
       }
-
-      BYTE bKeys[256];
-      if (GetKeyboardState(bKeys)) {
-        bool fShift = false;
-        if (bKeys[VK_LSHIFT] & 0x80)
-          fShift = true;
-        if (bKeys[VK_RSHIFT] & 0x80)
-          fShift = true;
-        bool fCtrl = false;
-        if (bKeys[VK_LCONTROL] & 0x80)
-          fCtrl = true;
-        if (bKeys[VK_RCONTROL] & 0x80)
-          fCtrl = true;
-        if (msg == WM_KEYDOWN && wParam == VkKeyScanA('d') && fShift && fCtrl) {
-          auto contextSelf = winrt::get_self<React::implementation::ReactContext>(m_context.Handle());
-          Microsoft::ReactNative::DevMenuManager::Show(
-              Mso::CntPtr<Mso::React::IReactContext>(&contextSelf->GetInner()));
-        }
-        if (!fCtrl && msg == WM_KEYDOWN && wParam == VK_TAB) {
-          if (!RootComponentView().TryMoveFocus(!fShift)) {
-            // TODO notify rootview that host should move focus
-          }
-          return 1;
-        }
-      }
-      return 0;
+      winrt::get_self<CompositionKeyboardSource>(keyboardSource)->Disconnect();
     }
   }
 
   return 0;
 }
 
+void CompositionEventHandler::onKeyDown(
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
+  if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
+    focusedComponent->onKeyDown(source, args);
+
+    if (args.Handled())
+      return;
+  }
+
+  bool fShift = source.GetKeyState(winrt::Windows::System::VirtualKey::Shift) ==
+      winrt::Windows::UI::Core::CoreVirtualKeyStates::Down;
+  bool fCtrl =
+      GetKeyState(winrt::Windows::System::VirtualKey::Control) == winrt::Windows::UI::Core::CoreVirtualKeyStates::Down;
+
+  if (fShift && fCtrl && args.Key() == static_cast<winrt::Windows::System::VirtualKey>(VkKeyScanA('d')) &&
+      Mso::React::ReactOptions::UseDeveloperSupport(m_context.Properties().Handle())) {
+    auto contextSelf = winrt::get_self<React::implementation::ReactContext>(m_context.Handle());
+    Microsoft::ReactNative::DevMenuManager::Show(Mso::CntPtr<Mso::React::IReactContext>(&contextSelf->GetInner()));
+    args.Handled(true);
+    return;
+  }
+
+  if (!fCtrl && args.Key() == winrt::Windows::System::VirtualKey::Tab) {
+    if (RootComponentView().TryMoveFocus(!fShift)) {
+      args.Handled(true);
+    }
+
+    // TODO notify rootview that host should move focus
+  }
+}
+
+void CompositionEventHandler::onKeyUp(
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+    const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept {
+  if (auto focusedComponent = RootComponentView().GetFocusedComponent()) {
+    focusedComponent->onKeyUp(source, args);
+
+    if (args.Handled())
+      return;
+  }
+}
+
 std::vector<IComponentView *> GetTouchableViewsInPathToRoot(IComponentView *view) {
   std::vector<IComponentView *> results;
   while (view) {
-    if (view->touchEventEmitter()) {
+    if (view->eventEmitter()) {
       results.push_back(view);
     }
     view = view->parent();
@@ -220,15 +448,17 @@ std::vector<IComponentView *> GetTouchableViewsInPathToRoot(IComponentView *view
 
 /**
  * Private method which is used for tracking the location of pointer events to manage the entering/leaving events.
- * The primary idea is that a pointer's presence & movement is dicated by a variety of underlying events such as down,
+ * The primary idea is that a pointer's presence & movement is dictated by a variety of underlying events such as down,
  * move, and up — and they should all be treated the same when it comes to tracking the entering & leaving of pointers
- * to views. This method accomplishes that by recieving the pointer event, the target view (can be null in cases when
+ * to views. This method accomplishes that by receiving the pointer event, the target view (can be null in cases when
  * the event indicates that the pointer has left the screen entirely), and a block/callback where the underlying event
  * should be fired.
  */
 void CompositionEventHandler::HandleIncomingPointerEvent(
     facebook::react::PointerEvent &event,
     IComponentView *targetView,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers,
     std::function<void(std::vector<IComponentView *> &)> handler) {
   int pointerId = event.pointerId;
   // CGPoint clientLocation = CGPointMake(event.clientPoint.x, event.clientPoint.y);
@@ -253,7 +483,7 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
   if (targetView != nullptr && previousTargetTag != targetView->tag()) {
     bool shouldEmitOverEvent =
         IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerOver);
-    facebook::react::SharedTouchEventEmitter eventEmitter = targetView->touchEventEmitterAtPoint(event.offsetPoint);
+    const auto eventEmitter = targetView->eventEmitterAtPoint(event.offsetPoint);
     if (shouldEmitOverEvent && eventEmitter != nullptr) {
       eventEmitter->onPointerOver(event);
     }
@@ -264,9 +494,10 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
   // We only want to emit events to JS if there is a view that is currently listening to said event
   // so we only send those event to the JS side if the element which has been entered is itself listening,
   // or if one of its parents is listening in case those listeners care about the capturing phase. Adding the ability
-  // for native to distingusih between capturing listeners and not could be an optimization to futher reduce the
+  // for native to distinguish between capturing listeners and not could be an optimization to further reduce the
   // number of events we send to JS
   bool hasParentEnterListener = false;
+  bool emittedNativeEnteredEvent = false;
 
   for (auto itComponentView = eventPathViews.rbegin(); itComponentView != eventPathViews.rend();
        itComponentView++) { //  for (RCTReactTaggedView *taggedView in [eventPathViews reverseObjectEnumerator]) {
@@ -275,18 +506,27 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
     bool shouldEmitEvent = componentView != nullptr &&
         (hasParentEnterListener ||
          IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::PointerEnter) ||
-         IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::MouseEnter));
+         IsViewListeningToEvent(componentView, facebook::react::WindowsViewEvents::Offset::MouseEnter));
 
-    if (shouldEmitEvent &&
+    if ((shouldEmitEvent || !emittedNativeEnteredEvent) &&
         std::find(currentlyHoveredViews.begin(), currentlyHoveredViews.end(), componentView) ==
             currentlyHoveredViews.end()) {
-      facebook::react::SharedTouchEventEmitter eventEmitter = componentView->touchEventEmitter();
-      if (eventEmitter) {
-        eventEmitter->onPointerEnter(event);
-        if (IsMousePointerEvent(event)) {
-          eventEmitter->onMouseEnter(event);
+      if (shouldEmitEvent) {
+        const auto eventEmitter = componentView->eventEmitter();
+        if (eventEmitter) {
+          eventEmitter->onPointerEnter(event);
+          if (IsMousePointerEvent(event)) {
+            eventEmitter->onMouseEnter(event);
+          }
         }
       }
+      if (!emittedNativeEnteredEvent) {
+        emittedNativeEnteredEvent = true;
+        auto args =
+            winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+                componentView->tag(), pointerPoint, keyModifiers);
+        static_cast<CompositionBaseComponentView *>(componentView)->onPointerEntered(args);
+      }
     }
 
     if (shouldEmitEvent && !hasParentEnterListener) {
@@ -301,7 +541,7 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
   if (previousTargetTag != -1 && previousTargetTag != (targetView ? targetView->tag() : -1)) {
     bool shouldEmitOutEvent =
         IsAnyViewInPathListeningToEvent(currentlyHoveredViews, facebook::react::ViewEvents::Offset::PointerOut);
-    facebook::react::SharedTouchEventEmitter eventEmitter = prevTargetView->touchEventEmitter();
+    const auto eventEmitter = prevTargetView->eventEmitter();
     if (shouldEmitOutEvent && eventEmitter != nullptr) {
       eventEmitter->onPointerOut(event);
     }
@@ -309,13 +549,15 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
 
   // Leaving
 
-  // pointerleave events need to be emited from the deepest target to the root but
+  // pointerleave events need to be emitted from the deepest target to the root but
   // we also need to efficiently keep track of if a view has a parent which is listening to the leave events,
   // so we first iterate from the root to the target, collecting the views which need events fired for, of which
   // we reverse iterate (now from target to root), actually emitting the events.
   std::vector<IComponentView *> viewsToEmitLeaveEventsTo; // NSMutableOrderedSet<UIView *> *viewsToEmitLeaveEventsTo =
                                                           // [NSMutableOrderedSet orderedSet];
 
+  IComponentView *viewToEmitNativeExitedEvent = nullptr;
+
   bool hasParentLeaveListener = false;
   for (auto itComponentView = currentlyHoveredViews.rbegin(); itComponentView != currentlyHoveredViews.rend();
        itComponentView++) { //  for (RCTReactTaggedView *taggedView in [currentlyHoveredViews
@@ -326,11 +568,16 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
     bool shouldEmitEvent = componentView != nullptr &&
         (hasParentLeaveListener ||
          IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::PointerLeave) ||
-         IsViewListeningToEvent(componentView, facebook::react::ViewEvents::Offset::MouseLeave));
+         IsViewListeningToEvent(componentView, facebook::react::WindowsViewEvents::Offset::MouseLeave));
 
-    if (shouldEmitEvent &&
+    if ((shouldEmitEvent || !viewToEmitNativeExitedEvent) &&
         std::find(eventPathViews.begin(), eventPathViews.end(), componentView) == eventPathViews.end()) {
-      viewsToEmitLeaveEventsTo.push_back(componentView);
+      if (shouldEmitEvent) {
+        viewsToEmitLeaveEventsTo.push_back(componentView);
+      }
+      if (!viewToEmitNativeExitedEvent) {
+        viewToEmitNativeExitedEvent = componentView;
+      }
     }
 
     if (shouldEmitEvent && !hasParentLeaveListener) {
@@ -338,11 +585,17 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
     }
   }
 
+  if (viewToEmitNativeExitedEvent) {
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        viewToEmitNativeExitedEvent->tag(), pointerPoint, keyModifiers);
+    static_cast<CompositionBaseComponentView *>(viewToEmitNativeExitedEvent)->onPointerExited(args);
+  }
+
   for (auto itComponentView = viewsToEmitLeaveEventsTo.rbegin(); itComponentView != viewsToEmitLeaveEventsTo.rend();
        itComponentView++) { //  for (UIView *componentView in [viewsToEmitLeaveEventsTo reverseObjectEnumerator]) {
     auto componentView = *itComponentView;
 
-    facebook::react::SharedTouchEventEmitter eventEmitter = componentView->touchEventEmitter();
+    const auto eventEmitter = componentView->eventEmitter();
     if (eventEmitter) {
       eventEmitter->onPointerLeave(event);
       if (IsMousePointerEvent(event)) {
@@ -416,31 +669,40 @@ facebook::react::PointerEvent CreatePointerEventFromIncompleteHoverData(
   return pointerEvent;
 }
 
-void CompositionEventHandler::MouseMove(uint32_t msg, uint64_t wParam, int64_t lParam) {
-  int pointerId = MOUSE_POINTER_ID; // TODO pointerId
+void CompositionEventHandler::onPointerMoved(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  if (SurfaceId() == -1)
+    return;
+
+  int pointerId = pointerPoint.PointerId();
 
-  auto x = GET_X_LPARAM(lParam);
-  auto y = GET_Y_LPARAM(lParam);
+  auto position = pointerPoint.Position();
 
   if (std::shared_ptr<FabricUIManager> fabricuiManager =
           ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
     facebook::react::Point ptLocal;
 
-    facebook::react::Point ptScaled = {
-        static_cast<float>(x / m_compRootView.ScaleFactor()), static_cast<float>(y / m_compRootView.ScaleFactor())};
+    facebook::react::Point ptScaled = {position.X, position.Y};
     auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
 
     if (tag == -1)
       return;
 
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        tag, pointerPoint, keyModifiers);
+    IComponentView *targetComponentView =
+        fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view.get();
+
+    static_cast<CompositionBaseComponentView *>(targetComponentView)->onPointerMoved(args);
+
     auto targetView = FindClosestFabricManagedTouchableView(
         fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view.get());
 
     facebook::react::PointerEvent pointerEvent = CreatePointerEventFromIncompleteHoverData(ptScaled, ptLocal);
 
     auto handler = [targetView, &pointerEvent](std::vector<IComponentView *> &eventPathViews) {
-      facebook::react::SharedTouchEventEmitter eventEmitter =
-          targetView ? targetView->touchEventEmitterAtPoint(pointerEvent.offsetPoint) : nullptr;
+      const auto eventEmitter = targetView ? targetView->eventEmitterAtPoint(pointerEvent.offsetPoint) : nullptr;
       bool hasMoveEventListeners =
           IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMove) ||
           IsAnyViewInPathListeningToEvent(eventPathViews, facebook::react::ViewEvents::Offset::PointerMoveCapture);
@@ -449,91 +711,14 @@ void CompositionEventHandler::MouseMove(uint32_t msg, uint64_t wParam, int64_t l
       }
     };
 
-    HandleIncomingPointerEvent(pointerEvent, targetView, handler);
+    HandleIncomingPointerEvent(pointerEvent, targetView, pointerPoint, keyModifiers, handler);
   }
 }
 
-void CompositionEventHandler::PointerPressed(uint32_t msg, uint64_t wParam, int64_t lParam) {
-  POINTER_INFO pi;
-  PointerId pointerId = GET_POINTERID_WPARAM(wParam);
-  GetPointerInfo(pointerId, &pi);
-  POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
-  ::ScreenToClient(pi.hwndTarget, &pt);
-
-  auto staleTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
-    return pair.second.touch.identifier == pointerId;
-  });
-
-  if (staleTouch != m_activeTouches.end()) {
-    // A pointer with this ID already exists - Should we fire a button cancel or something?
-    assert(false);
-    return;
-  }
-
-  const auto eventType = TouchEventType::Start;
-
-  if (std::shared_ptr<FabricUIManager> fabricuiManager =
-          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
-    facebook::react::Point ptLocal;
-
-    facebook::react::Point ptScaled = {
-        static_cast<float>(pt.x / m_compRootView.ScaleFactor()),
-        static_cast<float>(pt.y / m_compRootView.ScaleFactor())};
-    auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
-
-    if (tag == -1)
-      return;
-
-    IComponentView *targetComponentView =
-        fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view.get();
-    static_cast<CompositionBaseComponentView *>(targetComponentView)->sendMessage(msg, wParam, lParam);
-
-    ActiveTouch activeTouch{0};
-    switch (pi.pointerType) {
-      case PT_POINTER:
-      case PT_TOUCH:
-        activeTouch.touchType = UITouchType::Touch;
-        break;
-      case PT_PEN:
-        activeTouch.touchType = UITouchType::Pen;
-        break;
-      case PT_TOUCHPAD:
-      case PT_MOUSE:
-        activeTouch.touchType = UITouchType::Mouse;
-        break;
-    }
-
-    auto componentView = targetComponentView;
-    while (componentView) {
-      if (auto eventEmitter = componentView->touchEventEmitter()) {
-        activeTouch.eventEmitter = eventEmitter;
-        activeTouch.touch.target = componentView->tag();
-        // activeTouch.componentView = componentView;
-        break;
-      }
-      componentView = componentView->parent();
-    }
-
-    UpdateActiveTouch(activeTouch, ptScaled, ptLocal);
-
-    // activeTouch.touch.isPrimary = true;
-    activeTouch.touch.identifier = pointerId;
-
-    // If the pointer has not been marked as hovering over views before the touch started, we register
-    // that the activeTouch should not maintain its hovered state once the pointer has been lifted.
-    auto currentlyHoveredTags = m_currentlyHoveredViewsPerPointer.find(activeTouch.touch.identifier);
-    if (currentlyHoveredTags == m_currentlyHoveredViewsPerPointer.end() || currentlyHoveredTags->second.empty()) {
-      activeTouch.shouldLeaveWhenReleased = true;
-    }
-
-    m_activeTouches.emplace(pointerId, activeTouch);
-
-    DispatchTouchEvent(eventType, pointerId);
-  }
-}
-
-void CompositionEventHandler::ButtonDown(uint32_t msg, uint64_t wParam, int64_t lParam) {
-  PointerId pointerId = MOUSE_POINTER_ID;
+void CompositionEventHandler::onPointerPressed(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  PointerId pointerId = pointerPoint.PointerId();
 
   auto staleTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
     return pair.second.touch.identifier == pointerId;
@@ -545,16 +730,14 @@ void CompositionEventHandler::ButtonDown(uint32_t msg, uint64_t wParam, int64_t
     return;
   }
 
-  auto x = GET_X_LPARAM(lParam);
-  auto y = GET_Y_LPARAM(lParam);
+  auto position = pointerPoint.Position();
   const auto eventType = TouchEventType::Start;
 
   if (std::shared_ptr<FabricUIManager> fabricuiManager =
           ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
     facebook::react::Point ptLocal;
 
-    facebook::react::Point ptScaled = {
-        static_cast<float>(x / m_compRootView.ScaleFactor()), static_cast<float>(y / m_compRootView.ScaleFactor())};
+    facebook::react::Point ptScaled = {position.X, position.Y};
     auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
 
     if (tag == -1)
@@ -562,14 +745,16 @@ void CompositionEventHandler::ButtonDown(uint32_t msg, uint64_t wParam, int64_t
 
     IComponentView *targetComponentView =
         fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view.get();
-    static_cast<CompositionBaseComponentView *>(targetComponentView)->sendMessage(msg, wParam, lParam);
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        tag, pointerPoint, keyModifiers);
+    static_cast<CompositionBaseComponentView *>(targetComponentView)->onPointerPressed(args);
 
     ActiveTouch activeTouch{0};
     activeTouch.touchType = UITouchType::Mouse;
 
     auto componentView = targetComponentView;
     while (componentView) {
-      if (auto eventEmitter = componentView->touchEventEmitterAtPoint(ptLocal)) {
+      if (auto eventEmitter = componentView->eventEmitterAtPoint(ptLocal)) {
         activeTouch.eventEmitter = eventEmitter;
         activeTouch.touch.target = componentView->tag();
         // activeTouch.componentView = componentView;
@@ -592,16 +777,14 @@ void CompositionEventHandler::ButtonDown(uint32_t msg, uint64_t wParam, int64_t
 
     m_activeTouches.emplace(pointerId, activeTouch);
 
-    DispatchTouchEvent(eventType, pointerId);
+    DispatchTouchEvent(eventType, pointerId, pointerPoint, keyModifiers);
   }
 }
 
-void CompositionEventHandler::PointerUp(uint32_t msg, uint64_t wParam, int64_t lParam) {
-  POINTER_INFO pi;
-  PointerId pointerId = GET_POINTERID_WPARAM(wParam);
-  GetPointerInfo(pointerId, &pi);
-  POINT pt = {GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam)};
-  ::ScreenToClient(pi.hwndTarget, &pt);
+void CompositionEventHandler::onPointerReleased(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  int pointerId = pointerPoint.PointerId();
 
   auto activeTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
     return pair.second.touch.identifier == pointerId;
@@ -611,59 +794,26 @@ void CompositionEventHandler::PointerUp(uint32_t msg, uint64_t wParam, int64_t l
     return;
   }
 
-  const auto eventType = TouchEventType::Start;
+  auto position = pointerPoint.Position();
 
   if (std::shared_ptr<FabricUIManager> fabricuiManager =
           ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
     facebook::react::Point ptLocal;
 
-    facebook::react::Point ptScaled = {
-        static_cast<float>(pt.x / m_compRootView.ScaleFactor()),
-        static_cast<float>(pt.y / m_compRootView.ScaleFactor())};
+    facebook::react::Point ptScaled = {position.X, position.Y};
     auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
 
     if (tag == -1)
       return;
 
     auto targetComponentView = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view;
-    std::static_pointer_cast<CompositionBaseComponentView>(targetComponentView)->sendMessage(msg, wParam, lParam);
-
-    UpdateActiveTouch(activeTouch->second, ptScaled, ptLocal);
-    DispatchTouchEvent(TouchEventType::End, pointerId);
-    m_activeTouches.erase(pointerId);
-  }
-}
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        tag, pointerPoint, keyModifiers);
 
-void CompositionEventHandler::ButtonUp(uint32_t msg, uint64_t wParam, int64_t lParam) {
-  int pointerId = MOUSE_POINTER_ID;
-
-  auto activeTouch = std::find_if(m_activeTouches.begin(), m_activeTouches.end(), [pointerId](const auto &pair) {
-    return pair.second.touch.identifier == pointerId;
-  });
-
-  if (activeTouch == m_activeTouches.end()) {
-    return;
-  }
-
-  auto x = GET_X_LPARAM(lParam);
-  auto y = GET_Y_LPARAM(lParam);
-
-  if (std::shared_ptr<FabricUIManager> fabricuiManager =
-          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
-    facebook::react::Point ptLocal;
-
-    facebook::react::Point ptScaled = {
-        static_cast<float>(x / m_compRootView.ScaleFactor()), static_cast<float>(y / m_compRootView.ScaleFactor())};
-    auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
-
-    if (tag == -1)
-      return;
-
-    auto targetComponentView = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(tag).view;
-    std::static_pointer_cast<CompositionBaseComponentView>(targetComponentView)->sendMessage(msg, wParam, lParam);
+    std::static_pointer_cast<CompositionBaseComponentView>(targetComponentView)->onPointerReleased(args);
 
     UpdateActiveTouch(activeTouch->second, ptScaled, ptLocal);
-    DispatchTouchEvent(TouchEventType::End, pointerId);
+    DispatchTouchEvent(TouchEventType::End, pointerId, pointerPoint, keyModifiers);
     m_activeTouches.erase(pointerId);
   }
 }
@@ -744,7 +894,11 @@ facebook::react::PointerEvent CompositionEventHandler::CreatePointerEventFromAct
 }
 
 // If we have events that include multiple pointer updates, we should change arg from pointerId to vector<pointerId>
-void CompositionEventHandler::DispatchTouchEvent(TouchEventType eventType, PointerId pointerId) {
+void CompositionEventHandler::DispatchTouchEvent(
+    TouchEventType eventType,
+    PointerId pointerId,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) {
   auto fabricuiManager = ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties());
 
   if (!fabricuiManager)
@@ -805,7 +959,7 @@ void CompositionEventHandler::DispatchTouchEvent(TouchEventType eventType, Point
       }
     };
 
-    HandleIncomingPointerEvent(pointerEvent, targetView, handler);
+    HandleIncomingPointerEvent(pointerEvent, targetView, pointerPoint, keyModifiers, handler);
   }
 
   for (const auto &pair : m_activeTouches) {