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

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

@@ -5,7 +5,7 @@
 #ifdef USE_WINUI3
 #include "Composition.MicrosoftCompositionContextHelper.g.h"
 #endif
-#include "Composition.WindowsCompositionContextHelper.g.h"
+#include "Composition.SystemCompositionContextHelper.g.h"
 
 #include <d2d1_1.h>
 #include <windows.ui.composition.interop.h>
@@ -16,14 +16,14 @@ namespace winrt::Microsoft::ReactNative::Composition {
 #ifdef USE_WINUI3
 using CompositionContextHelper = MicrosoftCompositionContextHelper;
 #else
-using CompositionContextHelper = WindowsCompositionContextHelper;
+using CompositionContextHelper = SystemCompositionContextHelper;
 #endif
 } // namespace winrt::Microsoft::ReactNative::Composition
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-struct WindowsCompositionContextHelper : WindowsCompositionContextHelperT<WindowsCompositionContextHelper> {
-  WindowsCompositionContextHelper() = default;
+struct SystemCompositionContextHelper : SystemCompositionContextHelperT<SystemCompositionContextHelper> {
+  SystemCompositionContextHelper() = default;
 
   static ICompositionContext CreateContext(winrt::Windows::UI::Composition::Compositor const &compositor) noexcept;
   static IVisual CreateVisual(winrt::Windows::UI::Composition::Visual const &visual) noexcept;
@@ -52,9 +52,9 @@ struct MicrosoftCompositionContextHelper : MicrosoftCompositionContextHelperT<Mi
 
 namespace winrt::Microsoft::ReactNative::Composition::factory_implementation {
 
-struct WindowsCompositionContextHelper : WindowsCompositionContextHelperT<
-                                             WindowsCompositionContextHelper,
-                                             implementation::WindowsCompositionContextHelper> {};
+struct SystemCompositionContextHelper
+    : SystemCompositionContextHelperT<SystemCompositionContextHelper, implementation::SystemCompositionContextHelper> {
+};
 
 #ifdef USE_WINUI3
 struct MicrosoftCompositionContextHelper : MicrosoftCompositionContextHelperT<

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

@@ -1,8 +1,8 @@
 
 #include "pch.h"
 #include "CompositionContextHelper.h"
-#if __has_include("Composition.WindowsCompositionContextHelper.g.cpp")
-#include "Composition.WindowsCompositionContextHelper.g.cpp"
+#if __has_include("Composition.SystemCompositionContextHelper.g.cpp")
+#include "Composition.SystemCompositionContextHelper.g.cpp"
 #endif
 #ifdef USE_WINUI3
 #if __has_include("Composition.MicrosoftCompositionContextHelper.g.cpp")
@@ -12,33 +12,33 @@
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-ICompositionContext WindowsCompositionContextHelper::CreateContext(
+ICompositionContext SystemCompositionContextHelper::CreateContext(
     winrt::Windows::UI::Composition::Compositor const &) noexcept {
   return nullptr;
 }
 
-IVisual WindowsCompositionContextHelper::CreateVisual(winrt::Windows::UI::Composition::Visual const &) noexcept {
+IVisual SystemCompositionContextHelper::CreateVisual(winrt::Windows::UI::Composition::Visual const &) noexcept {
   return nullptr;
 }
 
-winrt::Windows::UI::Composition::Compositor WindowsCompositionContextHelper::InnerCompositor(
+winrt::Windows::UI::Composition::Compositor SystemCompositionContextHelper::InnerCompositor(
     ICompositionContext) noexcept {
   return nullptr;
 }
 
-winrt::Windows::UI::Composition::Visual WindowsCompositionContextHelper::InnerVisual(IVisual) noexcept {
+winrt::Windows::UI::Composition::Visual SystemCompositionContextHelper::InnerVisual(IVisual) noexcept {
   return nullptr;
 }
 
-winrt::Windows::UI::Composition::DropShadow WindowsCompositionContextHelper::InnerDropShadow(IDropShadow) noexcept {
+winrt::Windows::UI::Composition::DropShadow SystemCompositionContextHelper::InnerDropShadow(IDropShadow) noexcept {
   return nullptr;
 }
 
-winrt::Windows::UI::Composition::CompositionBrush WindowsCompositionContextHelper::InnerBrush(IBrush) noexcept {
+winrt::Windows::UI::Composition::CompositionBrush SystemCompositionContextHelper::InnerBrush(IBrush) noexcept {
   return nullptr;
 }
 
-winrt::Windows::UI::Composition::ICompositionSurface WindowsCompositionContextHelper::InnerSurface(
+winrt::Windows::UI::Composition::ICompositionSurface SystemCompositionContextHelper::InnerSurface(
     IDrawingSurfaceBrush) noexcept {
   return nullptr;
 }

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

@@ -8,8 +8,8 @@
 namespace winrt::Microsoft::ReactNative::implementation {
 
 CompositionDynamicAutomationProvider::CompositionDynamicAutomationProvider(
-    const std::shared_ptr<::Microsoft::ReactNative::CompositionBaseComponentView> &componentView) noexcept
-    : m_view{std::static_pointer_cast<::Microsoft::ReactNative::IComponentView>(componentView)} {}
+    const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept
+    : m_view{componentView} {}
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
     NavigateDirection direction,
@@ -17,7 +17,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Navigate(
   if (pRetVal == nullptr)
     return E_POINTER;
 
-  return UiaNavigateHelper(m_view, direction, *pRetVal);
+  return UiaNavigateHelper(m_view.view(), direction, *pRetVal);
 }
 
 // Implementations should return NULL for a top-level element that is hosted in a window. Other elements should return
@@ -41,7 +41,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetRuntimeId(SAFEARRAY *
   if (*pRetVal == nullptr)
     return E_OUTOFMEMORY;
 
-  int runtimeId[] = {UiaAppendRuntimeId, strongView->tag()};
+  int runtimeId[] = {UiaAppendRuntimeId, strongView.Tag()};
   for (long i = 0; i < 2; i++) {
     SafeArrayPutElement(*pRetVal, &i, static_cast<void *>(&runtimeId[i]));
   }
@@ -62,17 +62,23 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_BoundingRectangle(Ui
   // into account already.
   winrt::com_ptr<IRawElementProviderFragmentRoot> spFragmentRoot = nullptr;
   hr = get_FragmentRoot(spFragmentRoot.put());
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    assert(false);
     return hr;
+  }
 
   auto spFragment = spFragmentRoot.try_as<IRawElementProviderFragment>();
-  if (spFragment == nullptr)
+  if (spFragment == nullptr) {
+    assert(false);
     return E_FAIL;
+  }
 
   UiaRect rect;
   hr = spFragment->get_BoundingRectangle(&rect);
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    assert(false);
     return hr;
+  }
 
   pRetVal->left += rect.left;
   pRetVal->top += rect.top;
@@ -99,20 +105,16 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_FragmentRoot(IRawEle
 
   auto strongView = m_view.view();
 
-  if (!strongView)
-    return UIA_E_ELEMENTNOTAVAILABLE;
-
-  auto rootCV = strongView->rootComponentView();
-  if (rootCV == nullptr)
+  if (!strongView) {
     return UIA_E_ELEMENTNOTAVAILABLE;
+  }
 
-  auto uiaProvider = rootCV->EnsureUiaProvider();
-  auto spFragmentRoot = uiaProvider.try_as<IRawElementProviderFragmentRoot>();
-  if (spFragmentRoot) {
-    *pRetVal = spFragmentRoot.detach();
+  if (auto root = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
+                      ->rootComponentView()) {
+    return root->GetFragmentRoot(pRetVal);
   }
 
-  return S_OK;
+  return UIA_E_ELEMENTNOTAVAILABLE;
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_ProviderOptions(ProviderOptions *pRetVal) {
@@ -133,7 +135,8 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
   if (strongView == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(strongView->props());
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
   if (props == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
   auto accessibilityRole = props->accessibilityRole;
@@ -147,6 +150,16 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
+  if (patternId == UIA_ScrollItemPatternId) {
+    *pRetVal = static_cast<IScrollItemProvider *>(this);
+    AddRef();
+  }
+
+  if (patternId == UIA_ValuePatternId) {
+    *pRetVal = static_cast<IValueProvider *>(this);
+    AddRef();
+  }
+
   return S_OK;
 }
 
@@ -221,12 +234,16 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
   if (strongView == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(strongView->props());
+  auto baseView = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView);
+  if (baseView == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(baseView->props());
   if (props == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto baseView = std::static_pointer_cast<::Microsoft::ReactNative::CompositionBaseComponentView>(strongView);
-  if (baseView == nullptr)
+  auto compositionView = strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
+  if (compositionView == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
   auto hr = S_OK;
@@ -234,7 +251,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
   switch (propertyId) {
     case UIA_ControlTypePropertyId: {
       pRetVal->vt = VT_I4;
-      auto role = props->accessibilityRole.empty() ? baseView->DefaultControlType() : props->accessibilityRole;
+      auto role = props->accessibilityRole.empty() ? compositionView->DefaultControlType() : props->accessibilityRole;
       pRetVal->lVal = GetControlType(role);
       break;
     }
@@ -248,7 +265,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
     case UIA_NamePropertyId: {
       pRetVal->vt = VT_BSTR;
       auto wideName = ::Microsoft::Common::Unicode::Utf8ToUtf16(
-          props->accessibilityLabel.empty() ? baseView->DefaultAccessibleName() : props->accessibilityLabel);
+          props->accessibilityLabel.empty() ? compositionView->DefaultAccessibleName() : props->accessibilityLabel);
       pRetVal->bstrVal = SysAllocString(wideName.c_str());
       hr = pRetVal->bstrVal != nullptr ? S_OK : E_OUTOFMEMORY;
       break;
@@ -259,17 +276,18 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
       break;
     }
     case UIA_HasKeyboardFocusPropertyId: {
-      auto rootCV = strongView->rootComponentView();
+      auto rootCV = baseView->rootComponentView();
       if (rootCV == nullptr)
         return UIA_E_ELEMENTNOTAVAILABLE;
 
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal = rootCV->GetFocusedComponent() == strongView.get() ? VARIANT_TRUE : VARIANT_FALSE;
+      pRetVal->boolVal = rootCV->GetFocusedComponent() == strongView ? VARIANT_TRUE : VARIANT_FALSE;
       break;
     }
     case UIA_IsEnabledPropertyId: {
       pRetVal->vt = VT_BOOL;
-      pRetVal->boolVal = !props->accessibilityState.disabled ? VARIANT_TRUE : VARIANT_FALSE;
+      pRetVal->boolVal =
+          !(props->accessibilityState && props->accessibilityState->disabled) ? VARIANT_TRUE : VARIANT_FALSE;
       break;
     }
     case UIA_IsContentElementPropertyId: {
@@ -282,11 +300,14 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
       pRetVal->boolVal = (props->accessible && props->accessibilityRole != "none") ? VARIANT_TRUE : VARIANT_FALSE;
       break;
     }
-
+    case UIA_IsOffscreenPropertyId: {
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = (compositionView->getClipState() == ClipState::FullyClipped) ? VARIANT_TRUE : VARIANT_FALSE;
+    }
     case UIA_HelpTextPropertyId: {
       pRetVal->vt = VT_BSTR;
       auto helpText = props->accessibilityHint.empty()
-          ? ::Microsoft::Common::Unicode::Utf8ToUtf16(baseView->DefaultHelpText())
+          ? ::Microsoft::Common::Unicode::Utf8ToUtf16(compositionView->DefaultHelpText())
           : ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityHint);
       pRetVal->bstrVal = SysAllocString(helpText.c_str());
       hr = pRetVal->bstrVal != nullptr ? S_OK : E_OUTOFMEMORY;
@@ -313,12 +334,13 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Invoke() {
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  auto baseView = std::static_pointer_cast<::Microsoft::ReactNative::CompositionBaseComponentView>(strongView);
+  auto baseView = strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>();
   if (baseView == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  baseView.get()->GetEventEmitter().get()->onAccessibilityTap();
-  auto uiaProvider = baseView->EnsureUiaProvider();
+  baseView->GetEventEmitter().get()->onAccessibilityTap();
+  auto uiaProvider =
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->EnsureUiaProvider();
   auto spProviderSimple = uiaProvider.try_as<IRawElementProviderSimple>();
   if (spProviderSimple != nullptr) {
     UiaRaiseAutomationEvent(spProviderSimple.get(), UIA_Invoke_InvokedEventId);
@@ -327,4 +349,71 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Invoke() {
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::ScrollIntoView() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  winrt::Microsoft::ReactNative::implementation::BringIntoViewOptions scrollOptions;
+  winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
+      ->StartBringIntoView(std::move(scrollOptions));
+
+  return S_OK;
+}
+
+BSTR StringToBSTR(const std::string &str) {
+  // Calculate the required BSTR size in bytes
+  int len = MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, nullptr, 0);
+  if (len == 0) {
+    return nullptr; // Conversion error
+  }
+
+  // Allocate memory for the BSTR
+  BSTR bstr = SysAllocStringLen(nullptr, len - 1); // len includes the null terminator
+
+  // Convert the std::string to BSTR
+  MultiByteToWideChar(CP_UTF8, 0, str.c_str(), -1, bstr, len);
+
+  return bstr;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::SetValue(LPCWSTR val) {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
+      ->setAcccessiblityValue(winrt::to_string(val));
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_Value(BSTR *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = StringToBSTR(winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
+                              ->getAcccessiblityValue()
+                              .value_or(""));
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_IsReadOnly(BOOL *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  *pRetVal = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)
+                 ->getAcccessiblityIsReadOnly();
+  return S_OK;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -13,10 +13,12 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  IInspectable,
                                                  IRawElementProviderFragment,
                                                  IRawElementProviderSimple,
-                                                 IInvokeProvider> {
+                                                 IInvokeProvider,
+                                                 IScrollItemProvider,
+                                                 IValueProvider> {
  public:
   CompositionDynamicAutomationProvider(
-      const std::shared_ptr<::Microsoft::ReactNative::CompositionBaseComponentView> &componentView) noexcept;
+      const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
 
   // inherited via IRawElementProviderFragment
   virtual HRESULT __stdcall Navigate(NavigateDirection direction, IRawElementProviderFragment **pRetVal) override;
@@ -36,6 +38,14 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   // inherited via IInvokeProvider
   virtual HRESULT __stdcall Invoke() override;
 
+  // inherited via IScrollItemProvider
+  HRESULT __stdcall ScrollIntoView() override;
+
+  // inherited via IValueProvider
+  virtual HRESULT __stdcall SetValue(LPCWSTR val) override;
+  virtual HRESULT __stdcall get_Value(BSTR *pRetVal) override;
+  virtual HRESULT __stdcall get_IsReadOnly(BOOL *pRetVal) override;
+
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
 };