react-native-windows 0.0.0-canary.658 → 0.0.0-canary.660

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

@@ -0,0 +1,125 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+#include "pch.h"
+
+#include "CompositionRootView.h"
+
+#include "CompositionRootView.g.cpp"
+#include "FocusNavigationRequest.g.cpp"
+
+namespace winrt::Microsoft::ReactNative::implementation {
+
+//! This class ensures that we access ReactRootView from UI thread.
+struct CompositionReactViewInstance
+    : public winrt::implements<CompositionReactViewInstance, winrt::Microsoft::ReactNative::IReactViewInstance> {
+  CompositionReactViewInstance(
+      winrt::weak_ref<winrt::Microsoft::ReactNative::implementation::CompositionRootView> &&) noexcept {}
+
+  void InitRootView(
+      winrt::Microsoft::ReactNative::IReactContext,
+      winrt::Microsoft::ReactNative::ReactViewOptions) noexcept {}
+
+  void UpdateRootView() noexcept {}
+  void UninitRootView() noexcept {}
+};
+
+//===========================================================================
+// ReactViewInstance inline implementation
+//===========================================================================
+
+CompositionRootView::CompositionRootView() noexcept {}
+
+ReactNative::IReactViewHost CompositionRootView::ReactViewHost() noexcept {
+  return nullptr;
+}
+
+void CompositionRootView::ReactViewHost(winrt::Microsoft::ReactNative::IReactViewHost const &) noexcept {}
+
+winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::RootVisual() noexcept {
+  return nullptr;
+}
+
+void CompositionRootView::RootVisual(winrt::Microsoft::ReactNative::Composition::IVisual const &) noexcept {}
+
+winrt::Windows::Foundation::Size CompositionRootView::Size() noexcept {
+  return {};
+}
+
+void CompositionRootView::Size(winrt::Windows::Foundation::Size) noexcept {}
+
+double CompositionRootView::ScaleFactor() noexcept {
+  return 0;
+}
+
+void CompositionRootView::ScaleFactor(double) noexcept {}
+
+winrt::IInspectable CompositionRootView::GetUiaProvider() noexcept {
+  return nullptr;
+}
+
+winrt::Microsoft::ReactNative::Composition::IVisual CompositionRootView::GetVisual() const noexcept {
+  return nullptr;
+}
+
+std::string CompositionRootView::JSComponentName() const noexcept {
+  return {};
+}
+
+int64_t CompositionRootView::GetActualHeight() const noexcept {
+  return 0;
+}
+
+int64_t CompositionRootView::GetActualWidth() const noexcept {
+  return 0;
+}
+
+int64_t CompositionRootView::GetTag() const noexcept {
+  return 0;
+}
+
+void CompositionRootView::SetTag(int64_t) noexcept {}
+
+int64_t CompositionRootView::SendMessage(uint32_t, uint64_t, int64_t) noexcept {
+  return 0;
+}
+
+void CompositionRootView::OnScrollWheel(Windows::Foundation::Point, int32_t) noexcept {}
+
+void CompositionRootView::InitRootView(
+    winrt::Microsoft::ReactNative::IReactContext &&,
+    winrt::Microsoft::ReactNative::ReactViewOptions &&) noexcept {}
+
+void CompositionRootView::UpdateRootView() noexcept {}
+
+void CompositionRootView::UpdateRootViewInternal() noexcept {}
+
+void CompositionRootView::UninitRootView() noexcept {}
+
+void CompositionRootView::ClearLoadingUI() noexcept {}
+
+void CompositionRootView::EnsureLoadingUI() noexcept {}
+
+void CompositionRootView::ShowInstanceLoaded() noexcept {}
+
+void CompositionRootView::ShowInstanceError() noexcept {}
+
+void CompositionRootView::ShowInstanceLoading() noexcept {}
+
+Windows::Foundation::Size CompositionRootView::Measure(Windows::Foundation::Size const &) const {
+  return {};
+}
+
+Windows::Foundation::Size CompositionRootView::Arrange(Windows::Foundation::Size) const {
+  return {};
+}
+
+::Microsoft::ReactNative::RootComponentView *CompositionRootView::GetComponentView() noexcept {
+  return nullptr;
+}
+
+winrt::Microsoft::ReactNative::FocusNavigationResult CompositionRootView::NavigateFocus(
+    const winrt::Microsoft::ReactNative::FocusNavigationRequest &) noexcept {
+  return nullptr;
+}
+
+} // namespace winrt::Microsoft::ReactNative::implementation

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

@@ -0,0 +1,18 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#include "pch.h"
+
+#include "CompositionUIService.h"
+
+#include "Composition.CompositionUIService.g.cpp"
+
+namespace winrt::Microsoft::ReactNative::Composition::implementation {
+
+void CompositionUIService::SetCompositionContext(IReactPropertyBag const &, ICompositionContext const &) noexcept {}
+
+ICompositionContext CompositionUIService::GetCompositionContext(const IReactPropertyBag &) noexcept {
+  return nullptr;
+}
+
+} // namespace winrt::Microsoft::ReactNative::Composition::implementation

package/Microsoft.ReactNative/Modules/NativeUIManager.cpp

@@ -153,9 +153,10 @@ NativeUIManager::NativeUIManager(winrt::Microsoft::ReactNative::ReactContext con
   m_yogaConfig = YGConfigNew();
   if (React::implementation::QuirkSettings::GetUseWebFlexBasisBehavior(m_context.Properties()))
     YGConfigSetExperimentalFeatureEnabled(m_yogaConfig, YGExperimentalFeatureWebFlexBasis, true);
+  auto errata = YGErrataAll;
   if (React::implementation::QuirkSettings::GetMatchAndroidAndIOSStretchBehavior(m_context.Properties()))
-    YGConfigSetErrata(m_yogaConfig, YGErrataStretchFlexBasis);
-
+    errata &= ~YGErrataStretchFlexBasis;
+  YGConfigSetErrata(m_yogaConfig, errata);
 #if defined(_DEBUG)
   YGConfigSetLogger(m_yogaConfig, &YogaLog);
 

package/Microsoft.ReactNative/Views/ViewPanel.cpp

@@ -51,43 +51,19 @@ winrt::AutomationPeer ViewPanel::OnCreateAutomationPeer() {
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::ViewBackgroundProperty() {
-  static xaml::DependencyProperty s_viewBackgroundProperty = xaml::DependencyProperty::Register(
-      L"ViewBackground",
-      winrt::xaml_typename<winrt::Brush>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(xaml::Media::SolidColorBrush(), ViewPanel::VisualPropertyChanged));
-
-  return s_viewBackgroundProperty;
+  return xaml::Controls::Panel::BackgroundProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::BorderThicknessProperty() {
-  static xaml::DependencyProperty s_borderThicknessProperty = xaml::DependencyProperty::Register(
-      L"BorderThickness",
-      winrt::xaml_typename<winrt::Thickness>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(winrt::box_value(winrt::Thickness()), ViewPanel::VisualPropertyChanged));
-
-  return s_borderThicknessProperty;
+  return xaml::Controls::Grid::BorderThicknessProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::BorderBrushProperty() {
-  static xaml::DependencyProperty s_borderBrushProperty = xaml::DependencyProperty::Register(
-      L"BorderBrush",
-      winrt::xaml_typename<winrt::Brush>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(xaml::Media::SolidColorBrush(), ViewPanel::VisualPropertyChanged));
-
-  return s_borderBrushProperty;
+  return xaml::Controls::Grid::BorderBrushProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::CornerRadiusProperty() {
-  static xaml::DependencyProperty s_cornerRadiusProperty = xaml::DependencyProperty::Register(
-      L"CornerRadius",
-      winrt::xaml_typename<xaml::CornerRadius>(),
-      viewPanelTypeName,
-      winrt::PropertyMetadata(winrt::box_value(xaml::CornerRadius()), ViewPanel::VisualPropertyChanged));
-
-  return s_cornerRadiusProperty;
+  return xaml::Controls::Grid::CornerRadiusProperty();
 }
 
 /*static*/ xaml::DependencyProperty ViewPanel::TopProperty() {
@@ -131,48 +107,32 @@ winrt::Size ViewPanel::MeasureOverride(winrt::Size /*availableSize*/) {
 }
 
 winrt::Size ViewPanel::ArrangeOverride(winrt::Size finalSize) {
-  // Sometimes we create outerBorder(i.e. when CornerRadius is true) instead of innerBorder,
-  // Yoga has no notion of outerBorder when calculating the child's position, so we
-  // need to make adjustment in arrange for outerborder's thickness.
-  float outerBorderLeft = 0;
-  float outerBorderTop = 0;
-  if (auto outerBorder = GetOuterBorder()) {
-    auto borderThickness = outerBorder.BorderThickness();
-    outerBorderLeft = static_cast<float>(borderThickness.Left);
-    outerBorderTop = static_cast<float>(borderThickness.Top);
-  }
   for (xaml::UIElement child : Children()) {
     double childHeight = 0.0;
     double childWidth = 0.0;
 
-    // A Border or inner ViewPanel should take up the same space as this panel
-    if (child == m_border) {
-      childWidth = finalSize.Width;
-      childHeight = finalSize.Height;
-    } else {
-      // We expect elements to have been arranged by yoga which means their
-      // Width & Height are set
-      xaml::FrameworkElement fe = child.try_as<xaml::FrameworkElement>();
-      if (fe != nullptr) {
-        childWidth = fe.Width();
-        childHeight = fe.Height();
-      }
-      // But we fall back to the measured size otherwise
-      else {
-        childWidth = child.DesiredSize().Width;
-        childHeight = child.DesiredSize().Height;
-      }
+    // We expect elements to have been arranged by yoga which means their
+    // Width & Height are set
+    xaml::FrameworkElement fe = child.try_as<xaml::FrameworkElement>();
+    if (fe != nullptr) {
+      childWidth = fe.Width();
+      childHeight = fe.Height();
+    }
+    // But we fall back to the measured size otherwise
+    else {
+      childWidth = child.DesiredSize().Width;
+      childHeight = child.DesiredSize().Height;
     }
 
     // Guard against negative values
     childWidth = std::max<double>(0.0f, childWidth);
     childHeight = std::max<double>(0.0f, childHeight);
 
-    float adjustedLeft = static_cast<float>(ViewPanel::GetLeft(child)) - outerBorderLeft;
-    float adjustedTop = static_cast<float>(ViewPanel::GetTop(child)) - outerBorderTop;
-
-    child.Arrange(
-        winrt::Rect(adjustedLeft, adjustedTop, static_cast<float>(childWidth), static_cast<float>(childHeight)));
+    child.Arrange(winrt::Rect(
+        static_cast<float>(ViewPanel::GetLeft(child)),
+        static_cast<float>(ViewPanel::GetTop(child)),
+        static_cast<float>(childWidth),
+        static_cast<float>(childHeight)));
   }
 
   return finalSize;
@@ -201,133 +161,4 @@ void ViewPanel::ViewBackground(winrt::Brush const &value) {
   SetValue(ViewBackgroundProperty(), winrt::box_value(value));
 }
 
-void ViewPanel::BorderThickness(winrt::Thickness const &value) {
-  SetValue(BorderThicknessProperty(), winrt::box_value(value));
-}
-
-void ViewPanel::BorderBrush(winrt::Brush const &value) {
-  SetValue(BorderBrushProperty(), winrt::box_value(value));
-}
-
-void ViewPanel::CornerRadius(xaml::CornerRadius const &value) {
-  SetValue(CornerRadiusProperty(), winrt::box_value(value));
-}
-
-void ViewPanel::FinalizeProperties() {
-  SystraceSection s("ViewPanel::FinalizeProperties");
-  if (!m_propertiesChanged)
-    return;
-
-  // There are 3 different solutions
-  //
-  //  A) No Border
-  //      -- No need for any border properties so just contain real children
-  //      >> Background applied to ViewPanel
-  //
-  //  B) Inner Border (child of this panel along with real children)
-  //      -- Border created and made a child of this panel, alongside standard
-  //      children
-  //      >> Border* properties applied to Border, Background applied to
-  //      ViewPanel
-  //
-  //  C) Outer Border
-  //      -- Border created but handed out to view manager to make parent of
-  //      this ViewPanel
-  //      >> Border* properties and Background applied to Border
-
-  const auto unsetValue = xaml::DependencyProperty::UnsetValue();
-  const Thickness emptyThickness = ThicknessHelper::FromUniformLength(0.0);
-
-  bool hasBackground = ReadLocalValue(ViewBackgroundProperty()) != unsetValue;
-  bool hasBorderBrush = ReadLocalValue(BorderBrushProperty()) != unsetValue;
-  bool hasBorderThickness = BorderThickness() != emptyThickness;
-  bool hasCornerRadius = ReadLocalValue(CornerRadiusProperty()) != unsetValue;
-  bool displayBorder = hasBorderThickness;
-
-  // Determine which scenario our current properties have put us into
-  enum class Scenario { OuterBorder, InnerBorder, NoBorder } scenario;
-  if (hasCornerRadius) {
-    scenario = Scenario::OuterBorder;
-    m_hasOuterBorder = true;
-  } else if (!displayBorder) {
-    scenario = Scenario::NoBorder;
-    m_hasOuterBorder = false;
-  } else {
-    scenario = Scenario::InnerBorder;
-    m_hasOuterBorder = false;
-  }
-
-  // Detach this Panel from the outer Border if needed
-  if (scenario != Scenario::OuterBorder && m_border != nullptr) {
-    m_border.Child(nullptr);
-  }
-
-  // Border element
-  if (scenario != Scenario::NoBorder) {
-    // Ensure Border is created
-    if (m_border == nullptr) {
-      m_border = xaml::Controls::Border();
-
-      // Add border as the top child if using as inner border
-      if (scenario == Scenario::InnerBorder)
-        Children().Append(m_border);
-    }
-
-    // TODO: Can Binding be used here?
-    if (hasBorderBrush)
-      m_border.BorderBrush(BorderBrush());
-    else if (!hasBorderThickness) {
-      m_border.ClearValue(xaml::Controls::Border::BorderBrushProperty());
-    }
-
-    if (hasBorderThickness) {
-      m_border.BorderThickness(BorderThickness());
-      if (!hasBorderBrush) {
-        // Borders with no brush draw something other than transparent on other platforms.
-        // To match, we'll use a default border brush if one isn't already set.
-        // Note:  Keep this in sync with code in TryUpdateBorderProperties().
-        m_border.BorderBrush(::Microsoft::ReactNative::DefaultBrushStore::Instance().GetDefaultBorderBrush());
-      }
-    } else
-      m_border.ClearValue(xaml::Controls::Border::BorderThicknessProperty());
-
-    if (hasCornerRadius)
-      m_border.CornerRadius(CornerRadius());
-    else
-      m_border.ClearValue(xaml::Controls::Border::CornerRadiusProperty());
-  } else if (m_border != nullptr) {
-    // Clean up and remove the Border element
-    m_border.Child(nullptr);
-    Remove(m_border);
-    m_border = nullptr;
-  }
-
-  if (scenario == Scenario::OuterBorder) {
-    if (hasBackground)
-      m_border.Background(ViewBackground());
-    else
-      m_border.ClearValue(xaml::Controls::Border::BackgroundProperty());
-
-    ClearValue(winrt::Panel::BackgroundProperty());
-
-    // Ensure the Border is not parented to this Panel
-    Remove(m_border);
-  } else {
-    // Set any background on this Panel
-    if (hasBackground)
-      SetValue(winrt::Panel::BackgroundProperty(), ViewBackground());
-    else
-      ClearValue(winrt::Panel::BackgroundProperty());
-  }
-
-  m_propertiesChanged = false;
-}
-
-xaml::Controls::Border ViewPanel::GetOuterBorder() {
-  if (m_hasOuterBorder && (m_border != nullptr))
-    return m_border;
-  else
-    return xaml::Controls::Border(nullptr);
-}
-
 } // namespace winrt::Microsoft::ReactNative::implementation

package/Microsoft.ReactNative/Views/ViewPanel.h

@@ -28,30 +28,12 @@ struct ViewPanel : ViewPanelT<ViewPanel> {
   void RemoveAt(uint32_t const index) const;
   void Clear() const;
 
-  void FinalizeProperties();
-  xaml::Controls::Border GetOuterBorder();
-
   // Public Properties
   xaml::Media::Brush ViewBackground() {
     return GetValue(ViewBackgroundProperty()).as<xaml::Media::Brush>();
   }
   void ViewBackground(xaml::Media::Brush const &value);
 
-  xaml::Thickness BorderThickness() {
-    return winrt::unbox_value<xaml::Thickness>(GetValue(BorderThicknessProperty()));
-  }
-  void BorderThickness(xaml::Thickness const &value);
-
-  xaml::Media::Brush BorderBrush() {
-    return GetValue(BorderBrushProperty()).as<xaml::Media::Brush>();
-  }
-  void BorderBrush(xaml::Media::Brush const &value);
-
-  xaml::CornerRadius CornerRadius() {
-    return winrt::unbox_value<xaml::CornerRadius>(GetValue(CornerRadiusProperty()));
-  }
-  void CornerRadius(xaml::CornerRadius const &value);
-
   // ViewPanel Properties
   static xaml::DependencyProperty ViewBackgroundProperty();
   static xaml::DependencyProperty BorderThicknessProperty();
@@ -79,10 +61,6 @@ struct ViewPanel : ViewPanelT<ViewPanel> {
  private:
   bool m_propertiesChanged{false};
 
-  // Child Elements
-  xaml::Controls::Border m_border{nullptr};
-  bool m_hasOuterBorder{false};
-
  private:
   static void VisualPropertyChanged(xaml::DependencyObject sender, xaml::DependencyPropertyChangedEventArgs e);
 };