react-native-windows 0.76.7 → 0.76.9

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

@@ -16,12 +16,21 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  IInvokeProvider,
                                                  IScrollItemProvider,
                                                  IValueProvider,
+                                                 IRangeValueProvider,
                                                  IToggleProvider,
-                                                 IExpandCollapseProvider> {
+                                                 IExpandCollapseProvider,
+                                                 ISelectionProvider,
+                                                 ISelectionItemProvider> {
  public:
   CompositionDynamicAutomationProvider(
       const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
 
+#ifdef USE_EXPERIMENTAL_WINUI3
+  CompositionDynamicAutomationProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      const winrt::Microsoft::UI::Content::ChildSiteLink &childContentLink) noexcept;
+#endif // USE_EXPERIMENTAL_WINUI3
+
   // inherited via IRawElementProviderFragment
   virtual HRESULT __stdcall Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal) override;
   virtual HRESULT __stdcall GetRuntimeId(SAFEARRAY **pRetVal) override;
@@ -48,6 +57,14 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall get_Value(BSTR *pRetVal) override;
   virtual HRESULT __stdcall get_IsReadOnly(BOOL *pRetVal) override;
 
+  // inherited via IRangeValueProvider
+  virtual HRESULT __stdcall get_LargeChange(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Maximum(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Minimum(double *pRetVal) override;
+  virtual HRESULT __stdcall get_SmallChange(double *pRetVal) override;
+  virtual HRESULT __stdcall get_Value(double *pRetVal) override;
+  virtual HRESULT __stdcall SetValue(double val) override;
+
   // inherited via IToggleProvider
   virtual HRESULT __stdcall get_ToggleState(ToggleState *pRetVal) override;
   virtual HRESULT __stdcall Toggle() override;
@@ -57,8 +74,29 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall Expand() override;
   virtual HRESULT __stdcall Collapse() override;
 
+  // inherited via ISelectionProvider
+  virtual HRESULT __stdcall get_CanSelectMultiple(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall get_IsSelectionRequired(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall GetSelection(SAFEARRAY **pRetVal) override;
+
+  // inherited via ISelectionItemProvider
+  virtual HRESULT __stdcall AddToSelection() override;
+  virtual HRESULT __stdcall get_IsSelected(BOOL *pRetVal) override;
+  virtual HRESULT __stdcall get_SelectionContainer(IRawElementProviderSimple **pRetVal) override;
+  virtual HRESULT __stdcall RemoveFromSelection() override;
+  virtual HRESULT __stdcall Select() override;
+
+  void AddToSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
+  void RemoveFromSelectionItems(winrt::com_ptr<IRawElementProviderSimple> &item);
+
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<ITextProvider2> m_textProvider;
+  std::vector<winrt::com_ptr<IRawElementProviderSimple>> m_selectionItems;
+#ifdef USE_EXPERIMENTAL_WINUI3
+  // Non-null when this UIA node is the peer of a ContentIslandComponentView.
+  winrt::Microsoft::UI::Content::ChildSiteLink m_childSiteLink{nullptr};
+#endif
 };
 
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -9,7 +9,6 @@
 #include <IReactContext.h>
 #include <React.h>
 #include <Views/DevMenu.h>
-#include <Views/ShadowNodeBase.h>
 #include <windows.h>
 #include <windowsx.h>
 #include <winrt/Windows.UI.Core.h>
@@ -142,9 +141,8 @@ struct CompositionInputKeyboardSource : winrt::implements<
 
 CompositionEventHandler::CompositionEventHandler(
     const winrt::Microsoft::ReactNative::ReactContext &context,
-    const winrt::Microsoft::ReactNative::ReactNativeIsland &reactNativeIsland,
-    const int fragmentTag)
-    : m_fragmentTag(fragmentTag), m_context(context), m_wkRootView(reactNativeIsland) {}
+    const winrt::Microsoft::ReactNative::ReactNativeIsland &reactNativeIsland)
+    : m_context(context), m_wkRootView(reactNativeIsland) {}
 
 void CompositionEventHandler::Initialize() noexcept {
 #ifdef USE_WINUI3
@@ -198,6 +196,20 @@ void CompositionEventHandler::Initialize() noexcept {
       }
     });
 
+    m_pointerExitedToken = pointerSource.PointerExited([wkThis = weak_from_this()](
+                                                           winrt::Microsoft::UI::Input::InputPointerSource const &,
+                                                           winrt::Microsoft::UI::Input::PointerEventArgs const &args) {
+      if (auto strongThis = wkThis.lock()) {
+        if (auto strongRootView = strongThis->m_wkRootView.get()) {
+          if (strongThis->SurfaceId() == -1)
+            return;
+          auto pp = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerPoint>(
+              args.CurrentPoint(), strongRootView.ScaleFactor());
+          strongThis->onPointerExited(pp, args.KeyModifiers());
+        }
+      }
+    });
+
     m_pointerCaptureLostToken =
         pointerSource.PointerCaptureLost([wkThis = weak_from_this()](
                                              winrt::Microsoft::UI::Input::InputPointerSource const &,
@@ -348,11 +360,8 @@ facebook::react::SurfaceId CompositionEventHandler::SurfaceId() const noexcept {
 
 winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView &
 CompositionEventHandler::RootComponentView() const noexcept {
-  auto rootComponentViewDescriptor = (::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties()))
-                                         ->GetViewRegistry()
-                                         .componentViewDescriptorWithTag(SurfaceId());
-  return *rootComponentViewDescriptor.view
-              .as<winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView>();
+  auto island = m_wkRootView.get();
+  return *winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(island)->GetComponentView();
 }
 
 void CompositionEventHandler::onPointerWheelChanged(
@@ -365,6 +374,9 @@ void CompositionEventHandler::onPointerWheelChanged(
     facebook::react::Point ptLocal;
     facebook::react::Point ptScaled = {static_cast<float>(position.X), static_cast<float>(position.Y)};
 
+    // In the case of a sub rootview, we may have a non-zero origin.  hitTest takes a pt in the parent coords, so we
+    // need to apply the current origin
+    ptScaled += RootComponentView().layoutMetrics().frame.origin;
     auto tag = RootComponentView().hitTest(ptScaled, ptLocal);
 
     if (tag == -1)
@@ -977,6 +989,11 @@ void CompositionEventHandler::getTargetPointerArgs(
   tag = -1;
 
   ptScaled = {position.X, position.Y};
+
+  // In the case of a sub rootview, we may have a non-zero origin.  hitTest takes a pt in the parent coords, so we need
+  // to apply the current origin
+  ptScaled += RootComponentView().layoutMetrics().frame.origin;
+
   if (std::find(m_capturedPointers.begin(), m_capturedPointers.end(), pointerId) != m_capturedPointers.end()) {
     assert(m_pointerCapturingComponentTag != -1);
     tag = m_pointerCapturingComponentTag;
@@ -989,30 +1006,7 @@ void CompositionEventHandler::getTargetPointerArgs(
       ptLocal.y = ptScaled.y - (clientRect.top / strongRootView.ScaleFactor());
     }
   } else {
-    if (m_fragmentTag == -1) {
-      tag = RootComponentView().hitTest(ptScaled, ptLocal);
-      return;
-    }
-
-    // check if the fragment tag exists
-    if (!fabricuiManager->GetViewRegistry().findComponentViewWithTag(m_fragmentTag)) {
-      return;
-    }
-
-    auto fagmentView = fabricuiManager->GetViewRegistry().componentViewDescriptorWithTag(m_fragmentTag).view;
-    auto fagmentchildren = fagmentView.Children();
-
-    // call the hitTest with the fargment as the RootComponent
-    for (auto index = fagmentchildren.Size(); index > 0; index--) {
-      auto childView = fagmentchildren.GetAt(index - 1);
-      auto targetTag =
-          winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(childView)->hitTest(
-              ptScaled, ptLocal);
-      if (targetTag != -1) {
-        tag = targetTag;
-        break;
-      }
-    }
+    tag = RootComponentView().hitTest(ptScaled, ptLocal);
   }
 }
 
@@ -1083,6 +1077,34 @@ void CompositionEventHandler::onPointerMoved(
   }
 }
 
+void CompositionEventHandler::onPointerExited(
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+    winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {
+  if (SurfaceId() == -1)
+    return;
+
+  int pointerId = pointerPoint.PointerId();
+  auto position = pointerPoint.Position();
+
+  if (std::shared_ptr<FabricUIManager> fabricuiManager =
+          ::Microsoft::ReactNative::FabricUIManager::FromProperties(m_context.Properties())) {
+    facebook::react::Tag tag = -1;
+    facebook::react::Point ptLocal, ptScaled;
+    getTargetPointerArgs(fabricuiManager, pointerPoint, tag, ptScaled, ptLocal);
+
+    tag = -1;
+
+    auto args = winrt::make<winrt::Microsoft::ReactNative::Composition::Input::implementation::PointerRoutedEventArgs>(
+        m_context, tag, pointerPoint, keyModifiers);
+
+    facebook::react::PointerEvent pointerEvent = CreatePointerEventFromIncompleteHoverData(ptScaled, ptLocal);
+
+    auto handler = [](std::vector<winrt::Microsoft::ReactNative::ComponentView> &eventPathViews) {};
+
+    HandleIncomingPointerEvent(pointerEvent, nullptr, pointerPoint, keyModifiers, handler);
+  }
+}
+
 void CompositionEventHandler::onPointerPressed(
     const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
     winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept {

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

@@ -31,8 +31,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
  public:
   CompositionEventHandler(
       const winrt::Microsoft::ReactNative::ReactContext &context,
-      const winrt::Microsoft::ReactNative::ReactNativeIsland &ReactNativeIsland,
-      const int fragmentTag);
+      const winrt::Microsoft::ReactNative::ReactNativeIsland &ReactNativeIsland);
   virtual ~CompositionEventHandler();
 
   void Initialize() noexcept;
@@ -58,6 +57,9 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   void onPointerMoved(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
+  void onPointerExited(
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
+      winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
   void onPointerWheelChanged(
       const winrt::Microsoft::ReactNative::Composition::Input::PointerPoint &pointerPoint,
       winrt::Windows::System::VirtualKeyModifiers keyModifiers) noexcept;
@@ -152,7 +154,6 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
 
   std::map<PointerId, ActiveTouch> m_activeTouches; // iOS is map of touch event args to ActiveTouch..?
   PointerId m_touchId = 0;
-  int m_fragmentTag = -1;
 
   std::map<PointerId, std::vector<ReactTaggedView>> m_currentlyHoveredViewsPerPointer;
   winrt::weak_ref<winrt::Microsoft::ReactNative::ReactNativeIsland> m_wkRootView;
@@ -171,6 +172,7 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   winrt::event_token m_pointerMovedToken;
   winrt::event_token m_pointerWheelChangedToken;
   winrt::event_token m_pointerCaptureLostToken;
+  winrt::event_token m_pointerExitedToken;
   winrt::event_token m_keyDownToken;
   winrt::event_token m_keyUpToken;
   winrt::event_token m_characterReceivedToken;

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

@@ -27,6 +27,25 @@ HRESULT __stdcall CompositionRootAutomationProvider::GetRuntimeId(SAFEARRAY **pR
 
   *pRetVal = nullptr;
 
+  if (!m_island)
+    return E_FAIL;
+
+  *pRetVal = SafeArrayCreateVector(VT_I4, 0, 3);
+  if (*pRetVal == nullptr)
+    return E_OUTOFMEMORY;
+
+  auto rgiRuntimeId = static_cast<int *>((*pRetVal)->pvData);
+
+  rgiRuntimeId[0] = UiaAppendRuntimeId;
+  rgiRuntimeId[1] = 0;
+  rgiRuntimeId[2] = 0;
+
+  if (auto rootView = m_wkRootView.get()) {
+    auto tag = rootView.RootTag();
+    rgiRuntimeId[1] = LODWORD(tag);
+    rgiRuntimeId[2] = HIDWORD(tag);
+  }
+
   return S_OK;
 }
 
@@ -153,8 +172,18 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_FragmentRoot(IRawElemen
   if (pRetVal == nullptr)
     return E_POINTER;
 
-  AddRef();
-  *pRetVal = this;
+  *pRetVal = nullptr;
+
+#ifdef USE_EXPERIMENTAL_WINUI3
+  if (m_island) {
+    auto parentRoot = m_island.FragmentRootAutomationProvider();
+    auto spFragment = parentRoot.try_as<IRawElementProviderFragmentRoot>();
+    if (spFragment) {
+      *pRetVal = spFragment.detach();
+      return S_OK;
+    }
+  }
+#endif
 
   return S_OK;
 }
@@ -167,7 +196,7 @@ HRESULT __stdcall CompositionRootAutomationProvider::get_ProviderOptions(Provide
   return S_OK;
 }
 
-winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *
+winrt::com_ptr<winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView>
 CompositionRootAutomationProvider::rootComponentView() noexcept {
   if (auto rootView = m_wkRootView.get()) {
     auto innerRootView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(rootView);
@@ -249,8 +278,6 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
   if (pRetVal == nullptr)
     return E_POINTER;
 
-  // 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) {
     if (auto rootView = rootComponentView()) {
       auto uiaProvider = rootView->EnsureUiaProvider();
@@ -260,6 +287,17 @@ HRESULT __stdcall CompositionRootAutomationProvider::Navigate(
         return S_OK;
       }
     }
+  } else if (direction == NavigateDirection_Parent) {
+#ifdef USE_EXPERIMENTAL_WINUI3
+    if (m_island) {
+      auto parent = m_island.ParentAutomationProvider();
+      auto spFragment = parent.try_as<IRawElementProviderFragment>();
+      if (spFragment) {
+        *pRetVal = spFragment.detach();
+        return S_OK;
+      }
+    }
+#endif
   }
   *pRetVal = nullptr;
   return S_OK;

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

@@ -63,7 +63,8 @@ class CompositionRootAutomationProvider : public winrt::implements<
   };
 
  private:
-  winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *rootComponentView() noexcept;
+  winrt::com_ptr<winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView>
+  rootComponentView() noexcept;
 
   HRESULT AdvisePropertiesAdded(SAFEARRAY *psaProperties) noexcept;
   HRESULT AdvisePropertiesRemoved(SAFEARRAY *psaProperties) noexcept;

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

@@ -0,0 +1,115 @@
+#include "pch.h"
+#include <Fabric/ComponentView.h>
+#include <Fabric/Composition/ParagraphComponentView.h>
+#include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
+#include <Unicode.h>
+#include "CompositionTextRangeProvider.h"
+#include "RootComponentView.h"
+#include "UiaHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+CompositionTextProvider::CompositionTextProvider(
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+    CompositionDynamicAutomationProvider *parentProvider) noexcept
+    : m_view{componentView} {
+  m_parentProvider.copy_from(parentProvider);
+  EnsureTextRangeProvider();
+}
+
+void CompositionTextProvider::EnsureTextRangeProvider() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return;
+
+  if (!m_textRangeProvider) {
+    m_textRangeProvider =
+        winrt::make<CompositionTextRangeProvider>(
+            strongView.as<winrt::Microsoft::ReactNative::Composition::ComponentView>(), m_parentProvider.get())
+            .try_as<ITextRangeProvider>();
+  }
+}
+
+HRESULT __stdcall CompositionTextProvider::get_DocumentRange(ITextRangeProvider **pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  m_textRangeProvider.copy_to(pRetVal);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::get_SupportedTextSelection(SupportedTextSelection *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  if (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::WindowsTextInputComponentView>()) {
+    *pRetVal = SupportedTextSelection_Single;
+  } else if (
+      auto textView =
+          strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ParagraphComponentView>()) {
+    auto props = std::static_pointer_cast<const facebook::react::ParagraphProps>(textView->props());
+    if (props == nullptr)
+      return UIA_E_ELEMENTNOTAVAILABLE;
+    *pRetVal = props->isSelectable ? SupportedTextSelection_Single : SupportedTextSelection_None;
+  } else {
+    *pRetVal = SupportedTextSelection_None;
+  }
+
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::GetSelection(SAFEARRAY **pRetVal) {
+  // no-op
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 0);
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::GetVisibleRanges(SAFEARRAY **pRetVal) {
+  *pRetVal = SafeArrayCreateVector(VT_UNKNOWN, 0, 1);
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  LONG pos = 0;
+  return SafeArrayPutElement(*pRetVal, &pos, m_textRangeProvider.get());
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromChild(
+    IRawElementProviderSimple *childElement,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromPoint(UiaPoint point, ITextRangeProvider **pRetVal) {
+  // no-op
+  if (m_textRangeProvider == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  m_textRangeProvider.copy_to(pRetVal);
+  return S_OK;
+}
+HRESULT __stdcall CompositionTextProvider::GetCaretRange(BOOL *isActive, ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionTextProvider::RangeFromAnnotation(
+    IRawElementProviderSimple *annotationElement,
+    ITextRangeProvider **pRetVal) {
+  // no-op
+  *pRetVal = nullptr;
+  return S_OK;
+}
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+#include <inspectable.h>
+#include <uiautomationcore.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+class CompositionTextProvider : public winrt::implements<CompositionTextProvider, ITextProvider, ITextProvider2> {
+ public:
+  CompositionTextProvider(
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView,
+      CompositionDynamicAutomationProvider *parentProvider) noexcept;
+
+  // inherited via ITextProvider
+  virtual HRESULT __stdcall get_DocumentRange(ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall get_SupportedTextSelection(SupportedTextSelection *pRetVal) override;
+  virtual HRESULT __stdcall GetSelection(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall GetVisibleRanges(SAFEARRAY **pRetVal) override;
+  virtual HRESULT __stdcall RangeFromChild(IRawElementProviderSimple *childElement, ITextRangeProvider **pRetVal)
+      override;
+  virtual HRESULT __stdcall RangeFromPoint(UiaPoint point, ITextRangeProvider **pRetVal) override;
+
+  // inherited via ITextProvider2
+  virtual HRESULT __stdcall GetCaretRange(BOOL *isActive, ITextRangeProvider **pRetVal) override;
+  virtual HRESULT __stdcall RangeFromAnnotation(
+      IRawElementProviderSimple *annotationElement,
+      ITextRangeProvider **pRetVal) override;
+
+  void EnsureTextRangeProvider();
+
+ private:
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::com_ptr<ITextRangeProvider> m_textRangeProvider;
+  winrt::com_ptr<CompositionDynamicAutomationProvider> m_parentProvider;
+};
+
+} // namespace winrt::Microsoft::ReactNative::implementation