react-native-windows 0.78.5 → 0.78.6

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

@@ -116,25 +116,25 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Show the scroll bar
   BOOL TxShowScrollBar(INT fnBar, BOOL fShow) override {
-    assert(false);
+    // assert(false);
     return {};
   }
 
   //@cmember Enable the scroll bar
   BOOL TxEnableScrollBar(INT fuSBFlags, INT fuArrowflags) override {
-    assert(false);
+    // assert(false);
     return {};
   }
 
   //@cmember Set the scroll range
   BOOL TxSetScrollRange(INT fnBar, LONG nMinPos, INT nMaxPos, BOOL fRedraw) override {
-    assert(false);
+    // assert(false);
     return {};
   }
 
   //@cmember Set the scroll position
   BOOL TxSetScrollPos(INT fnBar, INT nPos, BOOL fRedraw) override {
-    assert(false);
+    // assert(false);
     return {};
   }
 
@@ -377,8 +377,11 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
 
   //@cmember Get the bits representing requested scroll bars for the window
   HRESULT TxGetScrollBars(DWORD *pdwScrollBar) override {
-    // TODO support scrolling
-    *pdwScrollBar = 0;
+    if (m_outer->m_multiline) {
+      *pdwScrollBar = WS_VSCROLL | WS_HSCROLL | ES_AUTOVSCROLL | ES_AUTOHSCROLL;
+    } else {
+      *pdwScrollBar = WS_HSCROLL | ES_AUTOHSCROLL;
+    }
     return S_OK;
   }
 
@@ -460,6 +463,13 @@ struct CompTextHost : public winrt::implements<CompTextHost, ITextHost> {
   WindowsTextInputComponentView *m_outer;
 };
 
+int WINAPI
+AutoCorrectOffCallback(LANGID langid, const WCHAR *pszBefore, WCHAR *pszAfter, LONG cchAfter, LONG *pcchReplaced) {
+  wcsncpy_s(pszAfter, cchAfter, pszBefore, _TRUNCATE);
+  *pcchReplaced = static_cast<LONG>(wcslen(pszAfter));
+  return ATP_CHANGE;
+}
+
 facebook::react::AttributedString WindowsTextInputComponentView::getAttributedString() const {
   // Use BaseTextShadowNode to get attributed string from children
 
@@ -611,6 +621,19 @@ WPARAM PointerRoutedEventArgsToMouseWParam(
   return wParam;
 }
 
+bool WindowsTextInputComponentView::IsDoubleClick() {
+  using namespace std::chrono;
+
+  auto now = steady_clock::now();
+  auto duration = duration_cast<milliseconds>(now - m_lastClickTime).count();
+
+  const int DOUBLE_CLICK_TIME_MS = ::GetDoubleClickTime();
+
+  m_lastClickTime = now;
+
+  return (duration < DOUBLE_CLICK_TIME_MS);
+}
+
 void WindowsTextInputComponentView::OnPointerPressed(
     const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
   UINT msg = 0;
@@ -627,7 +650,11 @@ void WindowsTextInputComponentView::OnPointerPressed(
   if (pp.PointerDeviceType() == winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse) {
     switch (pp.Properties().PointerUpdateKind()) {
       case winrt::Microsoft::ReactNative::Composition::Input::PointerUpdateKind::LeftButtonPressed:
-        msg = WM_LBUTTONDOWN;
+        if (IsDoubleClick()) {
+          msg = WM_LBUTTONDBLCLK;
+        } else {
+          msg = WM_LBUTTONDOWN;
+        }
         break;
       case winrt::Microsoft::ReactNative::Composition::Input::PointerUpdateKind::MiddleButtonPressed:
         msg = WM_MBUTTONDOWN;
@@ -656,6 +683,24 @@ void WindowsTextInputComponentView::OnPointerPressed(
     auto hr = m_textServices->TxSendMessage(msg, static_cast<WPARAM>(wParam), static_cast<LPARAM>(lParam), &lresult);
     args.Handled(hr != S_FALSE);
   }
+
+  // Emits the OnPressIn event
+  if (m_eventEmitter && !m_comingFromJS) {
+    auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
+    float offsetX = position.X - m_layoutMetrics.frame.origin.x;
+    float offsetY = position.Y - m_layoutMetrics.frame.origin.y;
+    float neutralX = m_layoutMetrics.frame.origin.x;
+    float neutralY = m_layoutMetrics.frame.origin.y;
+
+    facebook::react::PressEvent pressInArgs;
+    pressInArgs.target = m_tag;
+    pressInArgs.pagePoint = {position.X, position.Y};
+    pressInArgs.offsetPoint = {offsetX, offsetY}; //{LocationX,LocationY}
+    pressInArgs.timestamp = static_cast<double>(pp.Timestamp()) / 1000.0;
+    pressInArgs.identifier = pp.PointerId();
+
+    emitter->onPressIn(pressInArgs);
+  }
 }
 
 void WindowsTextInputComponentView::OnPointerReleased(
@@ -928,8 +973,25 @@ void WindowsTextInputComponentView::onLostFocus(
     LRESULT lresult;
     DrawBlock db(*this);
     m_textServices->TxSendMessage(WM_KILLFOCUS, 0, 0, &lresult);
+    if (windowsTextInputProps().selectTextOnFocus) {
+      LRESULT res;
+      m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(-1), static_cast<WPARAM>(-1), &res);
+    }
   }
   m_caretVisual.IsVisible(false);
+
+  // Call onEndEditing when focus is lost
+  if (m_eventEmitter && !m_comingFromJS) {
+    auto emitter = std::static_pointer_cast<const facebook::react::WindowsTextInputEventEmitter>(m_eventEmitter);
+    facebook::react::WindowsTextInputEventEmitter::OnEndEditing onEndEditingArgs;
+
+    // Set event arguments
+    onEndEditingArgs.eventCount = ++m_nativeEventCount;
+    onEndEditingArgs.text = GetTextFromRichEdit();
+
+    // Emit the event
+    emitter->onEndEditing(onEndEditingArgs);
+  }
 }
 
 void WindowsTextInputComponentView::onGotFocus(
@@ -943,6 +1005,9 @@ void WindowsTextInputComponentView::onGotFocus(
 
     if (windowsTextInputProps().clearTextOnFocus) {
       m_textServices->TxSetText(L"");
+    } else if (windowsTextInputProps().selectTextOnFocus) {
+      LRESULT res;
+      m_textServices->TxSendMessage(EM_SETSEL, static_cast<WPARAM>(0), static_cast<WPARAM>(-1), &res);
     }
   }
 }
@@ -983,7 +1048,10 @@ void WindowsTextInputComponentView::updateProps(
   if (!facebook::react::floatEquality(
           oldTextInputProps.textAttributes.fontSize, newTextInputProps.textAttributes.fontSize) ||
       (oldTextInputProps.textAttributes.allowFontScaling != newTextInputProps.textAttributes.allowFontScaling) ||
-      oldTextInputProps.textAttributes.fontWeight != newTextInputProps.textAttributes.fontWeight) {
+      oldTextInputProps.textAttributes.fontWeight != newTextInputProps.textAttributes.fontWeight ||
+      !facebook::react::floatEquality(
+          oldTextInputProps.textAttributes.letterSpacing, newTextInputProps.textAttributes.letterSpacing) ||
+      oldTextInputProps.textAttributes.fontFamily != newTextInputProps.textAttributes.fontFamily) {
     m_propBitsMask |= TXTBIT_CHARFORMATCHANGE;
     m_propBits |= TXTBIT_CHARFORMATCHANGE;
   }
@@ -1042,6 +1110,26 @@ void WindowsTextInputComponentView::updateProps(
     autoCapitalizeOnUpdateProps(oldTextInputProps.autoCapitalize, newTextInputProps.autoCapitalize);
   }
 
+  if (oldTextInputProps.textAlign != newTextInputProps.textAlign) {
+    // Let UpdateParaFormat() to refresh the text field with the new text alignment.
+    m_propBitsMask |= TXTBIT_PARAFORMATCHANGE;
+    m_propBits |= TXTBIT_PARAFORMATCHANGE;
+  }
+
+  // Please note: spellcheck performs both red lines and autocorrect as per windows behaviour
+  bool shouldUpdateSpellCheck =
+      (!oldProps || (oldTextInputProps.spellCheck != newTextInputProps.spellCheck) ||
+       (oldTextInputProps.autoCorrect != newTextInputProps.autoCorrect));
+
+  if (shouldUpdateSpellCheck) {
+    bool effectiveSpellCheck = newTextInputProps.spellCheck || newTextInputProps.autoCorrect;
+    updateSpellCheck(effectiveSpellCheck);
+  }
+
+  if (!oldProps || oldTextInputProps.autoCorrect != newTextInputProps.autoCorrect) {
+    updateAutoCorrect(newTextInputProps.autoCorrect);
+  }
+
   UpdatePropertyBits();
 }
 
@@ -1147,10 +1235,10 @@ void WindowsTextInputComponentView::OnTextUpdated() noexcept {
     emitter->onChange(onChangeArgs);
   }
 
-  if (m_uiaProvider) {
+  if (UiaClientsAreListening()) {
     auto text = GetTextFromRichEdit();
     winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
-        m_uiaProvider, UIA_ValueValuePropertyId, text, text);
+        EnsureUiaProvider(), UIA_ValueValuePropertyId, text, text);
   }
 }
 
@@ -1288,10 +1376,24 @@ void WindowsTextInputComponentView::UpdateCharFormat() noexcept {
   //    cfNew.dwEffects |= CFE_UNDERLINE;
   //  }
 
+  // set font family
+  if (!props.textAttributes.fontFamily.empty()) {
+    cfNew.dwMask |= CFM_FACE;
+    std::wstring fontFamily =
+        std::wstring(props.textAttributes.fontFamily.begin(), props.textAttributes.fontFamily.end());
+    wcsncpy_s(cfNew.szFaceName, fontFamily.c_str(), LF_FACESIZE);
+  }
+
   // set char offset
   cfNew.dwMask |= CFM_OFFSET;
   cfNew.yOffset = 0;
 
+  // set letter spacing
+  float letterSpacing = props.textAttributes.letterSpacing;
+  if (!std::isnan(letterSpacing)) {
+    updateLetterSpacing(letterSpacing);
+  }
+
   // set charset
   cfNew.dwMask |= CFM_CHARSET;
   cfNew.bCharSet = DEFAULT_CHARSET;
@@ -1305,7 +1407,15 @@ void WindowsTextInputComponentView::UpdateParaFormat() noexcept {
   m_pf.cbSize = sizeof(PARAFORMAT2);
   m_pf.dwMask = PFM_ALL;
 
-  m_pf.wAlignment = PFA_LEFT;
+  auto &textAlign = windowsTextInputProps().textAlign;
+
+  if (textAlign == facebook::react::TextAlignment::Center) {
+    m_pf.wAlignment = PFA_CENTER;
+  } else if (textAlign == facebook::react::TextAlignment::Right) {
+    m_pf.wAlignment = PFA_RIGHT;
+  } else {
+    m_pf.wAlignment = PFA_LEFT;
+  }
 
   m_pf.cTabCount = 1;
   m_pf.rgxTabs[0] = lDefaultTab;
@@ -1475,6 +1585,9 @@ WindowsTextInputComponentView::createVisual() noexcept {
   winrt::check_hresult(g_pfnCreateTextServices(nullptr, m_textHost.get(), spUnk.put()));
   spUnk.as(m_textServices);
 
+  LRESULT res;
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_SETTEXTMODE, TM_PLAINTEXT, 0, &res));
+
   m_caretVisual = m_compContext.CreateCaretVisual();
   visual.InsertAt(m_caretVisual.InnerVisual(), 0);
   m_caretVisual.IsVisible(false);
@@ -1525,4 +1638,39 @@ void WindowsTextInputComponentView::autoCapitalizeOnUpdateProps(
   }
 }
 
-} // namespace winrt::Microsoft::ReactNative::Composition::implementation
+void WindowsTextInputComponentView::updateLetterSpacing(float letterSpacing) noexcept {
+  CHARFORMAT2W cf = {};
+  cf.cbSize = sizeof(CHARFORMAT2W);
+  cf.dwMask = CFM_SPACING;
+  cf.sSpacing = static_cast<SHORT>(letterSpacing * 20); // Convert to TWIPS
+
+  LRESULT res;
+
+  // Apply to all existing text like placeholder
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_SETCHARFORMAT, SCF_ALL, reinterpret_cast<LPARAM>(&cf), &res));
+
+  // Apply to future text input
+  winrt::check_hresult(
+      m_textServices->TxSendMessage(EM_SETCHARFORMAT, SCF_SELECTION, reinterpret_cast<LPARAM>(&cf), &res));
+}
+
+void WindowsTextInputComponentView::updateAutoCorrect(bool enable) noexcept {
+  LRESULT lresult;
+  winrt::check_hresult(m_textServices->TxSendMessage(
+      EM_SETAUTOCORRECTPROC, enable ? 0 : reinterpret_cast<WPARAM>(AutoCorrectOffCallback), 0, &lresult));
+}
+
+void WindowsTextInputComponentView::updateSpellCheck(bool enable) noexcept {
+  LRESULT currentLangOptions;
+  winrt::check_hresult(m_textServices->TxSendMessage(EM_GETLANGOPTIONS, 0, 0, &currentLangOptions));
+
+  DWORD newLangOptions = static_cast<DWORD>(currentLangOptions);
+  if (enable) {
+    newLangOptions |= IMF_SPELLCHECKING;
+  }
+
+  LRESULT lresult;
+  winrt::check_hresult(
+      m_textServices->TxSendMessage(EM_SETLANGOPTIONS, IMF_SPELLCHECKING, enable ? newLangOptions : 0, &lresult));
+}
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -70,6 +70,7 @@ struct WindowsTextInputComponentView
   std::optional<std::string> getAccessiblityValue() noexcept override;
   void setAcccessiblityValue(std::string &&value) noexcept override;
   bool getAcccessiblityIsReadOnly() noexcept override;
+  bool IsDoubleClick();
 
   WindowsTextInputComponentView(
       const winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext &compContext,
@@ -110,6 +111,10 @@ struct WindowsTextInputComponentView
       const std::string &previousCapitalizationType,
       const std::string &newcapitalizationType) noexcept;
 
+  void updateLetterSpacing(float letterSpacing) noexcept;
+  void updateAutoCorrect(bool value) noexcept;
+  void updateSpellCheck(bool value) noexcept;
+
   winrt::Windows::UI::Composition::CompositionSurfaceBrush m_brush{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::ICaretVisual m_caretVisual{nullptr};
   winrt::Microsoft::ReactNative::Composition::Experimental::IDrawingSurfaceBrush m_drawingSurface{nullptr};
@@ -136,6 +141,7 @@ struct WindowsTextInputComponentView
   DWORD m_propBitsMask{0};
   DWORD m_propBits{0};
   HCURSOR m_hcursor{nullptr};
+  std::chrono::steady_clock::time_point m_lastClickTime{};
   std::vector<facebook::react::CompWindowsTextInputSubmitKeyEventsStruct> m_submitKeyEvents;
 };
 

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

@@ -5,6 +5,8 @@
 
 #include "WindowsTextInputEventEmitter.h"
 
+#include <react/renderer/core/graphicsConversions.h>
+
 namespace facebook::react {
 
 void WindowsTextInputEventEmitter::onChange(OnChange event) const {
@@ -46,4 +48,49 @@ void WindowsTextInputEventEmitter::onKeyPress(OnKeyPress event) const {
   });
 }
 
+static jsi::Value textInputMetricsContentSizePayload(
+    jsi::Runtime &runtime,
+    const WindowsTextInputEventEmitter::OnContentSizeChange &event) {
+  auto payload = jsi::Object(runtime);
+  {
+    auto contentSize = jsi::Object(runtime);
+    contentSize.setProperty(runtime, "width", event.contentSize.width);
+    contentSize.setProperty(runtime, "height", event.contentSize.height);
+    payload.setProperty(runtime, "contentSize", contentSize);
+  }
+  return payload;
+};
+
+void WindowsTextInputEventEmitter::onContentSizeChange(OnContentSizeChange event) const {
+  dispatchEvent("textInputContentSizeChange", [event = std::move(event)](jsi::Runtime &runtime) {
+    return textInputMetricsContentSizePayload(runtime, event);
+  });
+}
+
+void WindowsTextInputEventEmitter::onPressIn(PressEvent event) const {
+  dispatchEvent("textInputPressIn", [event = std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    auto nativeEvent = jsi::Object(runtime);
+    nativeEvent.setProperty(runtime, "target", static_cast<double>(event.target));
+    nativeEvent.setProperty(runtime, "pageX", event.pagePoint.x);
+    nativeEvent.setProperty(runtime, "pageY", event.pagePoint.y);
+    nativeEvent.setProperty(runtime, "locationX", event.offsetPoint.x);
+    nativeEvent.setProperty(runtime, "locationY", event.offsetPoint.y);
+    nativeEvent.setProperty(runtime, "timestamp", event.timestamp);
+    nativeEvent.setProperty(runtime, "identifier", static_cast<double>(event.identifier));
+    payload.setProperty(runtime, "nativeEvent", nativeEvent);
+    return payload;
+  });
+}
+
+void WindowsTextInputEventEmitter::onEndEditing(OnEndEditing event) const {
+  dispatchEvent("textInputEndEditing", [event = std::move(event)](jsi::Runtime &runtime) {
+    auto payload = jsi::Object(runtime);
+    payload.setProperty(runtime, "eventCount", event.eventCount);
+    payload.setProperty(runtime, "target", event.target);
+    payload.setProperty(runtime, "text", event.text);
+    return payload;
+  });
+}
+
 } // namespace facebook::react

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

@@ -36,10 +36,24 @@ class WindowsTextInputEventEmitter : public ViewEventEmitter {
     std::string key;
   };
 
+  struct OnContentSizeChange {
+    int target;
+    facebook::react::Size contentSize;
+  };
+
+  struct OnEndEditing {
+    int eventCount;
+    int target;
+    std::string text;
+  };
+
   void onChange(OnChange value) const;
   void onSelectionChange(const OnSelectionChange &value) const;
   void onSubmitEditing(OnSubmitEditing value) const;
   void onKeyPress(OnKeyPress value) const;
+  void onContentSizeChange(OnContentSizeChange value) const;
+  void onPressIn(PressEvent event) const override;
+  void onEndEditing(OnEndEditing value) const;
 };
 
-} // namespace facebook::react
+} // namespace facebook::react

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

@@ -24,6 +24,7 @@ WindowsTextInputProps::WindowsTextInputProps(
           */
 
       allowFontScaling(convertRawProp(context, rawProps, "allowFontScaling", sourceProps.allowFontScaling, {true})),
+      autoCorrect(convertRawProp(context, rawProps, "autoCorrect", sourceProps.autoCorrect, {true})),
       clearTextOnFocus(convertRawProp(context, rawProps, "clearTextOnFocus", sourceProps.clearTextOnFocus, {false})),
       editable(convertRawProp(context, rawProps, "editable", sourceProps.editable, {true})),
       maxLength(convertRawProp(context, rawProps, "maxLength", sourceProps.maxLength, {0})),
@@ -36,7 +37,7 @@ WindowsTextInputProps::WindowsTextInputProps(
       selection(convertRawProp(context, rawProps, "selection", sourceProps.selection, {})),
       selectionColor(convertRawProp(context, rawProps, "selectionColor", sourceProps.selectionColor, {})),
       selectTextOnFocus(convertRawProp(context, rawProps, "selectTextOnFocus", sourceProps.selectTextOnFocus, {false})),
-      spellCheck(convertRawProp(context, rawProps, "spellCheck", sourceProps.spellCheck, {false})),
+      spellCheck(convertRawProp(context, rawProps, "spellCheck", sourceProps.spellCheck, {true})),
       text(convertRawProp(context, rawProps, "text", sourceProps.text, {})),
       mostRecentEventCount(
           convertRawProp(context, rawProps, "mostRecentEventCount", sourceProps.mostRecentEventCount, {0})),
@@ -47,7 +48,10 @@ WindowsTextInputProps::WindowsTextInputProps(
       autoCapitalize(convertRawProp(context, rawProps, "autoCapitalize", sourceProps.autoCapitalize, {})),
       clearTextOnSubmit(convertRawProp(context, rawProps, "clearTextOnSubmit", sourceProps.clearTextOnSubmit, {false})),
       submitKeyEvents(convertRawProp(context, rawProps, "submitKeyEvents", sourceProps.submitKeyEvents, {})),
-      autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})) {}
+      autoFocus(convertRawProp(context, rawProps, "autoFocus", sourceProps.autoFocus, {false})),
+      textAlign(
+          convertRawProp(context, rawProps, "textAlign", sourceProps.textAlign, facebook::react::TextAlignment::Left)) {
+}
 
 void WindowsTextInputProps::setProp(
     const PropsParserContext &context,

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

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <react/components/rnwcore/Props.h>
+#include <react/renderer/attributedstring/conversions.h>
 #include <react/renderer/components/text/BaseTextProps.h>
 #include <react/renderer/core/propsConversions.h>
 
@@ -96,6 +97,7 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
   setProp(const PropsParserContext &context, RawPropsPropNameHash hash, const char *propName, RawValue const &value);
 
   bool allowFontScaling{true};
+  bool autoCorrect{true};
   bool clearTextOnFocus{false};
   bool editable{true};
   int maxLength{0};
@@ -107,7 +109,7 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
   CompWindowsTextInputSelectionStruct selection{};
   SharedColor selectionColor{};
   bool selectTextOnFocus{false};
-  bool spellCheck{false};
+  bool spellCheck{true};
   std::string text{};
   int mostRecentEventCount{0};
   bool secureTextEntry{false};
@@ -118,6 +120,7 @@ class WindowsTextInputProps final : public ViewProps, public BaseTextProps {
   bool clearTextOnSubmit{false};
   std::vector<CompWindowsTextInputSubmitKeyEventsStruct> submitKeyEvents{};
   bool autoFocus{false};
+  facebook::react::TextAlignment textAlign{};
 };
 
 } // namespace facebook::react

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

@@ -25,11 +25,10 @@ Size WindowsTextInputShadowNode::measureContent(
     const LayoutContext &layoutContext,
     const LayoutConstraints &layoutConstraints) const {
   if (getStateData().cachedAttributedStringId != 0) {
+    facebook::react::ParagraphAttributes paragraphAttributes{};
+    paragraphAttributes.maximumNumberOfLines = getConcreteProps().multiline ? 0 : 1;
     return textLayoutManager_
-        ->measureCachedSpannableById(
-            getStateData().cachedAttributedStringId,
-            {}, // TODO getConcreteProps().paragraphAttributes
-            layoutConstraints)
+        ->measureCachedSpannableById(getStateData().cachedAttributedStringId, paragraphAttributes, layoutConstraints)
         .size;
   }
 
@@ -62,12 +61,11 @@ Size WindowsTextInputShadowNode::measureContent(
 
   TextLayoutContext textLayoutContext;
   textLayoutContext.pointScaleFactor = layoutContext.pointScaleFactor;
+
+  facebook::react::ParagraphAttributes paragraphAttributes{};
+  paragraphAttributes.maximumNumberOfLines = getConcreteProps().multiline ? 0 : 1;
   return textLayoutManager_
-      ->measure(
-          AttributedStringBox{attributedString},
-          {}, // TODO getConcreteProps().paragraphAttributes,
-          textLayoutContext,
-          layoutConstraints)
+      ->measure(AttributedStringBox{attributedString}, paragraphAttributes, textLayoutContext, layoutConstraints)
       .size;
 }
 

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

@@ -51,7 +51,10 @@ class WindowsTextInputShadowNode final : public ConcreteViewShadowNode<
 
   void layout(LayoutContext layoutContext) override;
 
-  // Float baseline(const LayoutContext& layoutContext, Size size) const override;
+  Float baseline(const LayoutContext &layoutContext, Size size) const override {
+    // Calculate baseline as 80% of the text height
+    return size.height * 0.8f;
+  }
 
   std::shared_ptr<const TextLayoutManager> textLayoutManager_;
 

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

@@ -241,15 +241,20 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ButtonForegroundPressed", "TextFillColorSecondary"},
           {"ButtonForegroundPointerOver", "TextFillColorPrimary"},
           {"ButtonBackground", "ControlFillColorDefault"},
+          {"ButtonBorderBrush", "ButtonBorder"},
           {"ButtonBorder", "ControlElevationBorder"},
           {"ControlElevationBorder",
            "ControlStrokeColorSecondary"}, // TODO ControlElevationBorderBrush is actually gradient brush
           {"ButtonForeground", "TextFillColorPrimary"},
+          {"SolidBackgroundFillColorBaseBrush", "SolidBackgroundFillColorBase"},
           {"ButtonBackgroundDisabled", "ControlFillColorDisabled"},
+          {"ButtonBorderBrushDisabled", "ButtonBorderDisabled"},
           {"ButtonBorderDisabled", "ControlStrokeColorDefault"},
           {"ButtonForegroundDisabled", "TextFillColorDisabled"},
           {"ButtonBackgroundPointerOver", "ControlFillColorSecondary"},
+          {"ButtonBorderBrushPointerOver", "ButtonBorderPointerOver"},
           {"ButtonBorderPointerOver", "ControlElevationBorder"},
+          {"ButtonBorderBrushPressed", "ButtonBorderPressed"},
           {"ButtonBorderPressed", "ControlFillColorTransparent"},
           {"ToggleSwitchFillOff", "ControlAltFillColorSecondary"},
           {"ToggleSwitchFillOffPointerOver", "ControlAltFillColorTertiary"},

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

@@ -10,6 +10,7 @@
 #include <react/renderer/core/LayoutConstraints.h>
 #include <react/renderer/textlayoutmanager/TextLayoutManager.h>
 #include <winrt/Microsoft.ReactNative.Composition.h>
+#include <winrt/Windows.UI.ViewManagement.h>
 #include "TextDrawing.h"
 #include "dwmapi.h"
 
@@ -49,6 +50,8 @@ facebook::react::AttributedStringBox CreateTooltipAttributedString(const std::st
   auto fragment = facebook::react::AttributedString::Fragment{};
   fragment.string = tooltip;
   fragment.textAttributes.fontSize = tooltipFontSize;
+  fragment.textAttributes.fontSizeMultiplier =
+      static_cast<float>(winrt::Windows::UI::ViewManagement::UISettings().TextScaleFactor());
   attributedString.appendFragment(std::move(fragment));
   return facebook::react::AttributedStringBox{attributedString};
 }
@@ -231,14 +234,13 @@ void TooltipTracker::OnUnmounted(
 }
 
 void TooltipTracker::ShowTooltip(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
-  auto viewCompView = view.as<winrt::Microsoft::ReactNative::Composition::ViewComponentView>();
-
-  auto selfView =
-      winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>(viewCompView);
-  auto parentHwnd = selfView->GetHwndForParenting();
   DestroyTimer();
 
   if (!m_hwndTip) {
+    auto viewCompView = view.as<winrt::Microsoft::ReactNative::Composition::ViewComponentView>();
+    auto selfView =
+        winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::ViewComponentView>(viewCompView);
+    auto parentHwnd = selfView->GetHwndForParenting();
     auto tooltipData = std::make_unique<TooltipData>(view);
     tooltipData->attributedString = CreateTooltipAttributedString(*selfView->viewProps()->tooltip);
 
@@ -256,37 +258,39 @@ void TooltipTracker::ShowTooltip(const winrt::Microsoft::ReactNative::ComponentV
     facebook::react::TextLayoutManager::GetTextLayout(
         tooltipData->attributedString, {} /*paragraphAttributes*/, layoutConstraints, tooltipData->textLayout);
 
-    DWRITE_TEXT_METRICS tm;
-    winrt::check_hresult(tooltipData->textLayout->GetMetrics(&tm));
-
-    tooltipData->width =
-        static_cast<int>(tm.width + ((tooltipHorizontalPadding + tooltipHorizontalPadding) * scaleFactor));
-    tooltipData->height = static_cast<int>(tm.height + ((tooltipTopPadding + tooltipBottomPadding) * scaleFactor));
-
-    POINT pt = {static_cast<LONG>(m_pos.X), static_cast<LONG>(m_pos.Y)};
-    ClientToScreen(parentHwnd, &pt);
-
-    RegisterTooltipWndClass();
-    HINSTANCE hInstance = GetModuleHandle(NULL);
-    m_hwndTip = CreateWindow(
-        c_tooltipWindowClassName,
-        L"Tooltip",
-        WS_POPUP,
-        pt.x - tooltipData->width / 2,
-        static_cast<int>(pt.y - tooltipData->height - (toolTipPlacementMargin * scaleFactor)),
-        tooltipData->width,
-        tooltipData->height,
-        parentHwnd,
-        NULL,
-        hInstance,
-        tooltipData.get());
-
-    DWM_WINDOW_CORNER_PREFERENCE preference = DWMWCP_ROUNDSMALL;
-    UINT borderThickness = 0;
-    DwmSetWindowAttribute(m_hwndTip, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
-
-    tooltipData.release();
-    AnimateWindow(m_hwndTip, toolTipAnimationTimeMs, AW_BLEND);
+    if (tooltipData->textLayout) {
+      DWRITE_TEXT_METRICS tm;
+      winrt::check_hresult(tooltipData->textLayout->GetMetrics(&tm));
+
+      tooltipData->width =
+          static_cast<int>((tm.width + tooltipHorizontalPadding + tooltipHorizontalPadding) * scaleFactor);
+      tooltipData->height = static_cast<int>((tm.height + tooltipTopPadding + tooltipBottomPadding) * scaleFactor);
+
+      POINT pt = {static_cast<LONG>(m_pos.X), static_cast<LONG>(m_pos.Y)};
+      ClientToScreen(parentHwnd, &pt);
+
+      RegisterTooltipWndClass();
+      HINSTANCE hInstance = GetModuleHandle(NULL);
+      m_hwndTip = CreateWindow(
+          c_tooltipWindowClassName,
+          L"Tooltip",
+          WS_POPUP,
+          pt.x - tooltipData->width / 2,
+          static_cast<int>(pt.y - tooltipData->height - (toolTipPlacementMargin * scaleFactor)),
+          tooltipData->width,
+          tooltipData->height,
+          parentHwnd,
+          NULL,
+          hInstance,
+          tooltipData.get());
+
+      DWM_WINDOW_CORNER_PREFERENCE preference = DWMWCP_ROUNDSMALL;
+      UINT borderThickness = 0;
+      DwmSetWindowAttribute(m_hwndTip, DWMWA_WINDOW_CORNER_PREFERENCE, &preference, sizeof(preference));
+
+      tooltipData.release();
+      AnimateWindow(m_hwndTip, toolTipAnimationTimeMs, AW_BLEND);
+    }
   }
 }