react-native-windows 0.73.11 → 0.74.0-preview.1

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

@@ -23,7 +23,8 @@ using namespace Windows::Foundation;
 
 namespace Microsoft::ReactNative {
 
-struct IComponentView;
+struct FabricUIManager;
+struct winrt::Microsoft::ReactNative::implementation::ComponentView;
 typedef int PointerId;
 
 class CompositionEventHandler {
@@ -33,10 +34,18 @@ class CompositionEventHandler {
       const winrt::Microsoft::ReactNative::CompositionRootView &CompositionRootView);
   virtual ~CompositionEventHandler();
 
-  int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
+  int64_t SendMessage(HWND hwnd, uint32_t msg, uint64_t wParam, int64_t lParam) noexcept;
   void RemoveTouchHandlers();
   winrt::Windows::UI::Core::CoreVirtualKeyStates GetKeyState(winrt::Windows::System::VirtualKey key) noexcept;
 
+  bool CapturePointer(
+      const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+      facebook::react::Tag tag) noexcept;
+  bool ReleasePointerCapture(
+      const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
+      facebook::react::Tag tag) noexcept;
+  facebook::react::Tag PointerCapturingComponent() noexcept;
+
  private:
   void onPointerPressed(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
@@ -50,15 +59,29 @@ class CompositionEventHandler {
   void onPointerWheelChanged(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerCaptureLost(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
   void onKeyDown(
       const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
       const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
   void onKeyUp(
       const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
       const winrt::Microsoft::ReactNative::Composition::Input::KeyRoutedEventArgs &args) noexcept;
+  void onCharacterReceived(
+      const winrt::Microsoft::ReactNative::Composition::Input::KeyboardSource &source,
+      const winrt::Microsoft::ReactNative::Composition::Input::CharacterReceivedRoutedEventArgs &args) noexcept;
 
-  facebook::react::SurfaceId SurfaceId() noexcept;
-  RootComponentView &RootComponentView() noexcept;
+  void getTargetPointerArgs(
+      const std::shared_ptr<FabricUIManager> &fabricuiManager,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      facebook::react::Tag &tag,
+      facebook::react::Point &ptScaled,
+      facebook::react::Point &ptLocal) const noexcept;
+  bool releasePointerCapture(PointerId pointerId, facebook::react::Tag tag) noexcept;
+
+  facebook::react::SurfaceId SurfaceId() const noexcept;
+  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView &RootComponentView() const noexcept;
 
   enum class UITouchType {
     Mouse,
@@ -73,10 +96,10 @@ class CompositionEventHandler {
       winrt::Windows::System::VirtualKeyModifiers keyModifiers);
   void HandleIncomingPointerEvent(
       facebook::react::PointerEvent &pe,
-      IComponentView *targetView,
+      const winrt::Microsoft::ReactNative::ComponentView &targetView,
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers,
-      std::function<void(std::vector<IComponentView *> &)> handler);
+      std::function<void(std::vector<winrt::Microsoft::ReactNative::ComponentView> &)> handler);
 
   struct ActiveTouch {
     facebook::react::Touch touch;
@@ -134,13 +157,18 @@ class CompositionEventHandler {
   winrt::Microsoft::ReactNative::CompositionRootView m_compRootView{nullptr};
   winrt::Microsoft::ReactNative::ReactContext m_context;
 
+  facebook::react::Tag m_pointerCapturingComponentTag{-1}; // Component that has captured input
+  std::vector<PointerId> m_capturedPointers;
+
 #ifdef USE_WINUI3
   winrt::event_token m_pointerPressedToken;
   winrt::event_token m_pointerReleasedToken;
   winrt::event_token m_pointerMovedToken;
   winrt::event_token m_pointerWheelChangedToken;
+  winrt::event_token m_pointerCaptureLostToken;
   winrt::event_token m_keyDownToken;
   winrt::event_token m_keyUpToken;
+  winrt::event_token m_characterReceivedToken;
 #endif
 };
 

package/Microsoft.ReactNative/Fabric/Composition/CompositionHelpers.h

@@ -4,7 +4,8 @@
 
 #pragma once
 
-#include <Composition/CompositionSwitcher.interop.h>
+#include <CompositionSwitcher.interop.h>
+#include <guid/msoGuid.h>
 #include <winrt/Windows.UI.Composition.h>
 
 namespace Microsoft::ReactNative {

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

@@ -17,53 +17,72 @@
 #include "CompositionRootAutomationProvider.h"
 #include "CompositionRootView.h"
 
+#if USE_WINUI3
+#include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.interop.h>
+#endif
+
 WINUSERAPI UINT WINAPI GetDpiForWindow(_In_ HWND hwnd);
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
-winrt::Windows::UI::Composition::Visual CompositionHwndHost::RootVisual() const noexcept {
-  return m_target.Root();
-}
-
-winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget CompositionHwndHost::Target() const noexcept {
-  assert(m_target);
-  return m_target;
-}
+CompositionHwndHost::CompositionHwndHost() noexcept {}
 
-void CompositionHwndHost::CreateDesktopWindowTarget(HWND window) {
-  namespace abi = ABI::Windows::UI::Composition::Desktop;
+void CompositionHwndHost::Initialize(uint64_t hwnd) noexcept {
+  m_hwnd = (HWND)hwnd;
 
-  auto interop = Compositor().as<abi::ICompositorDesktopInterop>();
-  winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget target{nullptr};
-  check_hresult(interop->CreateDesktopWindowTarget(
-      window, false, reinterpret_cast<abi::IDesktopWindowTarget **>(put_abi(target))));
-  m_target = target;
-}
+  auto compositionContext =
+      winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
+          ReactViewHost().ReactNativeHost().InstanceSettings().Properties());
+#if USE_WINUI3
+  if (auto liftedCompositor = winrt::Microsoft::ReactNative::Composition::implementation::
+          MicrosoftCompositionContextHelper::InnerCompositor(compositionContext)) {
+    m_compRootView = winrt::Microsoft::ReactNative::CompositionRootView(liftedCompositor);
+    m_compRootView.SetWindow(reinterpret_cast<uint64_t>(m_hwnd));
 
-void CompositionHwndHost::CreateCompositionRoot() {
-  auto root = Compositor().CreateContainerVisual();
-  root.RelativeSizeAdjustment({1.0f, 1.0f});
-  root.Offset({0, 0, 0});
-  m_target.Root(root);
-}
+    auto bridge = winrt::Microsoft::UI::Content::DesktopChildSiteBridge::Create(
+        liftedCompositor, winrt::Microsoft::UI::GetWindowIdFromWindow(m_hwnd));
 
-CompositionHwndHost::CompositionHwndHost() noexcept {}
+    auto island = m_compRootView.Island();
 
-void CompositionHwndHost::Initialize(uint64_t hwnd) noexcept {
-  m_hwnd = (HWND)hwnd;
+    auto invScale = 1.0f / ScaleFactor();
+    m_compRootView.RootVisual().Scale({invScale, invScale, invScale});
 
-  m_compRootView = winrt::Microsoft::ReactNative::CompositionRootView();
+    bridge.Connect(island);
+    bridge.Show();
 
-  CreateDesktopWindowTarget(m_hwnd);
-  CreateCompositionRoot();
+    m_compRootView.ScaleFactor(ScaleFactor());
+    bridge.ResizePolicy(winrt::Microsoft::UI::Content::ContentSizePolicy::ResizeContentToParentWindow);
+  } else {
+    m_compRootView = winrt::Microsoft::ReactNative::CompositionRootView();
+    m_compRootView.SetWindow(reinterpret_cast<uint64_t>(m_hwnd));
+
+#endif
+    auto compositor =
+        winrt::Microsoft::ReactNative::Composition::implementation::SystemCompositionContextHelper::InnerCompositor(
+            compositionContext);
+    auto interop = compositor.as<ABI::Windows::UI::Composition::Desktop::ICompositorDesktopInterop>();
+    winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget target{nullptr};
+    check_hresult(interop->CreateDesktopWindowTarget(
+        m_hwnd,
+        false,
+        reinterpret_cast<ABI::Windows::UI::Composition::Desktop::IDesktopWindowTarget **>(put_abi(target))));
+
+    auto root = compositor.CreateContainerVisual();
+    root.RelativeSizeAdjustment({1.0f, 1.0f});
+    root.Offset({0, 0, 0});
+    root.Comment(L"Root Visual");
+    target.Root(root);
+
+    m_compRootView.RootVisual(
+        winrt::Microsoft::ReactNative::Composition::SystemCompositionContextHelper::CreateVisual(target.Root()));
+
+#if USE_WINUI3
+  }
+#endif
 
   m_compRootView.ReactViewHost(std::move(m_reactViewHost));
-
   m_compRootView.ScaleFactor(ScaleFactor());
-  m_compRootView.RootVisual(
-      winrt::Microsoft::ReactNative::Composition::implementation::WindowsCompositionContextHelper::CreateVisual(
-          RootVisual()));
-
   UpdateSize();
 }
 
@@ -79,9 +98,11 @@ void CompositionHwndHost::UpdateSize() noexcept {
       m_width = rc.right - rc.left;
       winrt::Windows::Foundation::Size size{
           static_cast<float>(m_width / ScaleFactor()), static_cast<float>(m_height / ScaleFactor())};
-      m_compRootView.Size(size);
-      m_compRootView.Measure(size);
-      m_compRootView.Arrange(size);
+      // Do not relayout when minimized
+      if (!IsIconic(m_hwnd)) {
+        m_compRootView.Size(size);
+        m_compRootView.Arrange(size);
+      }
     }
   }
 }
@@ -93,20 +114,15 @@ LRESULT CompositionHwndHost::TranslateMessage(int msg, uint64_t wParam, int64_t
   switch (msg) {
     case WM_WINDOWPOSCHANGED: {
       UpdateSize();
-      /*
-      winrt::Windows::Foundation::Size size{
-          static_cast<float>(reinterpret_cast<const WINDOWPOS *>(lParam)->cx),
-          static_cast<float>(reinterpret_cast<const WINDOWPOS *>(lParam)->cy)};
-      m_compRootView.Size(size);
-      m_compRootView.Measure(size);
-      m_compRootView.Arrange(size);
-      */
       return 0;
     }
   }
 
   if (m_compRootView) {
-    return static_cast<LRESULT>(m_compRootView.SendMessage(msg, wParam, lParam));
+#if USE_WINUI3
+    if (!m_compRootView.Island()) // When using Island hosting we dont need to forward window messages
+#endif
+      return static_cast<LRESULT>(m_compRootView.SendMessage(msg, wParam, lParam));
   }
   return 0;
 }
@@ -128,15 +144,6 @@ void CompositionHwndHost::ReactViewHost(ReactNative::IReactViewHost const &value
   }
 }
 
-winrt::Windows::UI::Composition::Compositor CompositionHwndHost::Compositor() const noexcept {
-  auto compositionContext =
-      winrt::Microsoft::ReactNative::Composition::implementation::CompositionUIService::GetCompositionContext(
-          m_reactViewHost.ReactNativeHost().InstanceSettings().Properties());
-
-  return winrt::Microsoft::ReactNative::Composition::implementation::WindowsCompositionContextHelper::InnerCompositor(
-      compositionContext);
-}
-
 IInspectable CompositionHwndHost::UiaProvider() noexcept {
   auto compRootView = winrt::get_self<implementation::CompositionRootView>(m_compRootView);
   auto provider = compRootView->GetUiaProvider();

package/Microsoft.ReactNative/Fabric/Composition/CompositionHwndHost.h

@@ -23,26 +23,17 @@ struct CompositionHwndHost : CompositionHwndHostT<CompositionHwndHost> {
   // property UiaProvider
   IInspectable UiaProvider() noexcept;
 
-  winrt::Windows::UI::Composition::Visual RootVisual() const noexcept;
-
   winrt::Microsoft::ReactNative::FocusNavigationResult NavigateFocus(
       const winrt::Microsoft::ReactNative::FocusNavigationRequest &request) noexcept;
 
   LRESULT TranslateMessage(int msg, uint64_t wParam, int64_t lParam) noexcept;
 
  private:
-  // Possibly should be public..
-  winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget Target() const noexcept;
-  winrt::Windows::UI::Composition::Compositor Compositor() const noexcept;
-
-  void CreateDesktopWindowTarget(HWND window);
-  void CreateCompositionRoot();
   void UpdateSize() noexcept;
   float ScaleFactor() noexcept;
 
   HWND m_hwnd;
   winrt::Microsoft::ReactNative::CompositionRootView m_compRootView{nullptr};
-  winrt::Windows::UI::Composition::Desktop::DesktopWindowTarget m_target{nullptr};
   LONG m_height{0};
   LONG m_width{0};
 

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

@@ -5,13 +5,16 @@
 
 #ifdef USE_WINUI3
 #include <winrt/Microsoft.UI.Content.h>
+#include <winrt/Microsoft.UI.Input.h>
 #endif
 
+#include <Fabric/Composition/CompositionRootView.h>
+
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionRootAutomationProvider::CompositionRootAutomationProvider(
-    const std::shared_ptr<::Microsoft::ReactNative::RootComponentView> &componentView) noexcept
-    : m_view{componentView} {}
+    const winrt::Microsoft::ReactNative::CompositionRootView &rootView) noexcept
+    : m_wkRootView{rootView} {}
 
 // Implementations should return NULL for a top-level element that is hosted in a window. Other elements should return
 // an array that contains UiaAppendRuntimeId (defined in Uiautomationcoreapi.h), followed by a value that is unique
@@ -37,7 +40,24 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetEmbeddedFragmentRoots(SA
 }
 
 HRESULT __stdcall CompositionRootAutomationProvider::SetFocus(void) {
-  return UiaSetFocusHelper(m_view);
+#ifdef USE_WINUI3
+  if (m_island) {
+    auto focusController = winrt::Microsoft::UI::Input::InputFocusController::GetForIsland(m_island);
+
+    if (focusController) {
+      if (focusController.TrySetFocus()) {
+        return S_OK;
+      }
+    }
+  }
+#endif
+
+  if (m_hwnd) {
+    ::SetFocus(m_hwnd);
+    return S_OK;
+  }
+
+  return S_FALSE;
 }
 
 HRESULT __stdcall CompositionRootAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
@@ -53,6 +73,14 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetPropertyValue(PROPERTYID
   if (pRetVal == nullptr)
     return E_POINTER;
 
+  switch (propertyId) {
+    case UIA_ControlTypePropertyId: {
+      pRetVal->vt = VT_I4;
+      pRetVal->lVal = UIA_GroupControlTypeId;
+      break;
+    }
+  }
+
   return S_OK;
 }
 
@@ -69,8 +97,10 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_HostRawElementProvider(
 #endif
 
   // TODO: assumes windowed
-  if (!IsWindow(m_hwnd))
+  if (!IsWindow(m_hwnd)) {
+    assert(false);
     return UIA_E_ELEMENTNOTAVAILABLE;
+  }
 
   auto hr = UiaHostProviderFromHwnd(m_hwnd, pRetVal);
 
@@ -99,7 +129,9 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_BoundingRectangle(UiaRe
   // TODO: Need host site offsets
   // Assume we're hosted in some other visual-based hosting site
   if (m_hwnd == nullptr || !IsWindow(m_hwnd)) {
-    return UiaGetBoundingRectangleHelper(m_view, *pRetVal);
+    assert(false);
+    pRetVal->left = pRetVal->top = pRetVal->width = pRetVal->height = 0;
+    return E_FAIL;
   }
 
   POINT point{0, 0};
@@ -135,6 +167,18 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_ProviderOptions(Provide
   return S_OK;
 }
 
+winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *
+CompositionRootAutomationProvider::rootComponentView() noexcept {
+  if (auto rootView = m_wkRootView.get()) {
+    auto innerRootView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::CompositionRootView>(rootView);
+    if (auto view = innerRootView->GetComponentView()) {
+      return view;
+    }
+  }
+
+  return nullptr;
+}
+
 HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
     double x,
     double y,
@@ -144,28 +188,45 @@ HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
 
   *pRetVal = nullptr;
 
-  auto strongView = m_view.view();
-
-  if (strongView == nullptr) {
-    return UIA_E_ELEMENTNOTAVAILABLE;
-  }
-
-  auto spRootView = std::static_pointer_cast<::Microsoft::ReactNative::RootComponentView>(strongView);
-
-  if (m_hwnd == nullptr || !IsWindow(m_hwnd)) {
-    // TODO: Add support for non-HWND based hosting
-    return E_FAIL;
-  }
-
-  POINT clientPoint{static_cast<LONG>(x), static_cast<LONG>(y)};
-  ScreenToClient(m_hwnd, &clientPoint);
+  if (auto rootView = rootComponentView()) {
+#ifdef USE_WINUI3
+    if (m_island) {
+      auto cc = m_island.CoordinateConverter();
+      auto local = cc.ConvertScreenToLocal(
+          winrt::Windows::Graphics::PointInt32{static_cast<int32_t>(x), static_cast<int32_t>(y)});
+      auto provider = rootView->UiaProviderFromPoint(
+          {static_cast<LONG>(local.X * m_island.RasterizationScale()),
+           static_cast<LONG>(local.Y * m_island.RasterizationScale())});
+      auto spFragment = provider.try_as<IRawElementProviderFragment>();
+      if (spFragment) {
+        *pRetVal = spFragment.detach();
+      }
+
+      return S_OK;
+    }
+#endif
 
-  auto provider = spRootView->UiaProviderFromPoint(clientPoint);
-  auto spFragment = provider.try_as<IRawElementProviderFragment>();
-  if (spFragment) {
-    *pRetVal = spFragment.detach();
+    if (m_hwnd) {
+      if (!IsWindow(m_hwnd)) {
+        // TODO: Add support for non-HWND based hosting
+        assert(false);
+        return E_FAIL;
+      }
+
+      POINT clientPoint{static_cast<LONG>(x), static_cast<LONG>(y)};
+      ScreenToClient(m_hwnd, &clientPoint);
+
+      auto provider = rootView->UiaProviderFromPoint(clientPoint);
+      auto spFragment = provider.try_as<IRawElementProviderFragment>();
+      if (spFragment) {
+        *pRetVal = spFragment.detach();
+        return S_OK;
+      }
+    }
   }
 
+  AddRef();
+  *pRetVal = this;
   return S_OK;
 }
 
@@ -175,17 +236,18 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetFocus(IRawElementProvide
 
   *pRetVal = nullptr;
 
-  auto strongView = m_view.view();
+  auto rootView = rootComponentView();
 
-  if (strongView == nullptr) {
+  if (rootView == nullptr) {
     return UIA_E_ELEMENTNOTAVAILABLE;
   }
 
-  auto rootCV = std::static_pointer_cast<::Microsoft::ReactNative::RootComponentView>(strongView);
-  auto focusedComponent = rootCV->GetFocusedComponent();
+  const auto &focusedComponent = rootView->GetFocusedComponent();
 
   if (focusedComponent) {
-    auto focusedUiaProvider = focusedComponent->EnsureUiaProvider();
+    auto focusedUiaProvider =
+        winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(focusedComponent)
+            ->EnsureUiaProvider();
     auto spFragment = focusedUiaProvider.try_as<IRawElementProviderFragment>();
     if (spFragment) {
       *pRetVal = spFragment.detach();
@@ -214,7 +276,14 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
   // Fragment roots do not enable navigation to a parent or siblings; navigation among fragment roots is handled by the
   // default window providers. Elements in fragments must navigate only to other elements within that fragment.
   if (direction == NavigateDirection_FirstChild || direction == NavigateDirection_LastChild) {
-    return UiaNavigateHelper(m_view, direction, *pRetVal);
+    if (auto rootView = rootComponentView()) {
+      auto uiaProvider = rootView->EnsureUiaProvider();
+      auto spFragment = uiaProvider.try_as<IRawElementProviderFragment>();
+      if (spFragment) {
+        *pRetVal = spFragment.detach();
+        return S_OK;
+      }
+    }
   }
   *pRetVal = nullptr;
   return S_OK;

package/Microsoft.ReactNative/Fabric/Composition/CompositionRootAutomationProvider.h

@@ -39,8 +39,7 @@ class CompositionRootAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall AdviseEventAdded(EVENTID idEvent, SAFEARRAY *psaProperties) override;
   virtual HRESULT __stdcall AdviseEventRemoved(EVENTID idEvent, SAFEARRAY *psaProperties) override;
 
-  CompositionRootAutomationProvider(
-      const std::shared_ptr<::Microsoft::ReactNative::RootComponentView> &componentView) noexcept;
+  CompositionRootAutomationProvider(const winrt::Microsoft::ReactNative::CompositionRootView &rootView) noexcept;
 
   void SetHwnd(HWND hwnd) noexcept;
 #ifdef USE_WINUI3
@@ -64,6 +63,8 @@ class CompositionRootAutomationProvider : public winrt::implements<
   };
 
  private:
+  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *rootComponentView() noexcept;
+
   HRESULT AdvisePropertiesAdded(SAFEARRAY *psaProperties) noexcept;
   HRESULT AdvisePropertiesRemoved(SAFEARRAY *psaProperties) noexcept;
 
@@ -71,7 +72,7 @@ class CompositionRootAutomationProvider : public winrt::implements<
   // practice ATs tend to only listen to a dozen or so props and events, so std::vector is likely better than maps.
   std::vector<AdvisedEvent> m_advisedEvents{};
   std::vector<AdvisedEvent> m_advisedProperties{};
-  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::weak_ref<winrt::Microsoft::ReactNative::CompositionRootView> m_wkRootView;
   HWND m_hwnd{nullptr};
 #ifdef USE_WINUI3
   winrt::Microsoft::UI::Content::ContentIsland m_island{nullptr};