react-native-windows 0.75.5 → 0.75.6

package/Microsoft.ReactNative/Fabric/ComponentView.cpp

@@ -14,6 +14,7 @@
 #include <Fabric/Composition/RootComponentView.h>
 #include "AbiEventEmitter.h"
 #include "AbiShadowNode.h"
+#include "ReactCoreInjection.h"
 
 namespace winrt::Microsoft::ReactNative::Composition::implementation {
 struct RootComponentView;
@@ -262,6 +263,17 @@ void ComponentView::HandleCommand(const winrt::Microsoft::ReactNative::HandleCom
   }
 }
 
+HWND ComponentView::GetHwndForParenting() noexcept {
+  if (m_parent) {
+    return winrt::get_self<winrt::Microsoft::ReactNative::implementation::ComponentView>(m_parent)
+        ->GetHwndForParenting();
+  }
+
+  // Fallback if we do not know any more specific HWND
+  return reinterpret_cast<HWND>(winrt::Microsoft::ReactNative::implementation::ReactCoreInjection::GetTopLevelWindowId(
+      m_reactContext.Properties().Handle()));
+}
+
 winrt::Microsoft::ReactNative::Composition::implementation::RootComponentView *ComponentView::rootComponentView()
     const noexcept {
   if (m_rootView)

package/Microsoft.ReactNative/Fabric/ComponentView.h

@@ -209,6 +209,9 @@ struct ComponentView : public ComponentViewT<ComponentView> {
   // Notify up the tree to bring the rect into view by scrolling as needed
   virtual void StartBringIntoView(BringIntoViewOptions &&args) noexcept;
 
+  // Eventually PopupContentLink and similar APIs will remove the need for this.
+  virtual HWND GetHwndForParenting() noexcept;
+
   virtual const winrt::Microsoft::ReactNative::IComponentProps userProps(
       facebook::react::Props::Shared const &props) noexcept;
 

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

@@ -125,6 +125,22 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::get_ProviderOptions(Prov
   return S_OK;
 }
 
+bool accessibilityValueHasValue(const facebook::react::AccessibilityValue &value) {
+  return (value.min.has_value() && value.max.has_value()) || value.now.has_value() || value.text.has_value();
+}
+
+bool expandableControl(const facebook::react::SharedViewProps props) {
+  if (props->accessibilityState.has_value() && props->accessibilityState->expanded.has_value())
+    return true;
+  auto accessibilityActions = props->accessibilityActions;
+  for (size_t i = 0; i < accessibilityActions.size(); i++) {
+    if (accessibilityActions[i].name == "expand" || accessibilityActions[i].name == "collapse") {
+      return true;
+    }
+  }
+  return false;
+}
+
 HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTERNID patternId, IUnknown **pRetVal) {
   if (pRetVal == nullptr)
     return E_POINTER;
@@ -165,6 +181,15 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPatternProvider(PATTE
     AddRef();
   }
 
+  if (patternId == UIA_ExpandCollapsePatternId &&
+      (accessibilityRole == "combobox" || accessibilityRole == "splitbutton" || accessibilityRole == "treeitem" ||
+       (expandableControl(props) &&
+        (accessibilityRole == "toolbar" || accessibilityRole == "menuitem" || accessibilityRole == "menubar" ||
+         accessibilityRole == "listitem" || accessibilityRole == "group" || accessibilityRole == "button")))) {
+    *pRetVal = static_cast<IExpandCollapseProvider *>(this);
+    AddRef();
+  }
+
   return S_OK;
 }
 
@@ -333,6 +358,13 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::GetPropertyValue(PROPERT
       pRetVal->lVal = GetLiveSetting(props->accessibilityLiveRegion);
       break;
     }
+    case UIA_ItemStatusPropertyId: {
+      pRetVal->vt = VT_BSTR;
+      pRetVal->bstrVal = (props->accessibilityState.has_value() && props->accessibilityState->busy)
+          ? SysAllocString(L"Busy")
+          : SysAllocString(L"");
+      break;
+    }
   }
 
   return hr;
@@ -464,4 +496,42 @@ HRESULT __stdcall CompositionDynamicAutomationProvider::Toggle() {
   return S_OK;
 }
 
+HRESULT __stdcall CompositionDynamicAutomationProvider::get_ExpandCollapseState(ExpandCollapseState *pRetVal) {
+  if (pRetVal == nullptr)
+    return E_POINTER;
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+
+  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;
+
+  *pRetVal = props->accessibilityState->expanded.has_value()
+      ? GetExpandCollapseState(props->accessibilityState->expanded.value())
+      : ExpandCollapseState_Collapsed;
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Expand() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "expand");
+  return S_OK;
+}
+
+HRESULT __stdcall CompositionDynamicAutomationProvider::Collapse() {
+  auto strongView = m_view.view();
+
+  if (!strongView)
+    return UIA_E_ELEMENTNOTAVAILABLE;
+  DispatchAccessibilityAction(m_view, "collapse");
+  return S_OK;
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -16,7 +16,8 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
                                                  IInvokeProvider,
                                                  IScrollItemProvider,
                                                  IValueProvider,
-                                                 IToggleProvider> {
+                                                 IToggleProvider,
+                                                 IExpandCollapseProvider> {
  public:
   CompositionDynamicAutomationProvider(
       const winrt::Microsoft::ReactNative::Composition::ComponentView &componentView) noexcept;
@@ -47,10 +48,15 @@ class CompositionDynamicAutomationProvider : public winrt::implements<
   virtual HRESULT __stdcall get_Value(BSTR *pRetVal) override;
   virtual HRESULT __stdcall get_IsReadOnly(BOOL *pRetVal) override;
 
-  // inherited via IToggleProivder
+  // inherited via IToggleProvider
   virtual HRESULT __stdcall get_ToggleState(ToggleState *pRetVal) override;
   virtual HRESULT __stdcall Toggle() override;
 
+  // inherited via IExpandCollapseProvider
+  virtual HRESULT __stdcall get_ExpandCollapseState(ExpandCollapseState *pRetVal) override;
+  virtual HRESULT __stdcall Expand() override;
+  virtual HRESULT __stdcall Collapse() override;
+
  private:
   ::Microsoft::ReactNative::ReactTaggedView m_view;
 };

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

@@ -23,6 +23,7 @@
 #include "CompositionHelpers.h"
 #include "RootComponentView.h"
 #include "Theme.h"
+#include "TooltipService.h"
 #include "UiaHelpers.h"
 #include "d2d1helper.h"
 
@@ -43,6 +44,13 @@ ComponentView::ComponentView(
   m_outerVisual.InsertAt(m_focusVisual.InnerVisual(), 0);
 }
 
+ComponentView::~ComponentView() {
+  if (m_tooltipTracked) {
+    TooltipService::GetCurrent(m_reactContext.Properties())->StopTracking(*this);
+    m_tooltipTracked = false;
+  }
+}
+
 facebook::react::Tag ComponentView::Tag() const noexcept {
   return m_tag;
 }
@@ -130,6 +138,16 @@ void ComponentView::updateProps(
     updateShadowProps(oldViewProps, newViewProps);
   }
 
+  if (oldViewProps.tooltip != newViewProps.tooltip) {
+    if (!m_tooltipTracked && newViewProps.tooltip) {
+      TooltipService::GetCurrent(m_reactContext.Properties())->StartTracking(*this);
+      m_tooltipTracked = true;
+    } else if (m_tooltipTracked && !newViewProps.tooltip) {
+      TooltipService::GetCurrent(m_reactContext.Properties())->StopTracking(*this);
+      m_tooltipTracked = false;
+    }
+  }
+
   base_type::updateProps(props, oldProps);
 }
 
@@ -1291,6 +1309,12 @@ void ComponentView::updateAccessibilityProps(
       !(oldViewProps.accessibilityState && oldViewProps.accessibilityState->disabled),
       !(newViewProps.accessibilityState && newViewProps.accessibilityState->disabled));
 
+  winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
+      m_uiaProvider,
+      UIA_IsEnabledPropertyId,
+      !(oldViewProps.accessibilityState && oldViewProps.accessibilityState->busy),
+      !(newViewProps.accessibilityState && newViewProps.accessibilityState->busy));
+
   winrt::Microsoft::ReactNative::implementation::UpdateUiaProperty(
       m_uiaProvider, UIA_ControlTypePropertyId, oldViewProps.accessibilityRole, newViewProps.accessibilityRole);
 

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

@@ -30,6 +30,7 @@ struct ComponentView : public ComponentViewT<
       facebook::react::Tag tag,
       winrt::Microsoft::ReactNative::ReactContext const &reactContext,
       ComponentViewFeatures flags);
+  virtual ~ComponentView();
 
   virtual winrt::Microsoft::ReactNative::Composition::Experimental::IVisual Visual() const noexcept {
     return nullptr;
@@ -151,6 +152,7 @@ struct ComponentView : public ComponentViewT<
       const facebook::react::ViewProps &viewProps) noexcept;
 
   bool m_FinalizeTransform{false};
+  bool m_tooltipTracked{false};
   ComponentViewFeatures m_flags;
   void showFocusVisual(bool show) noexcept;
   winrt::Microsoft::ReactNative::Composition::Experimental::IFocusVisual m_focusVisual{nullptr};

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

@@ -157,6 +157,7 @@ void ReactNativeIsland::ReactViewHost(winrt::Microsoft::ReactNative::IReactViewH
   }
 
   if (m_reactViewHost) {
+    UninitRootView();
     m_reactViewHost.DetachViewInstance();
   }
 
@@ -332,7 +333,7 @@ winrt::IInspectable ReactNativeIsland::GetUiaProvider() noexcept {
   if (m_uiaProvider == nullptr) {
     m_uiaProvider =
         winrt::make<winrt::Microsoft::ReactNative::implementation::CompositionRootAutomationProvider>(*this);
-    if (m_hwnd) {
+    if (m_hwnd && !m_island) {
       auto pRootProvider =
           static_cast<winrt::Microsoft::ReactNative::implementation::CompositionRootAutomationProvider *>(
               m_uiaProvider.as<IRawElementProviderSimple>().get());
@@ -348,6 +349,10 @@ void ReactNativeIsland::SetWindow(uint64_t hwnd) noexcept {
   m_hwnd = reinterpret_cast<HWND>(hwnd);
 }
 
+HWND ReactNativeIsland::GetHwndForParenting() noexcept {
+  return m_hwnd;
+}
+
 int64_t ReactNativeIsland::SendMessage(uint32_t msg, uint64_t wParam, int64_t lParam) noexcept {
   if (m_rootTag == -1)
     return 0;
@@ -367,7 +372,7 @@ int64_t ReactNativeIsland::SendMessage(uint32_t msg, uint64_t wParam, int64_t lP
 bool ReactNativeIsland::CapturePointer(
     const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
     facebook::react::Tag tag) noexcept {
-  if (m_hwnd) {
+  if (m_hwnd && !m_island) {
     SetCapture(m_hwnd);
   }
   return m_CompositionEventHandler->CapturePointer(pointer, tag);
@@ -377,7 +382,7 @@ void ReactNativeIsland::ReleasePointerCapture(
     const winrt::Microsoft::ReactNative::Composition::Input::Pointer &pointer,
     facebook::react::Tag tag) noexcept {
   if (m_CompositionEventHandler->ReleasePointerCapture(pointer, tag)) {
-    if (m_hwnd) {
+    if (m_hwnd && !m_island) {
       if (m_hwnd == GetCapture()) {
         ReleaseCapture();
       }

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

@@ -82,6 +82,7 @@ struct ReactNativeIsland
   void AddRenderedVisual(const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual) noexcept;
   void RemoveRenderedVisual(const winrt::Microsoft::ReactNative::Composition::Experimental::IVisual &visual) noexcept;
   bool TrySetFocus() noexcept;
+  HWND GetHwndForParenting() noexcept;
 
   winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader Resources() noexcept;
   void Resources(const winrt::Microsoft::ReactNative::Composition::ICustomResourceLoader &resources) noexcept;

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

@@ -231,4 +231,15 @@ winrt::Microsoft::ReactNative::implementation::ClipState RootComponentView::getC
   return winrt::Microsoft::ReactNative::implementation::ClipState::NoClip;
 }
 
+HWND RootComponentView::GetHwndForParenting() noexcept {
+  if (auto rootView = m_wkRootView.get()) {
+    auto hwnd = winrt::get_self<winrt::Microsoft::ReactNative::implementation::ReactNativeIsland>(rootView)
+                    ->GetHwndForParenting();
+    if (hwnd)
+      return hwnd;
+  }
+
+  return base_type::GetHwndForParenting();
+}
+
 } // namespace winrt::Microsoft::ReactNative::Composition::implementation

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

@@ -64,6 +64,8 @@ struct RootComponentView : RootComponentViewT<RootComponentView, ViewComponentVi
   winrt::Microsoft::ReactNative::ComponentView FindFirstFocusableElement() noexcept;
   winrt::Microsoft::ReactNative::ComponentView FindLastFocusableElement() noexcept;
 
+  HWND GetHwndForParenting() noexcept override;
+
  private:
   // should this be a ReactTaggedView? - It shouldn't actually matter since if the view is going away it should always
   // be clearing its focus But being a reactTaggedView might make it easier to identify cases where that isn't

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

@@ -16,7 +16,7 @@
 namespace winrt::Microsoft::ReactNative::Composition {
 
 void RenderText(
-    ID2D1DeviceContext &deviceContext,
+    ID2D1RenderTarget &deviceContext,
     ::IDWriteTextLayout &textLayout,
     const facebook::react::AttributedString &attributedString,
     const facebook::react::TextAttributes &textAttributes,
@@ -26,7 +26,6 @@ void RenderText(
   float offsetX = offset.x / pointScaleFactor;
   float offsetY = offset.y / pointScaleFactor;
 
-  assert(deviceContext.GetUnitMode() == D2D1_UNIT_MODE_DIPS);
   const auto dpi = pointScaleFactor * 96.0f;
   float oldDpiX, oldDpiY;
   deviceContext.GetDpi(&oldDpiX, &oldDpiY);

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

@@ -14,7 +14,7 @@
 namespace winrt::Microsoft::ReactNative::Composition {
 
 void RenderText(
-    ID2D1DeviceContext &deviceContext,
+    ID2D1RenderTarget &deviceContext,
     ::IDWriteTextLayout &textLayout,
     const facebook::react::AttributedString &attributedString,
     const facebook::react::TextAttributes &textAttributes,

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

@@ -296,7 +296,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ScrollBarThumbFillDisabled", "ControlStrongFillColorDisabled"},
           {"ScrollBarTrackFill",
            "AcrylicInAppFillColorDefault"}, // TODO make AcrylicInAppFillColorDefault a real acrylic brush
-      };
+          {"ToolTipBackground", "SystemChromeMediumLowColor"},
+          {"ToolTipForeground", "SystemControlForegroundBaseHighColor"},
+          {"ToolTipBorderBrush", "SystemControlTransientBorderColor"}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_lightColors = {
@@ -326,7 +328,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ControlStrongFillColorDefault", {0x72, 0x00, 0x00, 0x00}},
           {"ControlStrongFillColorDisabled", {0x51, 0x00, 0x00, 0x00}},
           {"AcrylicInAppFillColorDefault", {0x9E, 0xFF, 0xFF, 0xFF}},
-      };
+          {"SystemChromeMediumLowColor", {0xFF, 0xF2, 0xF2, 0xF2}},
+          {"SystemControlForegroundBaseHighColor", {0xFF, 0x00, 0x00, 0x00}},
+          {"SystemControlTransientBorderColor", {0x24, 0x00, 0x00, 0x00}}};
 
   static std::unordered_map<std::string, winrt::Windows::UI::Color, std::hash<std::string_view>, std::equal_to<>>
       s_darkColors = {
@@ -356,7 +360,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"ControlStrongFillColorDefault", {0x8B, 0xFF, 0xFF, 0xFF}},
           {"ControlStrongFillColorDisabled", {0x3F, 0xFF, 0xFF, 0xFF}},
           {"AcrylicInAppFillColorDefault", {0x9E, 0x00, 0x00, 0x00}},
-      };
+          {"SystemChromeMediumLowColor", {0xFF, 0x2B, 0x2B, 0x2B}},
+          {"SystemControlForegroundBaseHighColor", {0xFF, 0xFF, 0xFF, 0xFF}},
+          {"SystemControlTransientBorderColor", {0x5C, 0x00, 0x00, 0x00}}};
 
   static std::unordered_map<
       std::string,
@@ -391,7 +397,9 @@ bool Theme::TryGetPlatformColor(const std::string &platformColor, winrt::Windows
           {"SubtleFillColorSecondary", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"ControlStrongFillColorDefault", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
           {"ControlStrongFillColorDisabled", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
-      };
+          {"SystemChromeMediumLowColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonFace, {}}},
+          {"SystemControlForegroundBaseHighColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}},
+          {"SystemControlTransientBorderColor", {winrt::Windows::UI::ViewManagement::UIElementType::ButtonText, {}}}};
 
   auto alias = s_xamlAliasedColors.find(platformColor);
   if (alias != s_xamlAliasedColors.end()) {

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

@@ -0,0 +1,338 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "TooltipService.h"
+
+#include <CompositionSwitcher.Experimental.interop.h>
+#include <Fabric/Composition/CompositionViewComponentView.h>
+#include <react/renderer/attributedstring/AttributedStringBox.h>
+#include <react/renderer/core/LayoutConstraints.h>
+#include <react/renderer/textlayoutmanager/TextLayoutManager.h>
+#include <winrt/Microsoft.ReactNative.Composition.h>
+#include "TextDrawing.h"
+#include "dwmapi.h"
+
+namespace winrt::Microsoft::ReactNative {
+
+constexpr PCWSTR c_tooltipWindowClassName = L"RN_TOOLTIP";
+constexpr auto TooltipDataProperty = L"TooltipData";
+constexpr float tooltipFontSize = 12;
+constexpr float tooltipMaxHeight = 1000;
+constexpr float tooltipMaxWidth = 320;
+constexpr float tooltipHorizontalPadding = 8;
+constexpr float tooltipTopPadding = 5;
+constexpr float tooltipBottomPadding = 7;
+constexpr float toolTipBorderThickness = 1;
+constexpr int toolTipPlacementMargin = 12;
+constexpr int toolTipAnimationTimeMs = 200;
+constexpr int toolTipTimeToShowMs = 1000;
+
+struct TooltipData {
+  TooltipData(const winrt::Microsoft::ReactNative::ComponentView &view) : view(view) {}
+
+  static TooltipData *GetFromWindow(HWND hwnd) {
+    auto data = reinterpret_cast<TooltipData *>(GetProp(hwnd, TooltipDataProperty));
+    return data;
+  }
+
+  int width;
+  int height;
+  ::Microsoft::ReactNative::ReactTaggedView view;
+  winrt::com_ptr<::IDWriteTextLayout> textLayout;
+  facebook::react::AttributedStringBox attributedString;
+  winrt::Microsoft::ReactNative::Composition::Experimental::ICompositionContext compositionContext;
+};
+
+facebook::react::AttributedStringBox CreateTooltipAttributedString(const std::string &tooltip) noexcept {
+  auto attributedString = facebook::react::AttributedString{};
+  auto fragment = facebook::react::AttributedString::Fragment{};
+  fragment.string = tooltip;
+  fragment.textAttributes.fontSize = tooltipFontSize;
+  attributedString.appendFragment(fragment);
+  return facebook::react::AttributedStringBox{attributedString};
+}
+
+LRESULT CALLBACK TooltipWndProc(HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam) noexcept {
+  switch (message) {
+    case WM_DESTROY: {
+      delete TooltipData::GetFromWindow(hwnd);
+      SetProp(hwnd, TooltipDataProperty, 0);
+      return 0;
+    }
+    case WM_PRINTCLIENT:
+    case WM_PAINT: {
+      HDC hdc;
+      PAINTSTRUCT ps;
+
+      if (message != WM_PRINTCLIENT)
+        hdc = BeginPaint(hwnd, &ps);
+      else
+        hdc = (HDC)wparam;
+      auto data = TooltipData::GetFromWindow(hwnd);
+
+      if (auto view = data->view.view()) {
+        auto scaleFactor = view.LayoutMetrics().PointScaleFactor;
+
+        auto ccInterop = data->compositionContext
+                             .as<::Microsoft::ReactNative::Composition::Experimental::ICompositionContextInterop>();
+        winrt::com_ptr<ID2D1Factory1> factory;
+        ccInterop->D2DFactory(factory.put());
+
+        winrt::com_ptr<ID2D1DCRenderTarget> renderTarget;
+
+        D2D1_RENDER_TARGET_PROPERTIES props = D2D1::RenderTargetProperties(
+            D2D1_RENDER_TARGET_TYPE_DEFAULT,
+            D2D1::PixelFormat(DXGI_FORMAT_B8G8R8A8_UNORM, D2D1_ALPHA_MODE_IGNORE),
+            0,
+            0,
+            D2D1_RENDER_TARGET_USAGE_NONE,
+            D2D1_FEATURE_LEVEL_DEFAULT);
+        winrt::check_hresult(factory->CreateDCRenderTarget(&props, renderTarget.put()));
+        RECT rc;
+        GetClientRect(hwnd, &rc);
+        winrt::check_hresult(renderTarget->BindDC(hdc, &rc));
+        auto theme = view.as<winrt::Microsoft::ReactNative::Composition::ComponentView>().Theme();
+        auto selfTheme = winrt::get_self<winrt::Microsoft::ReactNative::Composition::implementation::Theme>(theme);
+
+        renderTarget->BeginDraw();
+        renderTarget->Clear(selfTheme->D2DPlatformColor("ToolTipBackground"));
+
+        auto textAttributes = facebook::react::TextAttributes{};
+        facebook::react::Color fgColor;
+        fgColor.m_platformColor.push_back("ToolTipForeground");
+        textAttributes.foregroundColor = fgColor;
+
+        winrt::Microsoft::ReactNative::Composition::RenderText(
+            *renderTarget,
+            *data->textLayout,
+            data->attributedString.getValue(),
+            textAttributes,
+            {std::round(tooltipHorizontalPadding * scaleFactor), std::round(tooltipTopPadding * scaleFactor)},
+            scaleFactor,
+            *selfTheme);
+
+        auto hr = renderTarget->EndDraw();
+      }
+
+      if (message != WM_PRINTCLIENT)
+        EndPaint(hwnd, &ps);
+      return 0;
+    }
+    case WM_NCCREATE: {
+      auto cs = reinterpret_cast<CREATESTRUCT *>(lparam);
+      auto data = static_cast<TooltipData *>(cs->lpCreateParams);
+      WINRT_ASSERT(data);
+      SetProp(hwnd, TooltipDataProperty, reinterpret_cast<HANDLE>(data));
+      break;
+    }
+  }
+
+  return DefWindowProc(hwnd, message, wparam, lparam);
+}
+
+void RegisterTooltipWndClass() noexcept {
+  static bool registered = false;
+  if (registered) {
+    return;
+  }
+
+  HINSTANCE hInstance =
+      GetModuleHandle(NULL); // returns a handle to the file used to create the calling process (.exe file)
+
+  WNDCLASSEX wcex = {}; // contains window class information
+  wcex.cbSize = sizeof(wcex); // size of windows class (bytes)
+  wcex.style = CS_HREDRAW | CS_VREDRAW; // class style (redraw window on size adjustment)
+  wcex.lpfnWndProc = &TooltipWndProc; // pointer to windows procedure
+  wcex.cbClsExtra = DLGWINDOWEXTRA; // extra bytes to allocate
+  wcex.cbWndExtra = sizeof(TooltipData *); // extra bytes to allocate
+  wcex.hInstance = hInstance;
+  wcex.hCursor = LoadCursor(nullptr, IDC_ARROW); // handle to class cursor
+  wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // background color
+  wcex.lpszClassName = c_tooltipWindowClassName; // specify resource name
+  ATOM classId = RegisterClassEx(&wcex); // register new windows class
+  WINRT_VERIFY(classId); // 0 = fail
+  winrt::check_win32(!classId);
+
+  registered = true;
+}
+
+TooltipTracker::TooltipTracker(
+    const winrt::Microsoft::ReactNative::ComponentView &view,
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+    TooltipService *outer)
+    : m_view(view), m_properties(properties), m_outer(outer) {
+  view.PointerEntered({this, &TooltipTracker::OnPointerEntered});
+  view.PointerExited({this, &TooltipTracker::OnPointerExited});
+  view.PointerMoved({this, &TooltipTracker::OnPointerMoved});
+  view.Unmounted({this, &TooltipTracker::OnUnmounted});
+}
+
+TooltipTracker::~TooltipTracker() {
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+facebook::react::Tag TooltipTracker::Tag() const noexcept {
+  return m_view.Tag();
+}
+
+void TooltipTracker::OnPointerEntered(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+
+  auto pp = args.GetCurrentPoint(-1);
+  m_pos = pp.Position();
+
+  m_timer = winrt::Microsoft::ReactNative::Timer::Create(m_properties.Handle());
+  m_timer.Interval(std::chrono::milliseconds(toolTipTimeToShowMs));
+  m_timer.Tick({this, &TooltipTracker::OnTick});
+  m_timer.Start();
+}
+
+void TooltipTracker::OnPointerMoved(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+
+  auto pp = args.GetCurrentPoint(-1);
+  m_pos = pp.Position();
+}
+
+void TooltipTracker::OnTick(
+    const winrt::Windows::Foundation::IInspectable &,
+    const winrt::Windows::Foundation::IInspectable &) noexcept {
+  ShowTooltip(m_view.view());
+}
+
+void TooltipTracker::OnPointerExited(
+    const winrt::Windows::Foundation::IInspectable &sender,
+    const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept {
+  if (args.Pointer().PointerDeviceType() !=
+          winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Mouse &&
+      args.Pointer().PointerDeviceType() != winrt::Microsoft::ReactNative::Composition::Input::PointerDeviceType::Pen)
+    return;
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+void TooltipTracker::OnUnmounted(
+    const winrt::Windows::Foundation::IInspectable &,
+    const winrt::Microsoft::ReactNative::ComponentView &) noexcept {
+  DestroyTimer();
+  DestroyTooltip();
+}
+
+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 tooltipData = std::make_unique<TooltipData>(view);
+    tooltipData->attributedString = CreateTooltipAttributedString(*selfView->viewProps()->tooltip);
+
+    tooltipData->compositionContext = selfView->CompositionContext();
+    tooltipData->view = view;
+
+    auto scaleFactor = view.LayoutMetrics().PointScaleFactor;
+    facebook::react::LayoutConstraints layoutConstraints;
+    layoutConstraints.layoutDirection = facebook::react::LayoutDirection::Undefined;
+    layoutConstraints.maximumSize.height = tooltipMaxHeight * scaleFactor;
+    layoutConstraints.maximumSize.width = tooltipMaxWidth * scaleFactor;
+    layoutConstraints.minimumSize.height = 0;
+    layoutConstraints.minimumSize.width = 0;
+
+    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);
+  }
+}
+
+void TooltipTracker::DestroyTooltip() noexcept {
+  if (m_hwndTip) {
+    AnimateWindow(m_hwndTip, toolTipAnimationTimeMs, AW_BLEND | AW_HIDE);
+    DestroyWindow(m_hwndTip);
+    m_hwndTip = nullptr;
+  }
+}
+
+void TooltipTracker::DestroyTimer() noexcept {
+  if (m_timer) {
+    m_timer.Stop();
+    m_timer = nullptr;
+  }
+}
+
+TooltipService::TooltipService(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties)
+    : m_properties(properties) {}
+
+void TooltipService::StartTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+  m_trackers.push_back(std::make_shared<TooltipTracker>(view, m_properties, this));
+}
+
+void TooltipService::StopTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept {
+  for (auto it = m_trackers.begin(); it != m_trackers.end();) {
+    if ((*it)->Tag() == view.Tag())
+      it = m_trackers.erase(it);
+    else
+      ++it;
+  }
+}
+
+static const ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<TooltipService>>>
+    &TooltipServicePropertyId() noexcept {
+  static const ReactPropertyId<winrt::Microsoft::ReactNative::ReactNonAbiValue<std::shared_ptr<TooltipService>>> prop{
+      L"ReactNative", L"TooltipService"};
+  return prop;
+}
+
+std::shared_ptr<TooltipService> TooltipService::GetCurrent(
+    const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept {
+  return *properties.GetOrCreate(TooltipServicePropertyId(), [properties]() -> std::shared_ptr<TooltipService> {
+    return std::make_shared<TooltipService>(properties);
+  });
+}
+
+} // namespace winrt::Microsoft::ReactNative

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

@@ -0,0 +1,66 @@
+
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include <Fabric/ReactTaggedView.h>
+#include <winrt/Microsoft.ReactNative.h>
+
+namespace winrt::Microsoft::ReactNative {
+
+struct TooltipService;
+
+struct TooltipTracker {
+  TooltipTracker(
+      const winrt::Microsoft::ReactNative::ComponentView &view,
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties,
+      TooltipService *outer);
+  ~TooltipTracker();
+
+  void OnPointerEntered(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerMoved(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnPointerExited(
+      const winrt::Windows::Foundation::IInspectable &sender,
+      const winrt::Microsoft::ReactNative::Composition::Input::PointerRoutedEventArgs &args) noexcept;
+  void OnTick(
+      const winrt::Windows::Foundation::IInspectable &,
+      const winrt::Windows::Foundation::IInspectable &) noexcept;
+  void OnUnmounted(
+      const winrt::Windows::Foundation::IInspectable &,
+      const winrt::Microsoft::ReactNative::ComponentView &) noexcept;
+
+  facebook::react::Tag Tag() const noexcept;
+
+ private:
+  void ShowTooltip(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+  void DestroyTimer() noexcept;
+  void DestroyTooltip() noexcept;
+
+  TooltipService *m_outer;
+  winrt::Windows::Foundation::Point m_pos;
+  ::Microsoft::ReactNative::ReactTaggedView m_view;
+  winrt::Microsoft::ReactNative::ITimer m_timer;
+  HWND m_hwndTip{nullptr};
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_properties;
+};
+
+struct TooltipService {
+  TooltipService(const winrt::Microsoft::ReactNative::ReactPropertyBag &properties);
+  void StartTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+  void StopTracking(const winrt::Microsoft::ReactNative::ComponentView &view) noexcept;
+
+  static std::shared_ptr<TooltipService> GetCurrent(
+      const winrt::Microsoft::ReactNative::ReactPropertyBag &properties) noexcept;
+
+ private:
+  std::vector<std::shared_ptr<TooltipTracker>> m_enteredTrackers;
+  std::vector<std::shared_ptr<TooltipTracker>> m_trackers;
+  winrt::Microsoft::ReactNative::ReactPropertyBag m_properties;
+};
+
+} // namespace winrt::Microsoft::ReactNative

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

@@ -206,4 +206,12 @@ void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view
   }
 }
 
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept {
+  if (expanded) {
+    return ExpandCollapseState_Expanded;
+  } else {
+    return ExpandCollapseState_Collapsed;
+  }
+}
+
 } // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -35,4 +35,5 @@ std::string extractAccessibilityValue(const facebook::react::AccessibilityValue
 
 void DispatchAccessibilityAction(::Microsoft::ReactNative::ReactTaggedView &view, const std::string &action) noexcept;
 
+ExpandCollapseState GetExpandCollapseState(const bool &expanded) noexcept;
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Fabric/FabricUIManagerModule.cpp

@@ -164,6 +164,9 @@ void FabricUIManager::startSurface(
 
 void FabricUIManager::stopSurface(facebook::react::SurfaceId surfaceId) noexcept {
   m_surfaceManager->stopSurface(surfaceId);
+  auto &rootDescriptor = m_registry.componentViewDescriptorWithTag(surfaceId);
+  m_registry.enqueueComponentViewWithComponentHandle(
+      facebook::react::RootShadowNode::Handle(), surfaceId, rootDescriptor);
 }
 
 winrt::Microsoft::ReactNative::ReactNativeIsland FabricUIManager::GetReactNativeIsland(

package/Microsoft.ReactNative/Fabric/ReactTaggedView.h

@@ -31,6 +31,10 @@ struct ReactTaggedView {
     return strongView;
   }
 
+  facebook::react::Tag Tag() const noexcept {
+    return m_tag;
+  }
+
  private:
   facebook::react::Tag m_tag;
   winrt::weak_ref<winrt::Microsoft::ReactNative::ComponentView> m_view;

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.cpp

@@ -27,6 +27,10 @@ HostPlatformViewProps::HostPlatformViewProps(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.focusable
               : convertRawProp(context, rawProps, "focusable", sourceProps.focusable, {})),
+      tooltip(
+          CoreFeatures::enablePropIteratorSetter
+              ? sourceProps.tooltip
+              : convertRawProp(context, rawProps, "tooltip", sourceProps.tooltip, {})),
       accessibilityPosInSet(
           CoreFeatures::enablePropIteratorSetter
               ? sourceProps.accessibilityPosInSet
@@ -82,6 +86,7 @@ void HostPlatformViewProps::setProp(
     RAW_SET_PROP_SWITCH_CASE_BASIC(accessibilityLiveRegion);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyDownEvents);
     RAW_SET_PROP_SWITCH_CASE_BASIC(keyUpEvents);
+    RAW_SET_PROP_SWITCH_CASE_BASIC(tooltip);
   }
 }
 

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewProps.h

@@ -29,7 +29,7 @@ class HostPlatformViewProps : public BaseViewProps {
   std::string accessibilityLiveRegion{"none"};
 
   // std::optional<std::string> overflowAnchor{};
-  // std::optional<std::string> tooltip{};
+  std::optional<std::string> tooltip{};
   std::vector<HandledKeyEvent> keyDownEvents{};
   std::vector<HandledKeyEvent> keyUpEvents{};
 };

package/Microsoft.ReactNative/Fabric/platform/react/renderer/components/view/HostPlatformViewTraitsInitializer.h

@@ -13,7 +13,7 @@ inline bool formsStackingContext(ViewProps const &viewProps) {
   // Only Views which are marked as focusable can actually trigger the events, which will already avoid being collapsed.
   constexpr decltype(WindowsViewEvents::bits) focusEventsMask = {
       (1 << (int)WindowsViewEvents::Offset::Focus) & (1 << (int)WindowsViewEvents::Offset::Blur)};
-  return (viewProps.windowsEvents.bits & focusEventsMask).any();
+  return (viewProps.windowsEvents.bits & focusEventsMask).any() || viewProps.tooltip;
 }
 
 inline bool formsView(ViewProps const &viewProps) {

package/Microsoft.ReactNative/Microsoft.ReactNative.vcxproj

@@ -142,7 +142,7 @@
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
     </ClCompile>
     <Link>
-      <AdditionalDependencies>winsqlite3.lib;ChakraRT.lib;dxguid.lib;dloadhelper.lib;OneCoreUap_apiset.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalDependencies>winsqlite3.lib;ChakraRT.lib;dxguid.lib;dloadhelper.lib;OneCoreUap_apiset.lib;Dwmapi.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <DelayLoadDLLs>
         api-ms-win-core-file-l1-2-0.dll;
         api-ms-win-core-windowserrorreporting-l1-1-0.dll;

package/Microsoft.ReactNative/ReactCoreInjection.h

@@ -53,7 +53,6 @@ struct ReactCoreInjection : ReactCoreInjectionT<ReactCoreInjection> {
   static uint64_t GetTopLevelWindowId(const IReactPropertyBag &properties) noexcept;
   static void SetTopLevelWindowId(const IReactPropertyBag &properties, uint64_t windowId) noexcept;
 
-  static ITimer CreateTimer(const IReactPropertyBag &properties);
   static TimerFactory GetTimerFactory(const IReactPropertyBag &properties) noexcept;
   static void SetTimerFactory(const IReactPropertyBag &properties, const TimerFactory &timerFactory) noexcept;
 };

package/PropertySheets/Generated/PackageVersion.g.props

@@ -10,11 +10,11 @@
 -->
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <PropertyGroup>
-    <ReactNativeWindowsVersion>0.75.5</ReactNativeWindowsVersion>
+    <ReactNativeWindowsVersion>0.75.6</ReactNativeWindowsVersion>
     <ReactNativeWindowsMajor>0</ReactNativeWindowsMajor>
     <ReactNativeWindowsMinor>75</ReactNativeWindowsMinor>
-    <ReactNativeWindowsPatch>5</ReactNativeWindowsPatch>
+    <ReactNativeWindowsPatch>6</ReactNativeWindowsPatch>
     <ReactNativeWindowsCanary>false</ReactNativeWindowsCanary>
-    <ReactNativeWindowsCommitId>91192a3cc0a59ab92355a55721d20e04eade9648</ReactNativeWindowsCommitId>
+    <ReactNativeWindowsCommitId>499b89b7e5c209d97efd981342b953b75854c903</ReactNativeWindowsCommitId>
   </PropertyGroup>
 </Project>

package/Shared/Shared.vcxitems

@@ -150,6 +150,9 @@
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\TextDrawing.cpp">
       <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\TooltipService.cpp">
+      <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
+    </ClCompile>
     <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\UiaHelpers.cpp">
       <ExcludedFromBuild Condition="'$(UseFabric)' != 'true'">true</ExcludedFromBuild>
     </ClCompile>

package/Shared/Shared.vcxitems.filters

@@ -329,6 +329,8 @@
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\cxxreact\JSExecutor.cpp" />
     <ClCompile Include="$(ReactNativeDir)\ReactCommon\jsinspector-modern\RuntimeTargetConsole.cpp" />
     <ClCompile Include="$(MSBuildThisFileDirectory)Networking\NetworkPropertyIds.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\AbiEventEmitter.cpp" />
+    <ClCompile Include="$(MSBuildThisFileDirectory)..\Microsoft.ReactNative\Fabric\Composition\TooltipService.cpp" />
   </ItemGroup>
   <ItemGroup>
     <Filter Include="Source Files">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-windows",
-  "version": "0.75.5",
+  "version": "0.75.6",
   "license": "MIT",
   "repository": {
     "type": "git",