react-native-windows 0.76.1 → 0.76.3

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

@@ -0,0 +1,80 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/ComponentView.h>
+#include <Microsoft.ReactNative.Cxx/ReactContext.h>
+#include <react/renderer/components/view/ViewEventEmitter.h>
+#include <react/renderer/components/view/ViewProps.h>
+#include "CompositionHelpers.h"
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+struct ComponentView;
+
+// Controls adding/removing appropriate visuals to a parent to render a specific border without requiring
+struct BorderPrimitive {
+  static constexpr size_t SpecialBorderLayerCount = 8;
+
+  // Use when attaching to an existing visual - We do this for View's border properties, to optimize the number of
+  // visuals for each view.
+  BorderPrimitive(
+      winrt::Microsoft::ReactNative::Composition::implementation::ComponentView &outer,
+      const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &rootVisual);
+
+  // This ctor creates a new root visual that can then be added to the visual tree
+  BorderPrimitive(winrt::Microsoft::ReactNative::Composition::implementation::ComponentView &outer);
+
+  void markNeedsUpdate() noexcept;
+
+  // We hoist focus visuals up the tree to allow them to be higher in the z-order.
+  // This means a single BorderPrimitive may change the owning ComponentView as focus moves around
+  void setOuter(winrt::Microsoft::ReactNative::Composition::implementation::ComponentView *outer) noexcept;
+
+  void updateProps(
+      const facebook::react::ViewProps &oldViewProps,
+      const facebook::react::ViewProps &newViewProps) noexcept;
+  void finalize(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      const facebook::react::BorderMetrics &borderMetrics) noexcept;
+  void onThemeChanged(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      const facebook::react::BorderMetrics &borderMetrics) noexcept;
+
+  uint8_t numberOfVisuals() const noexcept;
+  winrt::Microsoft::ReactNative::Composition::Experimental::IVisual RootVisual() const noexcept;
+
+  static facebook::react::BorderMetrics resolveAndAlignBorderMetrics(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      const facebook::react::ViewProps &viewProps) noexcept;
+
+  static bool requiresBorder(
+      const facebook::react::BorderMetrics &borderMetrics,
+      winrt::Microsoft::ReactNative::Composition::implementation::Theme *theme) noexcept;
+
+  static winrt::com_ptr<ID2D1PathGeometry> GenerateRoundedRectPathGeometry(
+      winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
+      const facebook::react::RectangleCorners<facebook::react::CornerRadii> &baseRadius,
+      const facebook::react::RectangleEdges<float> &inset,
+      const facebook::react::RectangleEdges<float> &rectPathGeometry) noexcept;
+
+ private:
+  std::array<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual, SpecialBorderLayerCount>
+  FindSpecialBorderLayers() const noexcept;
+
+  bool TryUpdateSpecialBorderLayers(
+      winrt::Microsoft::ReactNative::Composition::implementation::Theme *theme,
+      std::array<winrt::Microsoft::ReactNative::Composition::Experimental::ISpriteVisual, SpecialBorderLayerCount>
+          &spBorderVisuals,
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      const facebook::react::BorderMetrics &borderMetrics) noexcept;
+
+  uint8_t m_numBorderVisuals{0};
+  winrt::Microsoft::ReactNative::Composition::implementation::ComponentView *m_outer;
+  winrt::Microsoft::ReactNative::Composition::Experimental::IVisual m_rootVisual{nullptr};
+  bool m_needsUpdate{true};
+};
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -1,6 +1,8 @@
 #include "pch.h"
 #include "CompositionDynamicAutomationProvider.h"
 #include <Fabric/ComponentView.h>
+#include <Fabric/Composition/SwitchComponentView.h>
+#include <Fabric/Composition/TextInput/WindowsTextInputComponentView.h>
 #include <Unicode.h>
 #include "RootComponentView.h"
 #include "UiaHelpers.h"
@@ -141,6 +143,20 @@ bool expandableControl(const facebook::react::SharedViewProps props) {
   return false;
 }
 
+bool togglableControl(const facebook::react::SharedViewProps props) {
+  if (props->accessibilityState.has_value() &&
+      props->accessibilityState->checked != facebook::react::AccessibilityState::None) {
+    return true;
+  }
+  auto accessibilityActions = props->accessibilityActions;
+  for (size_t i = 0; i < accessibilityActions.size(); i++) {
+    if (accessibilityActions[i].name == "toggle") {
+      return true;
+    }
+  }
+  return false;
+}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
@@ -188,7 +204,9 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
-  if (patternId == UIA_TogglePatternId && (accessibilityRole == "switch" || accessibilityRole == "checkbox")) {
+  if (patternId == UIA_TogglePatternId &&
+      (strongView.try_as<winrt::Microsoft::ReactNative::Composition::implementation::SwitchComponentView>() ||
+       togglableControl(props))) {
     *pRetVal = static_cast<IToggleProvider *>(this);
     AddRef();
   }
@@ -508,8 +526,13 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_ToggleState(ToggleSt
   if (!strongView)
     return UIA_E_ELEMENTNOTAVAILABLE;
 
-  *pRetVal =
-      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->getToggleState();
+  auto props = std::static_pointer_cast<const facebook::react::ViewProps>(
+      winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->props());
+
+  *pRetVal = (props->accessibilityState.has_value() &&
+              props->accessibilityState->checked != facebook::react::AccessibilityState::None)
+      ? GetToggleState(props->accessibilityState)
+      : winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(strongView)->getToggleState();
   return S_OK;
 }
 

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

@@ -12,15 +12,18 @@
 #include <Views/ShadowNodeBase.h>
 #include <windows.h>
 #include <windowsx.h>
+#include <winrt/Windows.UI.Core.h>
 #include <winrt/Windows.UI.Input.h>
 #include "Composition.Input.h"
 #include "CompositionViewComponentView.h"
 #include "ReactNativeIsland.h"
 #include "RootComponentView.h"
 
-#ifdef USE_WINUI3
-#include <winrt/Microsoft.UI.Input.h>
-#endif
+namespace ABI::Microsoft::UI::Input {
+struct IInputCursor;
+}
+
+#include <Microsoft.UI.Input.InputCursor.Interop.h>
 
 namespace Microsoft::ReactNative {
 
@@ -139,8 +142,9 @@ struct CompositionInputKeyboardSource : winrt::implements<
 
 CompositionEventHandler::CompositionEventHandler(
     const winrt::Microsoft::ReactNative::ReactContext &context,
-    const winrt::Microsoft::ReactNative::ReactNativeIsland &reactNativeIsland)
-    : m_context(context), m_wkRootView(reactNativeIsland) {}
+    const winrt::Microsoft::ReactNative::ReactNativeIsland &reactNativeIsland,
+    const int fragmentTag)
+    : m_fragmentTag(fragmentTag), m_context(context), m_wkRootView(reactNativeIsland) {}
 
 void CompositionEventHandler::Initialize() noexcept {
 #ifdef USE_WINUI3
@@ -327,6 +331,11 @@ CompositionEventHandler::~CompositionEventHandler() {
     }
   }
 #endif
+
+  if (m_hcursorOwned) {
+    ::DestroyCursor(m_hcursor);
+    m_hcursor = nullptr;
+  }
 }
 
 facebook::react::SurfaceId CompositionEventHandler::SurfaceId() const noexcept {
@@ -506,6 +515,10 @@ int64_t CompositionEventHandler::SendMessage(HWND hwnd, uint32_t msg, uint64_t w
       }
       break;
     }
+    case WM_SETCURSOR: {
+      UpdateCursor();
+      return 1;
+    }
   }
 
   return 0;
@@ -752,6 +765,151 @@ void CompositionEventHandler::HandleIncomingPointerEvent(
     hoveredViews.emplace_back(ReactTaggedView(componentViewDescriptor.view));
   }
   m_currentlyHoveredViewsPerPointer[pointerId] = std::move(hoveredViews);
+
+  if (IsMousePointerEvent(event)) {
+    UpdateCursor();
+  }
+}
+
+void CompositionEventHandler::UpdateCursor() noexcept {
+  for (auto &taggedView : m_currentlyHoveredViewsPerPointer[MOUSE_POINTER_ID]) {
+    if (auto view = taggedView.view()) {
+      if (auto viewcomponent =
+              view.try_as<winrt::Microsoft::ReactNative::Composition::implementation::ComponentView>()) {
+        auto cursorInfo = viewcomponent->cursor();
+        if (cursorInfo.first != facebook::react::Cursor::Auto || cursorInfo.second != nullptr) {
+          SetCursor(cursorInfo.first, cursorInfo.second);
+          return;
+        }
+      }
+    }
+  }
+
+  SetCursor(facebook::react::Cursor::Auto, nullptr);
+}
+
+void CompositionEventHandler::SetCursor(facebook::react::Cursor cursor, HCURSOR hcur) noexcept {
+  if (m_currentCursor == cursor && m_hcursor == hcur)
+    return;
+
+  if (auto strongRootView = m_wkRootView.get()) {
+    if (auto island = strongRootView.Island()) {
+      auto pointerSource = winrt::Microsoft::UI::Input::InputPointerSource::GetForIsland(island);
+
+      if (!hcur) {
+        winrt::Windows::UI::Core::CoreCursorType type = winrt::Windows::UI::Core::CoreCursorType::Arrow;
+        switch (cursor) {
+          case facebook::react::Cursor::Pointer:
+            type = winrt::Windows::UI::Core::CoreCursorType::Hand;
+            break;
+          case facebook::react::Cursor::Help:
+            type = winrt::Windows::UI::Core::CoreCursorType::Help;
+            break;
+          case facebook::react::Cursor::NotAllowed:
+            type = winrt::Windows::UI::Core::CoreCursorType::UniversalNo;
+            break;
+          case facebook::react::Cursor::Wait:
+            type = winrt::Windows::UI::Core::CoreCursorType::Wait;
+            break;
+          case facebook::react::Cursor::Move:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeAll;
+            break;
+          case facebook::react::Cursor::NESWResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNortheastSouthwest;
+            break;
+          case facebook::react::Cursor::NSResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthSouth;
+            break;
+          case facebook::react::Cursor::NWSEResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeNorthwestSoutheast;
+            break;
+          case facebook::react::Cursor::EWResize:
+            type = winrt::Windows::UI::Core::CoreCursorType::SizeWestEast;
+            break;
+          case facebook::react::Cursor::Text:
+            type = winrt::Windows::UI::Core::CoreCursorType::IBeam;
+            break;
+          case facebook::react::Cursor::Progress:
+            type = winrt::Windows::UI::Core::CoreCursorType::Wait; // IDC_APPSTARTING not mapped to CoreCursor?
+            break;
+          case facebook::react::Cursor::Crosshair:
+            type = winrt::Windows::UI::Core::CoreCursorType::Cross;
+            break;
+          default:
+            break;
+        }
+
+        m_inputCursor = winrt::Microsoft::UI::Input::InputCursor::CreateFromCoreCursor(
+            winrt::Windows::UI::Core::CoreCursor(type, 0));
+        m_hcursor = hcur;
+      } else {
+        auto cursorInterop = winrt::get_activation_factory<
+            winrt::Microsoft::UI::Input::InputCursor,
+            ABI::Microsoft::UI::Input::IInputCursorStaticsInterop>();
+        winrt::com_ptr<IUnknown> spunk;
+        winrt::check_hresult(cursorInterop->CreateFromHCursor(
+            hcur, reinterpret_cast<ABI::Microsoft::UI::Input::IInputCursor **>(spunk.put_void())));
+        m_hcursor = hcur;
+        m_inputCursor = spunk.as<winrt::Microsoft::UI::Input::InputCursor>();
+      }
+
+      pointerSource.Cursor(m_inputCursor);
+    } else {
+      if (m_hcursorOwned) {
+        ::DestroyCursor(m_hcursor);
+        m_hcursorOwned = false;
+      }
+      if (hcur == nullptr) {
+        const WCHAR *idc = IDC_ARROW;
+        switch (cursor) {
+          case facebook::react::Cursor::Pointer:
+            idc = IDC_HAND;
+            break;
+          case facebook::react::Cursor::Help:
+            idc = IDC_HELP;
+            break;
+          case facebook::react::Cursor::NotAllowed:
+            idc = IDC_NO;
+            break;
+          case facebook::react::Cursor::Wait:
+            idc = IDC_WAIT;
+            break;
+          case facebook::react::Cursor::Move:
+            idc = IDC_SIZEALL;
+            break;
+          case facebook::react::Cursor::NESWResize:
+            idc = IDC_SIZENESW;
+            break;
+          case facebook::react::Cursor::NSResize:
+            idc = IDC_SIZENS;
+            break;
+          case facebook::react::Cursor::NWSEResize:
+            idc = IDC_SIZENWSE;
+            break;
+          case facebook::react::Cursor::EWResize:
+            idc = IDC_SIZEWE;
+            break;
+          case facebook::react::Cursor::Text:
+            idc = IDC_IBEAM;
+            break;
+          case facebook::react::Cursor::Progress:
+            idc = IDC_APPSTARTING;
+            break;
+          case facebook::react::Cursor::Crosshair:
+            idc = IDC_CROSS;
+            break;
+          default:
+            break;
+        }
+        m_hcursor = ::LoadCursor(nullptr, idc);
+        m_hcursorOwned = true;
+      } else {
+        m_hcursor = hcur;
+      }
+      ::SetCursor(m_hcursor);
+    }
+    m_currentCursor = cursor;
+  }
 }
 
 void CompositionEventHandler::UpdateActiveTouch(
@@ -831,7 +989,30 @@ void CompositionEventHandler::getTargetPointerArgs(
       ptLocal.y = ptScaled.y - (clientRect.top / strongRootView.ScaleFactor());
     }
   } else {
-    tag = RootComponentView().hitTest(ptScaled, ptLocal);
+    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;
+      }
+    }
   }
 }
 

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

@@ -31,7 +31,8 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
  public:
   CompositionEventHandler(
       const winrt::Microsoft::ReactNative::ReactContext &context,
-      const winrt::Microsoft::ReactNative::ReactNativeIsland &ReactNativeIsland);
+      const winrt::Microsoft::ReactNative::ReactNativeIsland &ReactNativeIsland,
+      const int fragmentTag);
   virtual ~CompositionEventHandler();
 
   void Initialize() noexcept;
@@ -146,8 +147,12 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
   static void
   UpdateActiveTouch(ActiveTouch &activeTouch, facebook::react::Point ptScaled, facebook::react::Point ptLocal) noexcept;
 
+  void UpdateCursor() noexcept;
+  void SetCursor(facebook::react::Cursor cursor, HCURSOR hcur) noexcept;
+
   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;
@@ -155,6 +160,10 @@ class CompositionEventHandler : public std::enable_shared_from_this<CompositionE
 
   facebook::react::Tag m_pointerCapturingComponentTag{-1}; // Component that has captured input
   std::vector<PointerId> m_capturedPointers;
+  HCURSOR m_hcursor{nullptr};
+  bool m_hcursorOwned{false}; // If we create the cursor, so we need to destroy it
+  facebook::react::Cursor m_currentCursor{facebook::react::Cursor::Auto};
+  winrt::Microsoft::UI::Input::InputCursor m_inputCursor{nullptr};
 
 #ifdef USE_WINUI3
   winrt::event_token m_pointerPressedToken;

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

@@ -189,40 +189,16 @@ HRESULT __stdcall CompositionRootAutomationProvider::ElementProviderFromPoint(
   *pRetVal = nullptr;
 
   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;
+    auto local = rootView->ConvertScreenToLocal({static_cast<float>(x), static_cast<float>(y)});
+    auto provider = rootView->UiaProviderFromPoint(
+        {static_cast<LONG>(local.X * rootView->LayoutMetrics().PointScaleFactor),
+         static_cast<LONG>(local.Y * rootView->LayoutMetrics().PointScaleFactor)});
+    auto spFragment = provider.try_as<IRawElementProviderFragment>();
+    if (spFragment) {
+      *pRetVal = spFragment.detach();
     }
-#endif
 
-    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;
-      }
-    }
+    return S_OK;
   }
 
   AddRef();