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

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

@@ -2,17 +2,28 @@
 // Licensed under the MIT License.
 #pragma once
 
-#include "Composition.CompositionContextHelper.g.h"
+#ifdef USE_WINUI3
+#include "Composition.MicrosoftCompositionContextHelper.g.h"
+#endif
+#include "Composition.WindowsCompositionContextHelper.g.h"
 
 #include <d2d1_1.h>
 #include <windows.ui.composition.interop.h>
 #include <winrt/Windows.UI.Composition.h>
 #include "CompositionHelpers.h"
 
+namespace winrt::Microsoft::ReactNative::Composition {
+#ifdef USE_WINUI3
+using CompositionContextHelper = MicrosoftCompositionContextHelper;
+#else
+using CompositionContextHelper = WindowsCompositionContextHelper;
+#endif
+} // namespace winrt::Microsoft::ReactNative::Composition
+
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 
-struct CompositionContextHelper : CompositionContextHelperT<CompositionContextHelper> {
-  CompositionContextHelper() = default;
+struct WindowsCompositionContextHelper : WindowsCompositionContextHelperT<WindowsCompositionContextHelper> {
+  WindowsCompositionContextHelper() = default;
 
   static ICompositionContext CreateContext(winrt::Windows::UI::Composition::Compositor const &compositor) noexcept;
   static IVisual CreateVisual(winrt::Windows::UI::Composition::Visual const &visual) noexcept;
@@ -20,14 +31,35 @@ struct CompositionContextHelper : CompositionContextHelperT<CompositionContextHe
   static winrt::Windows::UI::Composition::Visual InnerVisual(IVisual visual) noexcept;
   static winrt::Windows::UI::Composition::DropShadow InnerDropShadow(IDropShadow shadow) noexcept;
   static winrt::Windows::UI::Composition::CompositionBrush InnerBrush(IBrush brush) noexcept;
-  static winrt::Windows::UI::Composition::ICompositionSurface InnerSurface(ICompositionDrawingSurface surface) noexcept;
+  static winrt::Windows::UI::Composition::ICompositionSurface InnerSurface(IDrawingSurfaceBrush surface) noexcept;
 };
 
+#ifdef USE_WINUI3
+struct MicrosoftCompositionContextHelper : MicrosoftCompositionContextHelperT<MicrosoftCompositionContextHelper> {
+  MicrosoftCompositionContextHelper() = default;
+
+  static ICompositionContext CreateContext(winrt::Microsoft::UI::Composition::Compositor const &compositor) noexcept;
+  static IVisual CreateVisual(winrt::Microsoft::UI::Composition::Visual const &visual) noexcept;
+  static winrt::Microsoft::UI::Composition::Compositor InnerCompositor(ICompositionContext context) noexcept;
+  static winrt::Microsoft::UI::Composition::Visual InnerVisual(IVisual visual) noexcept;
+  static winrt::Microsoft::UI::Composition::DropShadow InnerDropShadow(IDropShadow shadow) noexcept;
+  static winrt::Microsoft::UI::Composition::CompositionBrush InnerBrush(IBrush brush) noexcept;
+  static winrt::Microsoft::UI::Composition::ICompositionSurface InnerSurface(IDrawingSurfaceBrush surface) noexcept;
+};
+#endif
+
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation
 
 namespace winrt::Microsoft::ReactNative::Composition::factory_implementation {
 
-struct CompositionContextHelper
-    : CompositionContextHelperT<CompositionContextHelper, implementation::CompositionContextHelper> {};
+struct WindowsCompositionContextHelper : WindowsCompositionContextHelperT<
+                                             WindowsCompositionContextHelper,
+                                             implementation::WindowsCompositionContextHelper> {};
+
+#ifdef USE_WINUI3
+struct MicrosoftCompositionContextHelper : MicrosoftCompositionContextHelperT<
+                                               MicrosoftCompositionContextHelper,
+                                               implementation::MicrosoftCompositionContextHelper> {};
+#endif
 
 } // namespace winrt::Microsoft::ReactNative::Composition::factory_implementation

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

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

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

@@ -1,12 +1,7 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
-#pragma warning(push)
-#pragma warning(disable : 4229)
-#define IN
-#define OUT
-#include <atlsafe.h>
-#pragma warning(pop)
+#include <Unicode.h>
 #include "RootComponentView.h"
 #include "UiaHelpers.h"
 
@@ -41,16 +36,15 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetRuntimeId(SAFEARRAY *
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  CComSafeArray<int32_t> runtimeId;
-  auto hr = runtimeId.Create(2);
+  *pRetVal = SafeArrayCreateVector(VT_I4, 0, 2);
 
-  if (FAILED(hr))
-    return hr;
+  if (*pRetVal == nullptr)
+    return E_OUTOFMEMORY;
 
-  runtimeId[0] = UiaAppendRuntimeId;
-  runtimeId[1] = strongView->tag();
-
-  *pRetVal = runtimeId.Detach();
+  int runtimeId[] = {UiaAppendRuntimeId, strongView->tag()};
+  for (long i = 0; i < 2; i++) {
+    SafeArrayPutElement(*pRetVal, &i, static_cast<void *>(&runtimeId[i]));
+  }
 
   return S_OK;
 }
@@ -59,6 +53,30 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_BoundingRectangle(Ui
   if (pRetVal == nullptr)
     return E_POINTER;
 
+  auto hr = UiaGetBoundingRectangleHelper(m_view, *pRetVal);
+  if (FAILED(hr))
+    return hr;
+
+  // Since get_BoundingRectangle needs to provide real screen coordinates back to the UIA client
+  // we'll use the FragmentRoot's origin to offset our rect because that should have been taken
+  // into account already.
+  winrt::com_ptr<IRawElementProviderFragmentRoot> spFragmentRoot = nullptr;
+  hr = get_FragmentRoot(spFragmentRoot.put());
+  if (FAILED(hr))
+    return hr;
+
+  auto spFragment = spFragmentRoot.try_as<IRawElementProviderFragment>();
+  if (spFragment == nullptr)
+    return E_FAIL;
+
+  UiaRect rect;
+  hr = spFragment->get_BoundingRectangle(&rect);
+  if (FAILED(hr))
+    return hr;
+
+  pRetVal->left += rect.left;
+  pRetVal->top += rect.top;
+
   return S_OK;
 }
 
@@ -72,7 +90,7 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetEmbeddedFragmentRoots
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::SetFocus(void) {
-  return S_OK;
+  return UiaSetFocusHelper(m_view);
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_FragmentRoot(IRawElementProviderFragmentRoot **pRetVal) {
@@ -89,10 +107,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_FragmentRoot(IRawEle
     return UIA_E_ELEMENTNOTAVAILABLE;
 
   auto uiaProvider = rootCV->EnsureUiaProvider();
-  if (uiaProvider != nullptr) {
-    winrt::com_ptr<IRawElementProviderFragmentRoot> spReps;
-    uiaProvider.as(spReps);
-    *pRetVal = spReps.detach();
+  auto spFragmentRoot = uiaProvider.try_as<IRawElementProviderFragmentRoot>();
+  if (spFragmentRoot) {
+    *pRetVal = spFragmentRoot.detach();
   }
 
   return S_OK;
@@ -112,6 +129,24 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
 
   *pRetVal = nullptr;
 
+  auto strongView = m_view.view();
+  if (strongView == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(strongView->props());
+  if (props == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  auto accessibilityRole = props->accessibilityRole;
+  // Invoke control pattern is used to support controls that do not maintain state
+  // when activated but rather initiate or perform a single, unambiguous action.
+  if (patternId == UIA_InvokePatternId &&
+      (accessibilityRole == "button" || accessibilityRole == "imagebutton" || accessibilityRole == "link" ||
+       accessibilityRole == "splitbutton" || (accessibilityRole == "menuitem" && props->onAccessibilityTap) ||
+       (accessibilityRole == "treeitem" && props->onAccessibilityTap))) {
+    *pRetVal = static_cast<IInvokeProvider *>(this);
+    AddRef();
+  }
+
   return S_OK;
 }
 
@@ -165,6 +200,8 @@ long GetControlType(const std::string &role) noexcept {
     return UIA_TabItemControlTypeId;
   } else if (role == "tablist") {
     return UIA_TabControlTypeId;
+  } else if (role == "textinput" || role == "searchbox") {
+    return UIA_EditControlTypeId;
   } else if (role == "toolbar") {
     return UIA_ToolBarControlTypeId;
   } else if (role == "tree") {
@@ -188,30 +225,76 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
   if (props == nullptr)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
+  auto baseView = std::static_pointer_cast<::Microsoft::ReactNative::CompositionBaseComponentView>(strongView);
+  if (baseView == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto hr = S_OK;
+
   switch (propertyId) {
     case UIA_ControlTypePropertyId: {
       pRetVal->vt = VT_I4;
-      auto role = props->accessibilityRole;
+      auto role = props->accessibilityRole.empty() ? baseView->DefaultControlType() : props->accessibilityRole;
       pRetVal->lVal = GetControlType(role);
       break;
     }
     case UIA_AutomationIdPropertyId: {
       pRetVal->vt = VT_BSTR;
-      auto testId = props->testId;
-      CComBSTR temp(testId.c_str());
-      pRetVal->bstrVal = temp.Detach();
+      auto wideTestId = ::Microsoft::Common::Unicode::Utf8ToUtf16(props->testId);
+      pRetVal->bstrVal = SysAllocString(wideTestId.c_str());
+      hr = pRetVal->bstrVal != nullptr ? S_OK : E_OUTOFMEMORY;
       break;
     }
     case UIA_NamePropertyId: {
       pRetVal->vt = VT_BSTR;
-      auto name = props->accessibilityLabel;
-      CComBSTR temp(name.c_str());
-      pRetVal->bstrVal = temp.Detach();
+      auto wideName = ::Microsoft::Common::Unicode::Utf8ToUtf16(
+          props->accessibilityLabel.empty() ? baseView->DefaultAccessibleName() : props->accessibilityLabel);
+      pRetVal->bstrVal = SysAllocString(wideName.c_str());
+      hr = pRetVal->bstrVal != nullptr ? S_OK : E_OUTOFMEMORY;
+      break;
+    }
+    case UIA_IsKeyboardFocusablePropertyId: {
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = props->focusable ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
+    }
+    case UIA_HasKeyboardFocusPropertyId: {
+      auto rootCV = strongView->rootComponentView();
+      if (rootCV == nullptr)
+        return UIA_E_ELEMENTNOTAVAILABLE;
+
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = rootCV->GetFocusedComponent() == strongView.get() ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
+    }
+    case UIA_IsEnabledPropertyId: {
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = !props->accessibilityState.disabled ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
+    }
+    case UIA_IsContentElementPropertyId: {
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = (props->accessible && props->accessibilityRole != "none") ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
+    }
+    case UIA_IsControlElementPropertyId: {
+      pRetVal->vt = VT_BOOL;
+      pRetVal->boolVal = (props->accessible && props->accessibilityRole != "none") ? VARIANT_TRUE : VARIANT_FALSE;
+      break;
+    }
+
+    case UIA_HelpTextPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      auto helpText = props->accessibilityHint.empty()
+          ? ::Microsoft::Common::Unicode::Utf8ToUtf16(baseView->DefaultHelpText())
+          : ::Microsoft::Common::Unicode::Utf8ToUtf16(props->accessibilityHint);
+      pRetVal->bstrVal = SysAllocString(helpText.c_str());
+      hr = pRetVal->bstrVal != nullptr ? S_OK : E_OUTOFMEMORY;
       break;
     }
   }
 
-  return S_OK;
+  return hr;
 }
 
 HRESULT __stdcall CompositionDynamicAutomationProvider::get_HostRawElementProvider(
@@ -224,4 +307,24 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_HostRawElementProvid
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::Invoke() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  auto baseView = std::static_pointer_cast<::Microsoft::ReactNative::CompositionBaseComponentView>(strongView);
+  if (baseView == nullptr)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  baseView.get()->GetEventEmitter().get()->onAccessibilityTap();
+  auto uiaProvider = baseView->EnsureUiaProvider();
+  auto spProviderSimple = uiaProvider.try_as<IRawElementProviderSimple>();
+  if (spProviderSimple != nullptr) {
+    UiaRaiseAutomationEvent(spProviderSimple.get(), UIA_Invoke_InvokedEventId);
+  }
+
+  return S_OK;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -4,6 +4,7 @@
 #include <Fabric/ReactTaggedView.h>
 #include <UIAutomation.h>
 #include <inspectable.h>
+#include <uiautomationcore.h>
 
 namespace winrt::Microsoft::ReactNative::implementation {
 
@@ -11,7 +12,8 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  CompositionDynamicAutomationProvider,
                                                  IInspectable,
                                                  IRawElementProviderFragment,
-                                                 IRawElementProviderSimple> {
+                                                 IRawElementProviderSimple,
+                                                 IInvokeProvider> {
  public:
   CompositionDynamicAutomationProvider(
       const std::shared_ptr<::Microsoft::ReactNative::CompositionBaseComponentView> &componentView) noexcept;
@@ -31,6 +33,9 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall get_HostRawElementProvider(IRawElementProviderSimple **pRetVal) override;
   // virtual HRESULT __stdcall ShowContextMenu() noexcept override;
 
+  // inherited via IInvokeProvider
+  virtual HRESULT __stdcall Invoke() override;
+
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
 };