react-native-windows 0.81.1 → 0.82.0-preview.1

package/Microsoft.ReactNative/Views/TextInputViewManager.h

@@ -1,33 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <Views/ControlViewManager.h>
-
-namespace Microsoft::ReactNative {
-
-class TextInputViewManager : public ControlViewManager {
-  using Super = ControlViewManager;
-
- public:
-  TextInputViewManager(const Mso::React::IReactContext &context);
-
-  const wchar_t *GetName() const override;
-  void GetNativeProps(const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
-  void GetExportedCustomDirectEventTypeConstants(
-      const winrt::Microsoft::ReactNative::IJSValueWriter &writer) const override;
-  ShadowNode *createShadow() const override;
-
-  YGMeasureFunc GetYogaCustomMeasureFunc() const override;
-  virtual void TransferProperties(const XamlView &oldView, const XamlView &newView) override;
-
- protected:
-  XamlView CreateViewCore(int64_t tag, const winrt::Microsoft::ReactNative::JSValueObject &) override;
-  friend class TextInputShadowNode;
-
- private:
-  void TransferInputScope(const XamlView &oldView, const XamlView &newView, const bool copyToPasswordBox);
-};
-
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/TextViewManager.cpp

@@ -1,414 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#include "pch.h"
-
-#include "TextViewManager.h"
-#include "TouchEventHandler.h"
-#include "Utils/ShadowNodeTypeUtils.h"
-#include "Utils/XamlIslandUtils.h"
-
-#include <Views/ShadowNodeBase.h>
-#include <Views/Text/TextVisitors.h>
-#include <Views/VirtualTextViewManager.h>
-
-#include <UI.Input.h>
-#include <UI.Xaml.Automation.Peers.h>
-#include <UI.Xaml.Automation.h>
-#include <UI.Xaml.Controls.h>
-#include <UI.Xaml.Documents.h>
-#include <UI.Xaml.Input.h>
-#include <Utils/PropertyUtils.h>
-#include <Utils/TransformableText.h>
-#include <Utils/ValueUtils.h>
-
-#ifdef USE_WINUI3
-#include <winrt/Microsoft.UI.Input.h>
-#endif
-
-namespace winrt {
-using namespace xaml::Documents;
-using namespace xaml::Automation;
-using namespace xaml::Automation::Peers;
-} // namespace winrt
-
-namespace Microsoft::ReactNative {
-
-class TextShadowNode final : public ShadowNodeBase {
-  using Super = ShadowNodeBase;
-  friend TextViewManager;
-
- private:
-  bool m_isTextOptimized{true};
-  bool m_hasDescendantTextHighlighter{false};
-  bool m_hasDescendantPressable{false};
-  std::optional<winrt::Windows::UI::Color> m_backgroundColor{};
-  std::optional<winrt::Windows::UI::Color> m_foregroundColor{};
-  std::unique_ptr<TouchEventHandler> m_touchEventHandler = nullptr;
-  winrt::event_revoker<xaml::Controls::ITextBlock> m_selectionChangedRevoker;
-
- public:
-  bool ImplementsPadding() override {
-    return true;
-  }
-
-  void AddView(ShadowNode &child, int64_t index) override {
-    auto &childNode = static_cast<ShadowNodeBase &>(child);
-    ApplyTextTransformToChild(&child);
-
-    if (IsVirtualTextShadowNode(&childNode)) {
-      auto &textChildNode = static_cast<VirtualTextShadowNode &>(childNode);
-      m_hasDescendantTextHighlighter |= textChildNode.hasDescendantTextHighlighter;
-      m_hasDescendantPressable |= textChildNode.hasDescendantPressable;
-    }
-
-    const auto wasOptimized = m_isTextOptimized;
-    m_isTextOptimized = IsRawTextShadowNode(&childNode) && m_isTextOptimized;
-    if (m_isTextOptimized) {
-      // Re-build optimized text from children
-      UpdateOptimizedText();
-    } else if (wasOptimized) {
-      // Remove optimized text and re-construct as Inline tree
-      UpdateOptimizedText(true);
-      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
-        for (size_t i = 0; i < m_children.size(); ++i) {
-          if (const auto childNode =
-                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(m_children[i]))) {
-            Super::AddView(*childNode, i);
-          }
-        }
-      }
-    } else {
-      Super::AddView(child, index);
-    }
-
-    RecalculateTextHighlighters();
-    GetViewManager()->MarkDirty(m_tag);
-  }
-
-  void removeAllChildren() override {
-    if (m_isTextOptimized) {
-      UpdateOptimizedText();
-    } else {
-      Super::removeAllChildren();
-    }
-    RecalculateTextHighlighters();
-    GetViewManager()->MarkDirty(m_tag);
-  }
-
-  void RemoveChildAt(int64_t indexToRemove) override {
-    if (m_isTextOptimized) {
-      UpdateOptimizedText();
-    } else {
-      Super::RemoveChildAt(indexToRemove);
-    }
-    RecalculateTextHighlighters();
-    GetViewManager()->MarkDirty(m_tag);
-  }
-
-  void UpdateOptimizedText(bool clearOptimizedText = false) {
-    if (m_children.size() > 0 && m_isTextOptimized) {
-      if (const auto uiManager = GetNativeUIManager(GetViewManager()->GetReactContext()).lock()) {
-        winrt::hstring text = L"";
-        for (const auto childTag : m_children) {
-          if (const auto childNode =
-                  static_cast<ShadowNodeBase *>(uiManager->getHost()->FindShadowNodeForTag(childTag))) {
-            text = text + childNode->GetView().as<winrt::Run>().Text();
-          }
-        }
-        auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-        textBlock.Text(text);
-      }
-    } else if (m_isTextOptimized || clearOptimizedText) {
-      auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-      textBlock.ClearValue(xaml::Controls::TextBlock::TextProperty());
-    }
-  }
-
-  void RecalculateTextHighlighters() {
-    const auto textBlock = this->GetView().as<xaml::Controls::TextBlock>();
-    textBlock.TextHighlighters().Clear();
-
-    // Since TextShadowNode is not public, we lift some of the recursive
-    // algorithm into the shadow node implementation to detect when no
-    // descendants have background colors and we can skip recursion.
-    if (m_hasDescendantTextHighlighter) {
-      const auto highlighters = GetNestedTextHighlighters(this, m_foregroundColor, m_backgroundColor);
-      if (highlighters.size() == 0) {
-        m_hasDescendantTextHighlighter = false;
-      } else {
-        // We must add the highlighters in reverse order, as highlighters
-        // "deeper" in the text tree should render at the top.
-        auto iter = highlighters.rbegin();
-        while (iter != highlighters.rend()) {
-          textBlock.TextHighlighters().Append(*iter);
-          ++iter;
-        }
-      }
-    }
-
-    if (m_backgroundColor) {
-      winrt::TextHighlighter highlighter{};
-      highlighter.Ranges().Append({0, static_cast<int32_t>(textBlock.Text().size())});
-      highlighter.Background(SolidBrushFromColor(m_backgroundColor.value()));
-      if (m_foregroundColor) {
-        highlighter.Foreground(SolidBrushFromColor(m_foregroundColor.value()));
-      }
-      textBlock.TextHighlighters().InsertAt(0, highlighter);
-    }
-  }
-
-  void ToggleTouchEvents(XamlView xamlView, bool selectable) {
-    if (selectable) {
-      if (m_touchEventHandler == nullptr) {
-        m_touchEventHandler = std::make_unique<TouchEventHandler>(GetViewManager()->GetReactContext());
-      }
-
-      m_selectionChangedRevoker = xamlView.as<xaml::Controls::TextBlock>().SelectionChanged(
-          winrt::auto_revoke, [selectionChanged = this->selectionChanged](const auto &sender, auto &&) {
-            const auto textBlock = sender.as<xaml::Controls::TextBlock>();
-            *selectionChanged =
-                *selectionChanged || textBlock.SelectionStart().Offset() != textBlock.SelectionEnd().Offset();
-          });
-
-      m_touchEventHandler->AddTouchHandlers(xamlView, GetRootView(), true);
-    } else {
-      if (m_touchEventHandler != nullptr) {
-        m_touchEventHandler->RemoveTouchHandlers();
-        m_selectionChangedRevoker.revoke();
-      }
-    }
-  }
-
-  TextTransform textTransform{TextTransform::Undefined};
-  std::shared_ptr<bool> selectionChanged = std::make_shared<bool>(false);
-};
-
-TextViewManager::TextViewManager(const Mso::React::IReactContext &context) : Super(context) {}
-
-ShadowNode *TextViewManager::createShadow() const {
-  return new TextShadowNode();
-}
-
-const wchar_t *TextViewManager::GetName() const {
-  return L"RCTText";
-}
-
-XamlView TextViewManager::CreateViewCore(int64_t /*tag*/, const winrt::Microsoft::ReactNative::JSValueObject &) {
-  auto textBlock = xaml::Controls::TextBlock();
-  textBlock.TextWrapping(xaml::TextWrapping::Wrap); // Default behavior in React Native
-  return textBlock;
-}
-
-void TextViewManager::UpdateProperties(
-    ShadowNodeBase *nodeToUpdate,
-    winrt::Microsoft::ReactNative::JSValueObject &props) {
-  // This could be optimized further, but rather than paying a penalty to mark
-  // the node dirty for each relevant property in UpdateProperty (which should
-  // be reasonably cheap given it just does an O(1) lookup of the Yoga node
-  // for the tag, for now this just marks the node dirty for any prop update.
-  MarkDirty(nodeToUpdate->m_tag);
-  Super::UpdateProperties(nodeToUpdate, props);
-}
-
-bool TextViewManager::UpdateProperty(
-    ShadowNodeBase *nodeToUpdate,
-    const std::string &propertyName,
-    const winrt::Microsoft::ReactNative::JSValue &propertyValue) {
-  auto textBlock = nodeToUpdate->GetView().as<xaml::Controls::TextBlock>();
-  if (textBlock == nullptr)
-    return true;
-
-  if (TryUpdateForeground(textBlock, propertyName, propertyValue)) {
-    const auto node = static_cast<TextShadowNode *>(nodeToUpdate);
-    if (IsValidOptionalColorValue(propertyValue)) {
-      node->m_foregroundColor = OptionalColorFrom(propertyValue);
-      node->RecalculateTextHighlighters();
-    }
-  } else if (TryUpdateFontProperties(textBlock, propertyName, propertyValue)) {
-  } else if (propertyName == "textTransform") {
-    auto textNode = static_cast<TextShadowNode *>(nodeToUpdate);
-    textNode->textTransform = TransformableText::GetTextTransform(propertyValue);
-    UpdateTextTransformForChildren(nodeToUpdate);
-  } else if (TryUpdatePadding(nodeToUpdate, textBlock, propertyName, propertyValue)) {
-  } else if (TryUpdateTextAlignment(textBlock, propertyName, propertyValue)) {
-  } else if (TryUpdateTextTrimming(textBlock, propertyName, propertyValue)) {
-  } else if (TryUpdateTextDecorationLine(textBlock, propertyName, propertyValue)) {
-    // Temporary workaround for bug in XAML which fails to flush old TextDecorationLine render
-    // Link to Bug: https://github.com/microsoft/microsoft-ui-xaml/issues/1093#issuecomment-514282402
-    winrt::hstring text(textBlock.Text().c_str());
-    textBlock.Text(L"");
-    textBlock.Text(text);
-  } else if (TryUpdateCharacterSpacing(textBlock, propertyName, propertyValue)) {
-  } else if (propertyName == "numberOfLines") {
-    if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-        propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-      auto numberLines = propertyValue.AsInt32();
-      if (numberLines == 1) {
-        textBlock.TextWrapping(xaml::TextWrapping::NoWrap); // setting no wrap for single line
-                                                            // text for better trimming
-                                                            // experience
-      } else {
-        textBlock.TextWrapping(xaml::TextWrapping::Wrap);
-      }
-      textBlock.MaxLines(numberLines);
-    } else if (propertyValue.IsNull()) {
-      textBlock.TextWrapping(xaml::TextWrapping::Wrap); // set wrapping back to default
-      textBlock.ClearValue(xaml::Controls::TextBlock::MaxLinesProperty());
-    }
-  } else if (propertyName == "lineHeight") {
-    if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Double ||
-        propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Int64) {
-      textBlock.LineHeight(propertyValue.AsInt32());
-      textBlock.LineStackingStrategy(xaml::LineStackingStrategy::BlockLineHeight);
-    } else if (propertyValue.IsNull()) {
-      textBlock.ClearValue(xaml::Controls::TextBlock::LineHeightProperty());
-      textBlock.ClearValue(xaml::Controls::TextBlock::LineStackingStrategyProperty());
-    }
-  } else if (propertyName == "selectable") {
-    const auto node = static_cast<TextShadowNode *>(nodeToUpdate);
-    if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
-      const auto selectable = propertyValue.AsBoolean();
-      textBlock.IsTextSelectionEnabled(selectable);
-      node->ToggleTouchEvents(textBlock, selectable);
-      if (selectable) {
-        EnsureUniqueTextFlyoutForXamlIsland(textBlock);
-      }
-    } else if (propertyValue.IsNull()) {
-      textBlock.ClearValue(xaml::Controls::TextBlock::IsTextSelectionEnabledProperty());
-      node->ToggleTouchEvents(textBlock, false);
-      ClearUniqueTextFlyoutForXamlIsland(textBlock);
-    }
-  } else if (propertyName == "allowFontScaling") {
-    if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::Boolean) {
-      textBlock.IsTextScaleFactorEnabled(propertyValue.AsBoolean());
-    } else {
-      textBlock.ClearValue(xaml::Controls::TextBlock::IsTextScaleFactorEnabledProperty());
-    }
-  } else if (propertyName == "selectionColor") {
-    if (IsValidColorValue(propertyValue)) {
-      textBlock.SelectionHighlightColor(SolidColorBrushFrom(propertyValue));
-    } else
-      textBlock.ClearValue(xaml::Controls::TextBlock::SelectionHighlightColorProperty());
-  } else if (propertyName == "backgroundColor") {
-    const auto node = static_cast<TextShadowNode *>(nodeToUpdate);
-    if (IsValidOptionalColorValue(propertyValue)) {
-      node->m_backgroundColor = OptionalColorFrom(propertyValue);
-      node->RecalculateTextHighlighters();
-    }
-  } else if (propertyName == "accessibilityRole") {
-    if (propertyValue.Type() == winrt::Microsoft::ReactNative::JSValueType::String) {
-      const std::string &role = propertyValue.AsString();
-      auto value = asHstring(propertyValue);
-      auto boxedValue = winrt::Windows::Foundation::PropertyValue::CreateString(value);
-
-      textBlock.SetValue(winrt::AutomationProperties::LocalizedControlTypeProperty(), boxedValue);
-      if (role == "header") {
-        xaml::Automation::AutomationProperties::SetHeadingLevel(
-            textBlock, winrt::Peers::AutomationHeadingLevel::Level2);
-      } else {
-        textBlock.ClearValue(winrt::AutomationProperties::HeadingLevelProperty());
-      }
-    } else if (propertyValue.IsNull()) {
-      textBlock.ClearValue(winrt::AutomationProperties::LocalizedControlTypeProperty());
-      textBlock.ClearValue(winrt::AutomationProperties::HeadingLevelProperty());
-    }
-  } else {
-    return Super::UpdateProperty(nodeToUpdate, propertyName, propertyValue);
-  }
-
-  return true;
-}
-
-void TextViewManager::AddView(const XamlView &parent, const XamlView &child, int64_t index) {
-  auto textBlock(parent.as<xaml::Controls::TextBlock>());
-
-  if (auto childInline = child.try_as<winrt::Inline>()) {
-    textBlock.Inlines().InsertAt(static_cast<uint32_t>(index), childInline);
-  } else {
-    // #6315 Text can embed non-text elements. Fail gracefully instead of crashing if that happens
-    textBlock.Inlines().InsertAt(static_cast<uint32_t>(index), winrt::Run());
-    GetReactContext().CallJSFunction(
-        "RCTLog",
-        "logToConsole",
-        folly::dynamic::array(
-            "warn", "React Native for Windows does not yet support nesting non-Text components under <Text>"));
-  }
-}
-
-void TextViewManager::RemoveAllChildren(const XamlView &parent) {
-  auto textBlock(parent.as<xaml::Controls::TextBlock>());
-  textBlock.Inlines().Clear();
-}
-
-void TextViewManager::RemoveChildAt(const XamlView &parent, int64_t index) {
-  auto textBlock(parent.as<xaml::Controls::TextBlock>());
-  return textBlock.Inlines().RemoveAt(static_cast<uint32_t>(index));
-}
-
-YGMeasureFunc TextViewManager::GetYogaCustomMeasureFunc() const {
-  return DefaultYogaSelfMeasureFunc;
-}
-
-void TextViewManager::OnPointerEvent(
-    ShadowNodeBase *node,
-    winrt::Microsoft::ReactNative::ReactPointerEventArgs const &args) {
-  const auto textNode = static_cast<TextShadowNode *>(node);
-  const auto textBlock = node->GetView().as<xaml::Controls::TextBlock>();
-  if (textNode->m_hasDescendantPressable && args.Target() == node->GetView()) {
-    // Set the target to null temporarily
-    args.Target(nullptr);
-
-    // Get the pointer point and hit test
-    const auto point = args.Args().GetCurrentPoint(textBlock).Position();
-    HitTest(node, args, point);
-
-    // Set the target back to the current view if hit test failed
-    if (!args.Target()) {
-      args.Target(node->GetView());
-    }
-  }
-
-  if (args.Kind() == winrt::Microsoft::ReactNative::PointerEventKind::CaptureLost) {
-    if (!*textNode->selectionChanged) {
-      args.Kind(winrt::Microsoft::ReactNative::PointerEventKind::End);
-    }
-    *textNode->selectionChanged = false;
-  }
-
-  Super::OnPointerEvent(node, args);
-}
-
-/*static*/ void TextViewManager::UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded) {
-  if (IsTextShadowNode(node)) {
-    const auto textNode = static_cast<TextShadowNode *>(node);
-    if (highlightAdded) {
-      textNode->m_hasDescendantTextHighlighter = true;
-    }
-    textNode->RecalculateTextHighlighters();
-  }
-}
-
-/*static*/ void TextViewManager::UpdateOptimizedText(ShadowNodeBase *node) {
-  if (IsTextShadowNode(node)) {
-    const auto textNode = static_cast<TextShadowNode *>(node);
-    textNode->UpdateOptimizedText();
-  }
-}
-
-/*static*/ void TextViewManager::SetDescendantPressable(ShadowNodeBase *node) {
-  if (IsTextShadowNode(node)) {
-    const auto textNode = static_cast<TextShadowNode *>(node);
-    textNode->m_hasDescendantPressable = true;
-  }
-}
-
-/*static*/ TextTransform TextViewManager::GetTextTransformValue(ShadowNodeBase *node) {
-  if (IsTextShadowNode(node)) {
-    return static_cast<TextShadowNode *>(node)->textTransform;
-  }
-
-  return TextTransform::Undefined;
-}
-
-} // namespace Microsoft::ReactNative

package/Microsoft.ReactNative/Views/TextViewManager.h

@@ -1,47 +0,0 @@
-// Copyright (c) Microsoft Corporation.
-// Licensed under the MIT License.
-
-#pragma once
-
-#include <Utils/TextTransform.h>
-#include <Views/FrameworkElementViewManager.h>
-
-namespace Microsoft::ReactNative {
-
-class TextViewManager : public FrameworkElementViewManager {
-  using Super = FrameworkElementViewManager;
-
- public:
-  TextViewManager(const Mso::React::IReactContext &context);
-
-  ShadowNode *createShadow() const override;
-
-  const wchar_t *GetName() const override;
-
-  void AddView(const XamlView &parent, const XamlView &child, int64_t index) override;
-  void RemoveAllChildren(const XamlView &parent) override;
-  void RemoveChildAt(const XamlView &parent, int64_t index) override;
-  void UpdateProperties(ShadowNodeBase *nodeToUpdate, winrt::Microsoft::ReactNative::JSValueObject &props) override;
-
-  YGMeasureFunc GetYogaCustomMeasureFunc() const override;
-
-  void OnPointerEvent(ShadowNodeBase *node, const winrt::Microsoft::ReactNative::ReactPointerEventArgs &args) override;
-
-  static void UpdateTextHighlighters(ShadowNodeBase *node, bool highlightAdded);
-
-  static void UpdateOptimizedText(ShadowNodeBase *node);
-
-  static void SetDescendantPressable(ShadowNodeBase *node);
-
-  static TextTransform GetTextTransformValue(ShadowNodeBase *node);
-
- protected:
-  bool UpdateProperty(
-      ShadowNodeBase *nodeToUpdate,
-      const std::string &propertyName,
-      const winrt::Microsoft::ReactNative::JSValue &propertyValue) override;
-
-  XamlView CreateViewCore(int64_t tag, const winrt::Microsoft::ReactNative::JSValueObject &) override;
-};
-
-} // namespace Microsoft::ReactNative