react-native-windows 0.71.7 → 0.72.0-preview.1

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

@@ -0,0 +1,262 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "SwitchComponentView.h"
+#include "CompositionDynamicAutomationProvider.h"
+
+namespace Microsoft::ReactNative {
+
+SwitchComponentView::SwitchComponentView(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext)
+    : Super(compContext, tag), m_context(reactContext) {
+  m_props = std::make_shared<facebook::react::SwitchProps const>();
+}
+
+std::shared_ptr<SwitchComponentView> SwitchComponentView::Create(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  return std::shared_ptr<SwitchComponentView>(new SwitchComponentView(compContext, tag, reactContext));
+}
+
+void SwitchComponentView::mountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept {
+  assert(false);
+}
+
+void SwitchComponentView::unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept {
+  assert(false);
+}
+
+void SwitchComponentView::handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept {
+  if (commandName == "setValue") {
+    // TODO - Current implementation always aligns with JS value
+    // This will be needed when we move to using WinUI controls
+  } else {
+    Super::handleCommand(commandName, arg);
+  }
+}
+
+void SwitchComponentView::updateProps(
+    facebook::react::Props::Shared const &props,
+    facebook::react::Props::Shared const &oldProps) noexcept {
+  const auto &oldViewProps = *std::static_pointer_cast<const facebook::react::SwitchProps>(m_props);
+  const auto &newViewProps = *std::static_pointer_cast<const facebook::react::SwitchProps>(props);
+
+  ensureVisual();
+
+  if (oldViewProps.backgroundColor != newViewProps.backgroundColor ||
+      oldViewProps.thumbTintColor != newViewProps.thumbTintColor || oldViewProps.value != newViewProps.value ||
+      oldViewProps.disabled != newViewProps.disabled) {
+    m_drawingSurface = nullptr;
+  }
+
+  updateBorderProps(oldViewProps, newViewProps);
+  m_props = std::static_pointer_cast<facebook::react::ViewProps const>(props);
+}
+
+void SwitchComponentView::updateState(
+    facebook::react::State::Shared const &state,
+    facebook::react::State::Shared const &oldState) noexcept {}
+
+void SwitchComponentView::updateLayoutMetrics(
+    facebook::react::LayoutMetrics const &layoutMetrics,
+    facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept {
+  // Set Position & Size Properties
+  ensureVisual();
+
+  if ((layoutMetrics.displayType != m_layoutMetrics.displayType)) {
+    OuterVisual().IsVisible(layoutMetrics.displayType != facebook::react::DisplayType::None);
+  }
+
+  updateBorderLayoutMetrics(layoutMetrics, *m_props);
+  m_layoutMetrics = layoutMetrics;
+
+  UpdateCenterPropertySet();
+  m_visual.Size(
+      {layoutMetrics.frame.size.width * layoutMetrics.pointScaleFactor,
+       layoutMetrics.frame.size.height * layoutMetrics.pointScaleFactor});
+}
+
+void SwitchComponentView::finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept {
+  ensureDrawingSurface();
+}
+
+void SwitchComponentView::Draw() noexcept {
+  // Begin our update of the surface pixels. If this is our first update, we are required
+  // to specify the entire surface, which nullptr is shorthand for (but, as it works out,
+  // any time we make an update we touch the entire surface, so we always pass nullptr).
+  winrt::com_ptr<ID2D1DeviceContext> d2dDeviceContext;
+  POINT offset;
+
+  winrt::com_ptr<Composition::ICompositionDrawingSurfaceInterop> drawingSurfaceInterop;
+  m_drawingSurface.as(drawingSurfaceInterop);
+
+  if (CheckForDeviceRemoved(drawingSurfaceInterop->BeginDraw(d2dDeviceContext.put(), &offset))) {
+    const auto switchProps = std::static_pointer_cast<const facebook::react::SwitchProps>(m_props);
+
+    d2dDeviceContext->Clear(D2D1::ColorF(D2D1::ColorF::Black, 0.0f));
+    if (m_props->backgroundColor) {
+      d2dDeviceContext->Clear(m_props->backgroundColor.AsD2DColor());
+    }
+
+    float offsetX = static_cast<float>(offset.x / m_layoutMetrics.pointScaleFactor);
+    float offsetY = static_cast<float>(offset.y / m_layoutMetrics.pointScaleFactor);
+
+    // https://github.com/microsoft/microsoft-ui-xaml/blob/main/dev/CommonStyles/ToggleSwitch_themeresources.xaml
+    constexpr float thumbMargin = 3.0f;
+    constexpr float thumbRadius = 7.0f;
+    constexpr float trackWidth = 40.0f;
+    constexpr float trackHeight = 20.0f;
+    constexpr float trackCornerRadius = 10.0f;
+
+    auto frame{m_layoutMetrics.frame.size};
+    float trackMarginX = (frame.width - trackWidth) / 2;
+    float trackMarginY = (frame.height - trackHeight) / 2;
+
+    D2D1_RECT_F trackRect = D2D1::RectF(
+        offsetX + trackMarginX,
+        offsetY + trackMarginY,
+        offsetX + trackMarginX + trackWidth,
+        offsetY + trackMarginY + trackHeight);
+
+    // switchProps->value = false
+    float thumbX = trackRect.left + thumbMargin + thumbRadius;
+
+    if (switchProps->value) {
+      thumbX = trackRect.right - thumbMargin - thumbRadius;
+    }
+
+    winrt::com_ptr<ID2D1SolidColorBrush> defaultBrush;
+
+    D2D1_COLOR_F defaultColor =
+        switchProps->disabled ? facebook::react::greyColor().AsD2DColor() : facebook::react::blackColor().AsD2DColor();
+
+    winrt::check_hresult(d2dDeviceContext->CreateSolidColorBrush(defaultColor, defaultBrush.put()));
+
+    winrt::com_ptr<ID2D1SolidColorBrush> thumbBrush;
+    if (!switchProps->disabled && switchProps->thumbTintColor) {
+      winrt::check_hresult(
+          d2dDeviceContext->CreateSolidColorBrush(switchProps->thumbTintColor.AsD2DColor(), thumbBrush.put()));
+    } else {
+      thumbBrush = defaultBrush;
+    }
+
+    const auto dpi = m_layoutMetrics.pointScaleFactor * 96.0f;
+    float oldDpiX, oldDpiY;
+    d2dDeviceContext->GetDpi(&oldDpiX, &oldDpiY);
+    d2dDeviceContext->SetDpi(dpi, dpi);
+
+    // switch track - outline
+    D2D1_ROUNDED_RECT track = D2D1::RoundedRect(trackRect, trackCornerRadius, trackCornerRadius);
+    if ((!switchProps->onTintColor && switchProps->value) || (!switchProps->tintColor && !switchProps->value)) {
+      d2dDeviceContext->DrawRoundedRectangle(track, defaultBrush.get());
+    }
+
+    // switch track - fill
+    winrt::com_ptr<ID2D1SolidColorBrush> trackBrush;
+    if (!switchProps->disabled && switchProps->onTintColor && switchProps->value) {
+      winrt::check_hresult(
+          d2dDeviceContext->CreateSolidColorBrush(switchProps->onTintColor.AsD2DColor(), trackBrush.put()));
+      d2dDeviceContext->FillRoundedRectangle(track, trackBrush.get());
+    } else if (!switchProps->disabled && switchProps->tintColor && !switchProps->value) {
+      winrt::check_hresult(
+          d2dDeviceContext->CreateSolidColorBrush(switchProps->tintColor.AsD2DColor(), trackBrush.put()));
+      d2dDeviceContext->FillRoundedRectangle(track, trackBrush.get());
+    }
+
+    // switch thumb
+    D2D1_POINT_2F thumbCenter = D2D1 ::Point2F(thumbX, (trackRect.top + trackRect.bottom) / 2);
+    D2D1_ELLIPSE thumb = D2D1::Ellipse(thumbCenter, thumbRadius, thumbRadius);
+    d2dDeviceContext->FillEllipse(thumb, thumbBrush.get());
+
+    // Restore old dpi setting
+    d2dDeviceContext->SetDpi(oldDpiX, oldDpiY);
+
+    // Our update is done. EndDraw never indicates rendering device removed, so any
+    // failure here is unexpected and, therefore, fatal.
+    winrt::check_hresult(drawingSurfaceInterop->EndDraw());
+  }
+}
+
+void SwitchComponentView::prepareForRecycle() noexcept {}
+
+facebook::react::Props::Shared SwitchComponentView::props() noexcept {
+  return m_props;
+}
+
+void SwitchComponentView::ensureVisual() noexcept {
+  if (!m_visual) {
+    m_visual = m_compContext.CreateSpriteVisual();
+    OuterVisual().InsertAt(m_visual, 0);
+  }
+}
+
+void SwitchComponentView::ensureDrawingSurface() noexcept {
+  if (!m_drawingSurface) {
+    winrt::Windows::Foundation::Size surfaceSize = {
+        m_layoutMetrics.frame.size.width * m_layoutMetrics.pointScaleFactor,
+        m_layoutMetrics.frame.size.height * m_layoutMetrics.pointScaleFactor};
+    m_drawingSurface = m_compContext.CreateDrawingSurface(
+        surfaceSize,
+        winrt::Windows::Graphics::DirectX::DirectXPixelFormat::B8G8R8A8UIntNormalized,
+        winrt::Windows::Graphics::DirectX::DirectXAlphaMode::Premultiplied);
+
+    Draw();
+
+    auto surfaceBrush = m_compContext.CreateSurfaceBrush(m_drawingSurface);
+
+    m_visual.Brush(surfaceBrush);
+  }
+}
+
+facebook::react::Tag SwitchComponentView::hitTest(facebook::react::Point pt, facebook::react::Point &localPt)
+    const noexcept {
+  facebook::react::Point ptLocal{pt.x - m_layoutMetrics.frame.origin.x, pt.y - m_layoutMetrics.frame.origin.y};
+
+  if ((m_props->pointerEvents == facebook::react::PointerEventsMode::Auto ||
+       m_props->pointerEvents == facebook::react::PointerEventsMode::BoxOnly) &&
+      ptLocal.x >= 0 && ptLocal.x <= m_layoutMetrics.frame.size.width && ptLocal.y >= 0 &&
+      ptLocal.y <= m_layoutMetrics.frame.size.height) {
+    localPt = ptLocal;
+    return tag();
+  }
+
+  return -1;
+}
+
+winrt::Microsoft::ReactNative::Composition::IVisual SwitchComponentView::Visual() const noexcept {
+  return m_visual;
+}
+
+int64_t SwitchComponentView::sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
+  switch (msg) {
+    case WM_LBUTTONDOWN:
+    case WM_POINTERDOWN: {
+      const auto switchProps = std::static_pointer_cast<const facebook::react::SwitchProps>(m_props);
+
+      if (!switchProps->disabled && m_eventEmitter) {
+        auto switchEventEmitter = std::static_pointer_cast<facebook::react::SwitchEventEmitter const>(m_eventEmitter);
+
+        facebook::react::SwitchEventEmitter::OnChange args;
+        args.value = !(switchProps->value);
+        args.target = tag();
+
+        switchEventEmitter->onChange(args);
+      }
+      break;
+    }
+  }
+
+  return 0;
+}
+
+bool SwitchComponentView::focusable() const noexcept {
+  return m_props->focusable;
+}
+
+} // namespace Microsoft::ReactNative

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

@@ -0,0 +1,62 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/ComponentView.h>
+#include <Microsoft.ReactNative.Cxx/ReactContext.h>
+
+#include "CompositionViewComponentView.h"
+
+#include <react/components/rnwcore/ShadowNodes.h>
+
+namespace Microsoft::ReactNative {
+
+struct SwitchComponentView;
+
+struct SwitchComponentView : CompositionBaseComponentView {
+  using Super = CompositionBaseComponentView;
+
+  [[nodiscard]] static std::shared_ptr<SwitchComponentView> Create(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
+
+  void mountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
+  void unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
+  void handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept override;
+  void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
+      override;
+  void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
+      override;
+  void updateLayoutMetrics(
+      facebook::react::LayoutMetrics const &layoutMetrics,
+      facebook::react::LayoutMetrics const &oldLayoutMetrics) noexcept override;
+  void finalizeUpdates(RNComponentViewUpdateMask updateMask) noexcept override;
+  void prepareForRecycle() noexcept override;
+  facebook::react::Props::Shared props() noexcept override;
+  bool focusable() const noexcept override;
+
+  facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
+  winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
+  int64_t sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept override;
+
+ private:
+  SwitchComponentView(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext);
+
+  void ensureVisual() noexcept;
+  void Draw() noexcept;
+  void ensureDrawingSurface() noexcept;
+
+  facebook::react::Size m_contentSize;
+  winrt::Microsoft::ReactNative::Composition::SpriteVisual m_visual{nullptr};
+  winrt::Microsoft::ReactNative::ReactContext m_context;
+  facebook::react::SharedViewProps m_props;
+  winrt::Microsoft::ReactNative::Composition::ICompositionDrawingSurface m_drawingSurface;
+};
+
+} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.cpp

@@ -6,11 +6,13 @@
 
 #include "WindowsTextInputComponentView.h"
 
+#include <Fabric/Composition/CompositionDynamicAutomationProvider.h>
 #include <Utils/ValueUtils.h>
 #include <tom.h>
 #include <unicode.h>
 #include <winrt/Windows.UI.h>
 #include "../CompositionHelpers.h"
+#include "../RootComponentView.h"
 #include "WindowsTextInputShadowNode.h"
 #include "WindowsTextInputState.h"
 #include "guid/msoGuid.h"
@@ -214,7 +216,7 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Set the focus to the text window
   void TxSetFocus() override {
-    SetFocusedComponent(m_outer);
+    m_outer->rootComponentView()->SetFocusedComponent(m_outer);
     // assert(false);
     // TODO focus
   }
@@ -540,7 +542,19 @@ void WindowsTextInputComponentView::handleCommand(std::string const &commandName
   }
 }
 
-int64_t WindowsTextInputComponentView::SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
+int64_t WindowsTextInputComponentView::sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
+  // Do not forward tab keys into the TextInput, since we want that to do the tab loop instead.  This aligns with WinUI
+  // behavior We do forward Ctrl+Tab to the textinput.
+  if (((msg == WM_KEYDOWN || msg == WM_KEYUP) && wParam == VK_TAB) || (msg == WM_CHAR && wParam == '\t')) {
+    BYTE bKeys[256];
+    if (GetKeyboardState(bKeys)) {
+      bool fCtrl = false;
+      if (!(bKeys[VK_LCONTROL] & 0x80 || bKeys[VK_RCONTROL] & 0x80)) {
+        return 0;
+      }
+    }
+  }
+
   if (m_textServices) {
     LRESULT lresult;
     DrawBlock db(*this);
@@ -549,31 +563,18 @@ int64_t WindowsTextInputComponentView::SendMessage(uint32_t msg, uint64_t wParam
       return lresult;
     }
   }
-  return Super::SendMessage(msg, wParam, lParam);
-}
-
-std::vector<facebook::react::ComponentDescriptorProvider>
-WindowsTextInputComponentView::supplementalComponentDescriptorProviders() noexcept {
-  return {};
-}
-
-void WindowsTextInputComponentView::parent(IComponentView *parent) noexcept {
-  Super::parent(parent);
-
-  if (!parent && GetFocusedComponent() == this) {
-    SetFocusedComponent(nullptr); // TODO need move focus logic - where should focus go?
-  }
+  return Super::sendMessage(msg, wParam, lParam);
 }
 
 void WindowsTextInputComponentView::mountChildComponentView(
-    const IComponentView &childComponentView,
+    IComponentView &childComponentView,
     uint32_t index) noexcept {
   assert(false);
   // m_element.Children().InsertAt(index, v.Element());
 }
 
 void WindowsTextInputComponentView::unmountChildComponentView(
-    const IComponentView &childComponentView,
+    IComponentView &childComponentView,
     uint32_t index) noexcept {
   assert(false);
   // m_element.Children().RemoveAt(index);
@@ -581,12 +582,16 @@ void WindowsTextInputComponentView::unmountChildComponentView(
 
 void WindowsTextInputComponentView::onFocusLost() noexcept {
   Super::onFocusLost();
-  SendMessage(WM_KILLFOCUS, 0, 0);
+  sendMessage(WM_KILLFOCUS, 0, 0);
 }
 
 void WindowsTextInputComponentView::onFocusGained() noexcept {
   Super::onFocusGained();
-  SendMessage(WM_SETFOCUS, 0, 0);
+  sendMessage(WM_SETFOCUS, 0, 0);
+}
+
+bool WindowsTextInputComponentView::focusable() const noexcept {
+  return m_props->focusable;
 }
 
 void WindowsTextInputComponentView::updateProps(
@@ -755,7 +760,7 @@ void WindowsTextInputComponentView::updateLayoutMetrics(
   // Set Position & Size Properties
 
   if ((layoutMetrics.displayType != m_layoutMetrics.displayType)) {
-    m_visual.IsVisible(layoutMetrics.displayType != facebook::react::DisplayType::None);
+    OuterVisual().IsVisible(layoutMetrics.displayType != facebook::react::DisplayType::None);
   }
 
   if ((layoutMetrics.pointScaleFactor != m_layoutMetrics.pointScaleFactor)) {
@@ -786,11 +791,6 @@ void WindowsTextInputComponentView::updateLayoutMetrics(
   m_visual.Size(
       {layoutMetrics.frame.size.width * layoutMetrics.pointScaleFactor,
        layoutMetrics.frame.size.height * layoutMetrics.pointScaleFactor});
-  m_visual.Offset({
-      layoutMetrics.frame.origin.x * layoutMetrics.pointScaleFactor,
-      layoutMetrics.frame.origin.y * layoutMetrics.pointScaleFactor,
-      0.0f,
-  });
 }
 
 // When we are notified by RichEdit that the text changed, we need to notify JS
@@ -1048,10 +1048,6 @@ facebook::react::Tag WindowsTextInputComponentView::hitTest(facebook::react::Poi
   return -1;
 }
 
-facebook::react::SharedTouchEventEmitter WindowsTextInputComponentView::touchEventEmitter() noexcept {
-  return m_eventEmitter;
-}
-
 void WindowsTextInputComponentView::ensureVisual() noexcept {
   if (!m_visual) {
     HrEnsureRichEd20Loaded();
@@ -1060,6 +1056,7 @@ void WindowsTextInputComponentView::ensureVisual() noexcept {
     winrt::com_ptr<IUnknown> spUnk;
     winrt::check_hresult(g_pfnCreateTextServices(nullptr, m_textHost.get(), spUnk.put()));
     spUnk.as(m_textServices);
+    OuterVisual().InsertAt(m_visual, 0);
   }
 
   if (!m_caretVisual) {
@@ -1073,4 +1070,12 @@ winrt::Microsoft::ReactNative::Composition::IVisual WindowsTextInputComponentVie
   return m_visual;
 }
 
+std::shared_ptr<WindowsTextInputComponentView> WindowsTextInputComponentView::Create(
+    const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+    facebook::react::Tag tag,
+    winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept {
+  return std::shared_ptr<WindowsTextInputComponentView>(
+      new WindowsTextInputComponentView(compContext, tag, reactContext));
+}
+
 } // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputComponentView.h

@@ -24,15 +24,13 @@ struct WindowsTextInputComponentView : CompositionBaseComponentView {
   friend CompTextHost;
 
   using Super = CompositionBaseComponentView;
-  WindowsTextInputComponentView(
+  [[nodiscard]] static std::shared_ptr<WindowsTextInputComponentView> Create(
       const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
       facebook::react::Tag tag,
-      winrt::Microsoft::ReactNative::ReactContext const &reactContext);
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext) noexcept;
 
-  std::vector<facebook::react::ComponentDescriptorProvider> supplementalComponentDescriptorProviders() noexcept
-      override;
-  void mountChildComponentView(const IComponentView &childComponentView, uint32_t index) noexcept override;
-  void unmountChildComponentView(const IComponentView &childComponentView, uint32_t index) noexcept override;
+  void mountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
+  void unmountChildComponentView(IComponentView &childComponentView, uint32_t index) noexcept override;
   void updateProps(facebook::react::Props::Shared const &props, facebook::react::Props::Shared const &oldProps) noexcept
       override;
   void updateState(facebook::react::State::Shared const &state, facebook::react::State::Shared const &oldState) noexcept
@@ -44,16 +42,20 @@ struct WindowsTextInputComponentView : CompositionBaseComponentView {
   void prepareForRecycle() noexcept override;
   facebook::react::Props::Shared props() noexcept override;
   void handleCommand(std::string const &commandName, folly::dynamic const &arg) noexcept override;
-  int64_t SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept override;
+  int64_t sendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept override;
   facebook::react::Tag hitTest(facebook::react::Point pt, facebook::react::Point &localPt) const noexcept override;
-  void parent(IComponentView *parent) noexcept override;
   void OnRenderingDeviceLost() noexcept override;
   winrt::Microsoft::ReactNative::Composition::IVisual Visual() const noexcept override;
   void onFocusLost() noexcept override;
   void onFocusGained() noexcept override;
-  facebook::react::SharedTouchEventEmitter touchEventEmitter() noexcept override;
+  bool focusable() const noexcept override;
 
  private:
+  WindowsTextInputComponentView(
+      const winrt::Microsoft::ReactNative::Composition::ICompositionContext &compContext,
+      facebook::react::Tag tag,
+      winrt::Microsoft::ReactNative::ReactContext const &reactContext);
+
   struct DrawBlock {
     DrawBlock(WindowsTextInputComponentView &view);
     ~DrawBlock();

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputProps.cpp

@@ -48,4 +48,13 @@ WindowsTextInputProps::WindowsTextInputProps(
       submitKeyEvents(convertRawProp(context, rawProps, "submitKeyEvents", sourceProps.submitKeyEvents, {})),
       autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})) {}
 
+void WindowsTextInputProps::setProp(
+    const PropsParserContext &context,
+    RawPropsPropNameHash hash,
+    const char *propName,
+    RawValue const &value) {
+  BaseTextProps::setProp(context, hash, propName, value);
+  ViewProps::setProp(context, hash, propName, value);
+}
+
 } // namespace facebook::react

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputProps.h

@@ -92,6 +92,9 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
       const WindowsTextInputProps &sourceProps,
       const RawProps &rawProps);
 
+  void
+  setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, RawValue const &value);
+
   bool allowFontScaling{true};
   bool clearTextOnFocus{false};
   bool editable{true};

package/Microsoft.ReactNative/Fabric/Composition/TextInput/WindowsTextInputShadowNode.cpp

@@ -183,7 +183,8 @@ Size WindowsTextInputShadowNode::measureContent(
       ->measure(
           AttributedStringBox{attributedString},
           {}, // TODO getConcreteProps().paragraphAttributes,
-          layoutConstraints)
+          layoutConstraints,
+          nullptr)
       .size;
 }
 

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

@@ -0,0 +1,72 @@
+#include "pch.h"
+#include "UiaHelpers.h"
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <inspectable.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+HRESULT UiaNavigateHelper(
+    ::Microsoft::ReactNative::ReactTaggedView &view,
+    NavigateDirection direction,
+    IRawElementProviderFragment *&retVal) noexcept {
+  retVal = nullptr;
+
+  auto spComponentView = view.view();
+
+  if (!spComponentView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  winrt::IInspectable uiaProvider{nullptr};
+
+  switch (direction) {
+    case NavigateDirection_Parent: {
+      auto pParentCV = static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(spComponentView->parent());
+      if (pParentCV != nullptr) {
+        uiaProvider = pParentCV->EnsureUiaProvider();
+      }
+    } break;
+
+    case NavigateDirection_LastChild:
+      __fallthrough;
+
+    case NavigateDirection_FirstChild: {
+      auto children = spComponentView->children();
+      auto index = direction == NavigateDirection_FirstChild ? 0 : children.size() - 1;
+      if (!children.empty()) {
+        uiaProvider =
+            static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(children[index])->EnsureUiaProvider();
+      }
+    } break;
+
+    case NavigateDirection_NextSibling: {
+      auto pParentCV = static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(spComponentView->parent());
+      if (pParentCV != nullptr) {
+        auto children = pParentCV->children();
+        auto it = std::find(children.begin(), children.end(), spComponentView.get());
+        if (++it != children.end()) {
+          uiaProvider = static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(*it)->EnsureUiaProvider();
+        }
+      }
+    } break;
+
+    case NavigateDirection_PreviousSibling: {
+      auto pParentCV = static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(spComponentView->parent());
+      if (pParentCV != nullptr) {
+        auto children = pParentCV->children();
+        auto it = std::find(children.rbegin(), children.rend(), spComponentView.get());
+        if (++it != children.rend()) {
+          uiaProvider = static_cast<::Microsoft::ReactNative::CompositionBaseComponentView *>(*it)->EnsureUiaProvider();
+        }
+      }
+    } break;
+  }
+
+  if (uiaProvider != nullptr) {
+    winrt::com_ptr<IRawElementProviderFragment> spFragment;
+    uiaProvider.as(spFragment);
+    retVal = spFragment.detach();
+  }
+  return S_OK;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <Fabric/ComponentView.h>
+#include <Fabric/ReactTaggedView.h>
+#include <UIAutomation.h>
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+// Returns an AddRef'd neighbor of the provided IComponentView in the direction given
+HRESULT
+UiaNavigateHelper(
+    ::Microsoft::ReactNative::ReactTaggedView &view,
+    NavigateDirection direction,
+    IRawElementProviderFragment *&retVal) noexcept;
+
+} // namespace winrt::Microsoft::ReactNative::implementation