• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_TEXT_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_TEXT_PATTERN_H
18 
19 #include <limits>
20 #include <optional>
21 #include <string>
22 #include <unordered_map>
23 
24 #include "interfaces/inner_api/ace/ai/data_detector_interface.h"
25 
26 #include "base/geometry/dimension.h"
27 #include "base/geometry/ng/offset_t.h"
28 #include "base/memory/referenced.h"
29 #include "base/utils/noncopyable.h"
30 #include "base/utils/utils.h"
31 #include "core/common/ai/data_detector_adapter.h"
32 #include "core/components_ng/event/long_press_event.h"
33 #include "core/components_ng/pattern/pattern.h"
34 #include "core/components_ng/pattern/rich_editor/paragraph_manager.h"
35 #include "core/components_ng/pattern/rich_editor/selection_info.h"
36 #include "core/components_ng/pattern/rich_editor_drag/rich_editor_drag_info.h"
37 #include "core/components_ng/pattern/scrollable/scrollable_pattern.h"
38 #include "core/components_ng/pattern/select_overlay/magnifier.h"
39 #include "core/components_ng/pattern/text/layout_info_interface.h"
40 #include "core/components_ng/pattern/text/multiple_click_recognizer.h"
41 #include "core/components_ng/pattern/text/span/mutable_span_string.h"
42 #include "core/components_ng/pattern/text/span/span_object.h"
43 #include "core/components_ng/pattern/text/span/span_string.h"
44 #include "core/components_ng/pattern/text/span_node.h"
45 #include "core/components_ng/pattern/text/text_accessibility_property.h"
46 #include "core/components_ng/pattern/text/text_base.h"
47 #include "core/components_ng/pattern/text/text_content_modifier.h"
48 #include "core/components_ng/pattern/text/text_controller.h"
49 #include "core/components_ng/pattern/text/text_event_hub.h"
50 #include "core/components_ng/pattern/text/text_layout_algorithm.h"
51 #include "core/components_ng/pattern/text/text_layout_property.h"
52 #include "core/components_ng/pattern/text/text_overlay_modifier.h"
53 #include "core/components_ng/pattern/text/text_paint_method.h"
54 #include "core/components_ng/pattern/text/text_select_overlay.h"
55 #include "core/components_ng/pattern/text_drag/text_drag_base.h"
56 #include "core/components_ng/pattern/text_field/text_selector.h"
57 #include "core/components_ng/property/property.h"
58 #include "core/event/ace_events.h"
59 #include "core/pipeline_ng/ui_task_scheduler.h"
60 
61 namespace OHOS::Ace::NG {
62 namespace {
63 constexpr int32_t MAX_SIZE_OF_LOG = 2000;
64 }
65 
66 class InspectorFilter;
67 enum class Status { DRAGGING, FLOATING, ON_DROP, NONE };
68 using CalculateHandleFunc = std::function<void()>;
69 using ShowSelectOverlayFunc = std::function<void(const RectF&, const RectF&)>;
70 struct SpanNodeInfo {
71     RefPtr<UINode> node;
72     RefPtr<UINode> containerSpanNode;
73 };
74 enum class SelectionMenuCalblackId { MENU_APPEAR, MENU_SHOW, MENU_HIDE };
75 
76 // TextPattern is the base class for text render node to perform paint text.
77 class TextPattern : public virtual Pattern,
78                     public TextDragBase,
79                     public TextBase,
80                     public TextGestureSelector,
81                     public Magnifier,
82                     public LayoutInfoInterface {
83     DECLARE_ACE_TYPE(TextPattern, Pattern, TextDragBase, TextBase, TextGestureSelector, Magnifier);
84 
85 public:
TextPattern()86     TextPattern()
87     {
88         selectOverlay_ = AceType::MakeRefPtr<TextSelectOverlay>(WeakClaim(this));
89         pManager_ = AceType::MakeRefPtr<ParagraphManager>();
90         ResetOriginCaretPosition();
91     }
92 
93     ~TextPattern() override;
94 
95     SelectionInfo GetSpansInfo(int32_t start, int32_t end, GetSpansMethod method);
96     std::list<ResultObject> GetSpansInfoInStyledString(int32_t start, int32_t end);
97 
98     virtual int32_t GetTextContentLength();
99 
100     RefPtr<NodePaintMethod> CreateNodePaintMethod() override;
101 
CreateLayoutProperty()102     RefPtr<LayoutProperty> CreateLayoutProperty() override
103     {
104         return MakeRefPtr<TextLayoutProperty>();
105     }
106 
CreateLayoutAlgorithm()107     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
108     {
109         auto textLayoutProperty = GetLayoutProperty<TextLayoutProperty>();
110         if (textLayoutProperty &&
111             textLayoutProperty->GetTextOverflowValue(TextOverflow::CLIP) == TextOverflow::MARQUEE) {
112             return MakeRefPtr<TextLayoutAlgorithm>(spans_, pManager_, isSpanStringMode_, true);
113         } else {
114             return MakeRefPtr<TextLayoutAlgorithm>(spans_, pManager_, isSpanStringMode_);
115         }
116     }
117 
CreateAccessibilityProperty()118     RefPtr<AccessibilityProperty> CreateAccessibilityProperty() override
119     {
120         return MakeRefPtr<TextAccessibilityProperty>();
121     }
122 
CreateEventHub()123     RefPtr<EventHub> CreateEventHub() override
124     {
125         return MakeRefPtr<TextEventHub>();
126     }
127 
IsDragging()128     virtual bool IsDragging() const
129     {
130         return status_ == Status::DRAGGING;
131     }
132 
IsAtomicNode()133     bool IsAtomicNode() const override
134     {
135         auto host = GetHost();
136         CHECK_NULL_RETURN(host, false);
137         return host->GetTag() == V2::SYMBOL_ETS_TAG;
138     }
139 
IsTextNode()140     bool IsTextNode() const
141     {
142         auto host = GetHost();
143         CHECK_NULL_RETURN(host, false);
144         return host->GetTag() == V2::TEXT_ETS_TAG;
145     }
146 
DefaultSupportDrag()147     bool DefaultSupportDrag() override
148     {
149         return true;
150     }
151 
152     void OnModifyDone() override;
153 
154     void OnWindowHide() override;
155 
156     void OnWindowShow() override;
157 
158     void PreCreateLayoutWrapper();
159 
160     void BeforeCreateLayoutWrapper() override;
161 
162     void AddChildSpanItem(const RefPtr<UINode>& child);
163     void AddImageToSpanItem(const RefPtr<UINode>& child);
164 
GetFocusPattern()165     FocusPattern GetFocusPattern() const override
166     {
167         return { FocusType::NODE, false };
168     }
169 
170     void DumpAdvanceInfo() override;
171     void DumpInfo() override;
172     void DumpInfo(std::unique_ptr<JsonValue>& json) override;
173     void DumpAdvanceInfo(std::unique_ptr<JsonValue>& json) override;
174     void SetTextStyleDumpInfo(std::unique_ptr<JsonValue>& json);
175     void DumpSimplifyInfo(std::unique_ptr<JsonValue>& json) override;
176     void DumpTextStyleInfo();
177     void DumpTextStyleInfo2();
178     void DumpTextStyleInfo3();
179     void DumpSpanItem();
180     void DumpScaleInfo();
181     void DumpTextEngineInfo();
182     void DumpParagraphsInfo();
183 
GetTextSelector()184     TextSelector GetTextSelector() const
185     {
186         return textSelector_;
187     }
188 
GetTextForDisplay()189     const std::u16string& GetTextForDisplay() const
190     {
191         return textForDisplay_;
192     }
193 
GetStartOffset()194     const OffsetF& GetStartOffset() const
195     {
196         return textSelector_.selectionBaseOffset;
197     }
198 
GetEndOffset()199     const OffsetF& GetEndOffset() const
200     {
201         return textSelector_.selectionDestinationOffset;
202     }
203 
GetSelectHeight()204     double GetSelectHeight() const
205     {
206         return textSelector_.GetSelectHeight();
207     }
208 
209     void GetGlobalOffset(Offset& offset);
210 
211     RectF GetTextContentRect(bool isActualText = false) const override;
212 
GetBaselineOffset()213     float GetBaselineOffset() const
214     {
215         return baselineOffset_;
216     }
217 
GetContentModifier()218     RefPtr<TextContentModifier> GetContentModifier()
219     {
220         return contentMod_;
221     }
222 
223     void SetTextDetectEnable(bool enable);
GetTextDetectEnable()224     bool GetTextDetectEnable()
225     {
226         return textDetectEnable_;
227     }
SetTextDetectTypes(const std::string & types)228     void SetTextDetectTypes(const std::string& types)
229     {
230         dataDetectorAdapter_->SetTextDetectTypes(types);
231         textDetectTypes_ = types; // url value is not recorded in dataDetectorAdapter_, need to record it here
232     }
GetTextDetectTypes()233     std::string GetTextDetectTypes()
234     {
235         return textDetectTypes_;
236     }
GetDataDetectorAdapter()237     RefPtr<DataDetectorAdapter> GetDataDetectorAdapter()
238     {
239         return dataDetectorAdapter_;
240     }
GetAISpanMap()241     virtual const std::map<int32_t, AISpan>& GetAISpanMap()
242     {
243         return dataDetectorAdapter_->aiSpanMap_;
244     }
GetTextForAI()245     const std::u16string& GetTextForAI()
246     {
247         return dataDetectorAdapter_->textForAI_;
248     }
SetOnResult(std::function<void (const std::string &)> && onResult)249     void SetOnResult(std::function<void(const std::string&)>&& onResult)
250     {
251         dataDetectorAdapter_->onResult_ = std::move(onResult);
252     }
GetTextDetectResult()253     TextDataDetectResult GetTextDetectResult()
254     {
255         return dataDetectorAdapter_->textDetectResult_;
256     }
SetTextDetectConfig(const TextDetectConfig & textDetectConfig)257     void SetTextDetectConfig(const TextDetectConfig& textDetectConfig)
258     {
259         dataDetectorAdapter_->SetTextDetectTypes(textDetectConfig.types);
260         dataDetectorAdapter_->onResult_ = std::move(textDetectConfig.onResult);
261         dataDetectorAdapter_->entityColor_ = textDetectConfig.entityColor;
262         dataDetectorAdapter_->entityDecorationType_ = textDetectConfig.entityDecorationType;
263         dataDetectorAdapter_->entityDecorationColor_ = textDetectConfig.entityDecorationColor;
264         dataDetectorAdapter_->entityDecorationStyle_ = textDetectConfig.entityDecorationStyle;
265         auto textDetectConfigCache = dataDetectorAdapter_->textDetectConfigStr_;
266         dataDetectorAdapter_->textDetectConfigStr_ = textDetectConfig.ToString();
267         if (textDetectConfigCache != dataDetectorAdapter_->textDetectConfigStr_) {
268             auto host = GetHost();
269             CHECK_NULL_VOID(host);
270             host->MarkDirtyWithOnProChange(PROPERTY_UPDATE_MEASURE);
271         }
272     }
ModifyAISpanStyle(TextStyle & aiSpanStyle)273     void ModifyAISpanStyle(TextStyle& aiSpanStyle)
274     {
275         TextDetectConfig textDetectConfig;
276         aiSpanStyle.SetTextColor(dataDetectorAdapter_->entityColor_.value_or(textDetectConfig.entityColor));
277         aiSpanStyle.SetTextDecoration(
278             dataDetectorAdapter_->entityDecorationType_.value_or(textDetectConfig.entityDecorationType));
279         aiSpanStyle.SetTextDecorationColor(
280             dataDetectorAdapter_->entityDecorationColor_.value_or(textDetectConfig.entityColor));
281         aiSpanStyle.SetTextDecorationStyle(
282             dataDetectorAdapter_->entityDecorationStyle_.value_or(textDetectConfig.entityDecorationStyle));
283     }
284 
285     void OnVisibleChange(bool isVisible) override;
286 
GetSpanItemChildren()287     std::list<RefPtr<SpanItem>> GetSpanItemChildren()
288     {
289         return spans_;
290     }
291 
GetDisplayWideTextLength()292     int32_t GetDisplayWideTextLength()
293     {
294         return textForDisplay_.length();
295     }
296 
297     // ===========================================================
298     // TextDragBase implementations
299 
IsTextArea()300     bool IsTextArea() const override
301     {
302         return false;
303     }
304 
GetTextRect()305     const RectF& GetTextRect() override
306     {
307         return contentRect_;
308     }
309     float GetLineHeight() const override;
310 
311     std::vector<RectF> GetTextBoxes() override;
312     OffsetF GetParentGlobalOffset() const override;
313 
MoveDragNode()314     const RefPtr<FrameNode>& MoveDragNode() override
315     {
316         return dragNode_;
317     }
318 
GetDragParagraph()319     const RefPtr<Paragraph>& GetDragParagraph() const override
320     {
321         return pManager_->GetParagraphs().front().paragraph;
322     }
323 
CloseKeyboard(bool)324     bool CloseKeyboard(bool /* forceClose */) override
325     {
326         return true;
327     }
328     virtual void CloseSelectOverlay() override;
329     void CloseSelectOverlay(bool animation);
330     void CreateHandles() override;
331     bool BetweenSelectedPosition(const Offset& globalOffset) override;
332 
333     // end of TextDragBase implementations
334     // ===========================================================
335 
336     void InitSurfaceChangedCallback();
337     void InitSurfacePositionChangedCallback();
338     virtual void HandleSurfaceChanged(
339         int32_t newWidth, int32_t newHeight, int32_t prevWidth, int32_t prevHeight, WindowSizeChangeReason type);
HandleSurfacePositionChanged(int32_t posX,int32_t posY)340     virtual void HandleSurfacePositionChanged(int32_t posX, int32_t posY) {};
HasSurfaceChangedCallback()341     bool HasSurfaceChangedCallback()
342     {
343         return surfaceChangedCallbackId_.has_value();
344     }
UpdateSurfaceChangedCallbackId(int32_t id)345     void UpdateSurfaceChangedCallbackId(int32_t id)
346     {
347         surfaceChangedCallbackId_ = id;
348     }
349 
HasSurfacePositionChangedCallback()350     bool HasSurfacePositionChangedCallback()
351     {
352         return surfacePositionChangedCallbackId_.has_value();
353     }
UpdateSurfacePositionChangedCallbackId(int32_t id)354     void UpdateSurfacePositionChangedCallbackId(int32_t id)
355     {
356         surfacePositionChangedCallbackId_ = id;
357     }
358 
359     void SetOnClickEvent(GestureEventFunc&& onClick, double distanceThreshold = std::numeric_limits<double>::infinity())
360     {
361         onClick_ = std::move(onClick);
362         distanceThreshold_ = distanceThreshold;
363     }
364 
365     NG::DragDropInfo OnDragStart(const RefPtr<Ace::DragEvent>& event, const std::string& extraParams);
366     DragDropInfo OnDragStartNoChild(const RefPtr<Ace::DragEvent>& event, const std::string& extraParams);
367     void InitDragEvent();
368     void ClearDragEvent();
369     void UpdateSpanItemDragStatus(const std::list<ResultObject>& resultObjects, bool IsDragging);
370     void OnDragMove(const RefPtr<Ace::DragEvent>& event);
371     virtual std::function<void(Offset)> GetThumbnailCallback();
372     std::list<ResultObject> dragResultObjects_;
373     std::list<ResultObject> recoverDragResultObjects_;
374     std::vector<RefPtr<SpanItem>> dragSpanItems_;
375     void OnDragEnd(const RefPtr<Ace::DragEvent>& event);
376     void OnDragEndNoChild(const RefPtr<Ace::DragEvent>& event);
377     void CloseOperate();
378     virtual void AddUdmfData(const RefPtr<Ace::DragEvent>& event);
379     void ProcessNormalUdmfData(const RefPtr<UnifiedData>& unifiedData);
380     void AddPixelMapToUdmfData(const RefPtr<PixelMap>& pixelMap, const RefPtr<UnifiedData>& unifiedData);
381 
382     std::u16string GetSelectedSpanText(std::u16string value, int32_t start, int32_t end, bool includeStartHalf = false,
383         bool includeEndHalf = true, bool getSubstrDirectly = true) const;
384     TextStyleResult GetTextStyleObject(const RefPtr<SpanNode>& node);
385     SymbolSpanStyle GetSymbolSpanStyleObject(const RefPtr<SpanNode>& node);
386     virtual RefPtr<UINode> GetChildByIndex(int32_t index) const;
387     RefPtr<SpanItem> GetSpanItemByIndex(int32_t index) const;
388     ResultObject GetTextResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
389     virtual void SetResultObjectText(ResultObject& resultObject, const RefPtr<SpanItem>& spanItem);
390     ResultObject GetSymbolSpanResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
391     ResultObject GetImageResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
392     std::string GetFontInJson() const;
393     std::string GetBindSelectionMenuInJson() const;
FillPreviewMenuInJson(const std::unique_ptr<JsonValue> & jsonValue)394     virtual void FillPreviewMenuInJson(const std::unique_ptr<JsonValue>& jsonValue) const {}
395     std::string GetFontSizeWithThemeInJson(const std::optional<Dimension>& value) const;
396 
GetDragContents()397     const std::vector<std::u16string>& GetDragContents() const
398     {
399         return dragContents_;
400     }
401 
InitSpanImageLayout(const std::vector<int32_t> & placeholderIndex,const std::vector<RectF> & rectsForPlaceholders,OffsetF contentOffset)402     void InitSpanImageLayout(const std::vector<int32_t>& placeholderIndex,
403         const std::vector<RectF>& rectsForPlaceholders, OffsetF contentOffset) override
404     {
405         placeholderIndex_ = placeholderIndex;
406         imageOffset_ = contentOffset;
407         rectsForPlaceholders_ = rectsForPlaceholders;
408     }
409 
GetPlaceHolderIndex()410     const std::vector<int32_t>& GetPlaceHolderIndex()
411     {
412         return placeholderIndex_;
413     }
414 
GetRectsForPlaceholders()415     const std::vector<RectF>& GetRectsForPlaceholders()
416     {
417         return rectsForPlaceholders_;
418     }
419 
GetContentOffset()420     OffsetF GetContentOffset() override
421     {
422         return imageOffset_;
423     }
424 
IsMeasureBoundary()425     bool IsMeasureBoundary() const override
426     {
427         return isMeasureBoundary_;
428     }
429 
SetIsMeasureBoundary(bool isMeasureBoundary)430     void SetIsMeasureBoundary(bool isMeasureBoundary)
431     {
432         isMeasureBoundary_ = isMeasureBoundary;
433     }
434 
SetIsCustomFont(bool isCustomFont)435     void SetIsCustomFont(bool isCustomFont)
436     {
437         isCustomFont_ = isCustomFont;
438     }
439 
GetIsCustomFont()440     bool GetIsCustomFont()
441     {
442         return isCustomFont_;
443     }
444 
SetImageSpanNodeList(std::vector<WeakPtr<FrameNode>> imageNodeList)445     void SetImageSpanNodeList(std::vector<WeakPtr<FrameNode>> imageNodeList)
446     {
447         imageNodeList_ = imageNodeList;
448     }
449 
GetImageSpanNodeList()450     std::vector<WeakPtr<FrameNode>> GetImageSpanNodeList()
451     {
452         return imageNodeList_;
453     }
454     // Deprecated: Use the TextSelectOverlay::ProcessOverlay() instead.
455     // It is currently used by RichEditorPattern.
456     virtual void UpdateSelectOverlayOrCreate(SelectOverlayInfo& selectInfo, bool animation = false);
457     // Deprecated: Use the TextSelectOverlay::CheckHandleVisible() instead.
458     // It is currently used by RichEditorPattern.
CheckHandles(SelectHandleInfo & handleInfo)459     virtual void CheckHandles(SelectHandleInfo& handleInfo) {};
460     OffsetF GetDragUpperLeftCoordinates() override;
461     void SetTextSelection(int32_t selectionStart, int32_t selectionEnd);
462 
463     // Deprecated: Use the TextSelectOverlay::OnHandleMove() instead.
464     // It is currently used by RichEditorPattern.
465     void OnHandleMove(const RectF& handleRect, bool isFirstHandle) override;
466 
GetParagraphs()467     virtual std::vector<ParagraphManager::ParagraphInfo> GetParagraphs() const
468     {
469         std::vector<ParagraphManager::ParagraphInfo> res;
470         CHECK_NULL_RETURN(pManager_, res);
471         return pManager_->GetParagraphs();
472     }
473 
GetParagraphManager()474     const RefPtr<ParagraphManager>& GetParagraphManager() const
475     {
476         return pManager_;
477     }
478 
MarkContentChange()479     void MarkContentChange()
480     {
481         contChange_ = true;
482     }
483 
ResetContChange()484     void ResetContChange()
485     {
486         contChange_ = false;
487     }
488 
GetContChange()489     bool GetContChange() const
490     {
491         return contChange_;
492     }
493 
GetShowSelect()494     bool GetShowSelect() const
495     {
496         return showSelect_;
497     }
498 
GetRecoverStart()499     int32_t GetRecoverStart() const
500     {
501         return recoverStart_;
502     }
503 
GetRecoverEnd()504     int32_t GetRecoverEnd() const
505     {
506         return recoverEnd_;
507     }
508 
509     void OnHandleAreaChanged() override;
510     void RemoveAreaChangeInner();
511 
ResetDragOption()512     void ResetDragOption() override
513     {
514         CloseSelectOverlay();
515         ResetSelection();
516     }
517     virtual bool NeedShowAIDetect();
518 
GetDragRecordSize()519     int32_t GetDragRecordSize() override
520     {
521         return dragRecordSize_;
522     }
523 
ResetDragRecordSize(int32_t size)524     void ResetDragRecordSize(int32_t size)
525     {
526         dragRecordSize_ = size;
527     }
528 
529     void BindSelectionMenu(TextSpanType spanType, TextResponseType responseType, std::function<void()>& menuBuilder,
530         const SelectMenuParam& menuParam);
531 
SetTextController(const RefPtr<TextController> & controller)532     void SetTextController(const RefPtr<TextController>& controller)
533     {
534         textController_ = controller;
535     }
536 
GetTextController()537     const RefPtr<TextController>& GetTextController()
538     {
539         return textController_;
540     }
541 
542     void CloseSelectionMenu();
543 
ClearSelectionMenu()544     void ClearSelectionMenu()
545     {
546         selectionMenuMap_.clear();
547     }
548 
549     virtual const std::list<RefPtr<UINode>>& GetAllChildren() const;
550 
551     void StartVibratorByIndexChange(int32_t currentIndex, int32_t preIndex);
552 
553     void HandleSelectionChange(int32_t start, int32_t end);
554 
GetCopyOptions()555     CopyOptions GetCopyOptions() const
556     {
557         return copyOption_;
558     }
559     bool CheckClickedOnSpanOrText(RectF textContentRect, const Offset& localLocation);
560 
561     // style string
SetSpanItemChildren(const std::list<RefPtr<SpanItem>> & spans)562     void SetSpanItemChildren(const std::list<RefPtr<SpanItem>>& spans)
563     {
564         spans_ = spans;
565     }
SetSpanStringMode(bool isSpanStringMode)566     void SetSpanStringMode(bool isSpanStringMode)
567     {
568         isSpanStringMode_ = isSpanStringMode;
569     }
GetSpanStringMode()570     bool GetSpanStringMode() const
571     {
572         return isSpanStringMode_;
573     }
AllocStyledString()574     void AllocStyledString()
575     {
576         if (!styledString_) {
577             styledString_ = MakeRefPtr<MutableSpanString>(u"");
578         }
579     }
580     void SetStyledString(const RefPtr<SpanString>& value, bool closeSelectOverlay = true);
581     // select overlay
582     virtual int32_t GetHandleIndex(const Offset& offset) const;
583     std::u16string GetSelectedText(int32_t start, int32_t end, bool includeStartHalf = false,
584         bool includeEndHalf = false, bool getSubstrDirectly = false) const;
585     void UpdateSelectionSpanType(int32_t selectStart, int32_t selectEnd);
586     void CalculateHandleOffsetAndShowOverlay(bool isUsingMouse = false);
587     void ResetSelection();
588     bool IsSelectAll();
589     void HandleOnCopy();
590     void HandleOnCopySpanString();
591     virtual void HandleOnSelectAll();
592     bool IsShowTranslate();
593     bool IsShowSearch();
594     void SetTextSelectableMode(TextSelectableMode value);
595 
GetTextPaintOffset()596     OffsetF GetTextPaintOffset() const override
597     {
598         return parentGlobalOffset_;
599     }
600 
SetTextResponseType(TextResponseType type)601     void SetTextResponseType(TextResponseType type)
602     {
603         textResponseType_ = type;
604     }
605 
IsSelectedTypeChange()606     bool IsSelectedTypeChange()
607     {
608         return selectedType_.has_value() && oldSelectedType_ != selectedType_.value();
609     }
610 
CheckSelectedTypeChange()611     bool CheckSelectedTypeChange()
612     {
613         auto changed = IsSelectedTypeChange();
614         if (changed) {
615             oldSelectedType_ = selectedType_.value();
616         }
617         return changed;
618     }
619 
IsUsingMouse()620     bool IsUsingMouse()
621     {
622         return sourceType_ == SourceType::MOUSE;
623     }
624 
625     void OnSensitiveStyleChange(bool isSensitive) override;
626 
627     bool IsSetObscured();
628     bool IsSensitiveEnalbe();
629 
CopySelectionMenuParams(SelectOverlayInfo & selectInfo)630     void CopySelectionMenuParams(SelectOverlayInfo& selectInfo)
631     {
632         CopySelectionMenuParams(selectInfo, textResponseType_.value_or(TextResponseType::NONE));
633     }
634 
InitCustomSpanPlaceholderInfo(const std::vector<CustomSpanPlaceholderInfo> & customSpanPlaceholder)635     void InitCustomSpanPlaceholderInfo(const std::vector<CustomSpanPlaceholderInfo>& customSpanPlaceholder)
636     {
637         customSpanPlaceholder_ = customSpanPlaceholder;
638     }
639 
GetCustomSpanPlaceholderInfo()640     std::vector<CustomSpanPlaceholderInfo> GetCustomSpanPlaceholderInfo()
641     {
642         return customSpanPlaceholder_;
643     }
644 
ClearCustomSpanPlaceholderInfo()645     void ClearCustomSpanPlaceholderInfo()
646     {
647         customSpanPlaceholder_.clear();
648     }
649 
GetChildNodes()650     const std::list<RefPtr<UINode>>& GetChildNodes() const
651     {
652         return childNodes_;
653     }
654     // add for capi NODE_TEXT_CONTENT_WITH_STYLED_STRING
SetExternalParagraph(void * paragraph)655     void SetExternalParagraph(void* paragraph)
656     {
657         ACE_TEXT_SCOPED_TRACE("SetExternalParagraph");
658         externalParagraph_ = paragraph;
659     }
660 
GetExternalParagraph()661     const std::optional<void*>& GetExternalParagraph()
662     {
663         return externalParagraph_;
664     }
665 
666     void SetExternalSpanItem(const std::list<RefPtr<SpanItem>>& spans);
667 
SetExternalParagraphStyle(std::optional<ParagraphStyle> paragraphStyle)668     void SetExternalParagraphStyle(std::optional<ParagraphStyle> paragraphStyle)
669     {
670         externalParagraphStyle_ = paragraphStyle;
671     }
672 
GetTextStyle()673     TextStyle GetTextStyle()
674     {
675         return textStyle_.value_or(TextStyle());
676     }
677 
678     bool DidExceedMaxLines() const override;
679 
GetExternalParagraphStyle()680     std::optional<ParagraphStyle> GetExternalParagraphStyle()
681     {
682         return externalParagraphStyle_;
683     }
684 
685     size_t GetLineCount() const override;
686     TextLineMetrics GetLineMetrics(int32_t lineNumber) override;
687     std::vector<ParagraphManager::TextBox> GetRectsForRange(int32_t start, int32_t end,
688         RectHeightStyle heightStyle, RectWidthStyle widthStyle) override;
689     PositionWithAffinity GetGlyphPositionAtCoordinate(int32_t x, int32_t y) override;
690 
691     void OnSelectionMenuOptionsUpdate(
692         const NG::OnCreateMenuCallback&& onCreateMenuCallback, const NG::OnMenuItemClickCallback&& onMenuItemClick);
693 
OnCreateMenuCallbackUpdate(const NG::OnCreateMenuCallback && onCreateMenuCallback)694     void OnCreateMenuCallbackUpdate(const NG::OnCreateMenuCallback&& onCreateMenuCallback)
695     {
696         selectOverlay_->OnCreateMenuCallbackUpdate(std::move(onCreateMenuCallback));
697     }
698 
OnMenuItemClickCallbackUpdate(const NG::OnMenuItemClickCallback && onMenuItemClick)699     void OnMenuItemClickCallbackUpdate(const NG::OnMenuItemClickCallback&& onMenuItemClick)
700     {
701         selectOverlay_->OnMenuItemClickCallbackUpdate(std::move(onMenuItemClick));
702     }
703 
704     void OnFrameNodeChanged(FrameNodeChangeInfoFlag flag) override;
705 
UpdateParentGlobalOffset()706     void UpdateParentGlobalOffset()
707     {
708         parentGlobalOffset_ = GetParentGlobalOffset();
709     }
710 
SetPrintInfo(const std::string & area,const OffsetF & paintOffset)711     void SetPrintInfo(const std::string& area, const OffsetF& paintOffset)
712     {
713         paintInfo_ = area + paintOffset.ToString();
714     }
715 
716     void DumpRecord(const std::string& record, bool stateChange = false)
717     {
718         if (stateChange || frameRecord_.length() > MAX_SIZE_OF_LOG) {
719             frameRecord_.clear();
720         }
721         frameRecord_.append("[" + record + "]");
722     }
723 
724     void LogForFormRender(const std::string& logTag);
725 
SetIsUserSetResponseRegion(bool isUserSetResponseRegion)726     void SetIsUserSetResponseRegion(bool isUserSetResponseRegion)
727     {
728         isUserSetResponseRegion_ = isUserSetResponseRegion;
729     }
730 
731     size_t GetSubComponentInfos(std::vector<SubComponentInfo>& subComponentInfos);
732 
733     void UpdateFontColor(const Color& value);
734     void BeforeCreatePaintWrapper() override;
735 
736     void OnTextOverflowChanged();
737 
738     void MarkDirtyNodeRender();
739 
GetSystemTimestamp()740     uint64_t GetSystemTimestamp()
741     {
742         return static_cast<uint64_t>(
743             std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
744                 .count());
745     }
746 
747     void ChangeHandleHeight(const GestureEvent& event, bool isFirst, bool isOverlayMode);
748     void ChangeFirstHandleHeight(const Offset& touchOffset, RectF& handleRect);
749     void ChangeSecondHandleHeight(const Offset& touchOffset, RectF& handleRect);
750     virtual void CalculateDefaultHandleHeight(float& height);
751 
SetEnableHapticFeedback(bool isEnabled)752     void SetEnableHapticFeedback(bool isEnabled)
753     {
754         isEnableHapticFeedback_ = isEnabled;
755     }
756 
757     bool HasContent();
758     void SetupMagnifier();
759 
IsEnabledObscured()760     virtual bool IsEnabledObscured() const
761     {
762         return true;
763     }
764 
765     virtual Color GetUrlSpanColor();
766     void DoTextSelectionTouchCancel() override;
767     void BeforeSyncGeometryProperties(const DirtySwapConfig& config) override;
768 
RegisterAfterLayoutCallback(std::function<void ()> callback)769     void RegisterAfterLayoutCallback(std::function<void()> callback)
770     {
771         afterLayoutCallback_ = callback;
772     }
773 
UnRegisterAfterLayoutCallback()774     void UnRegisterAfterLayoutCallback()
775     {
776         afterLayoutCallback_ = std::nullopt;
777     }
778 
GetOrCreateMagnifier()779     RefPtr<MagnifierController> GetOrCreateMagnifier()
780     {
781         if (!magnifierController_) {
782             magnifierController_ = MakeRefPtr<MagnifierController>(WeakClaim(this));
783         }
784         return magnifierController_;
785     }
786 
787     std::string GetCaretColor() const;
788     std::string GetSelectedBackgroundColor() const;
789 
790     void ResetCustomFontColor();
791     void OnColorConfigurationUpdate() override;
792     bool OnThemeScopeUpdate(int32_t themeScopeId) override;
793     void OnWindowSizeChanged(int32_t width, int32_t height, WindowSizeChangeReason type) override;
794 
795     bool GetOriginCaretPosition(OffsetF& offset) const;
796     void ResetOriginCaretPosition();
797     bool RecordOriginCaretPosition(const OffsetF& offset);
798     TextDragInfo CreateTextDragInfo();
799 
800 protected:
GetClickedSpanPosition()801     int32_t GetClickedSpanPosition()
802     {
803         return clickedSpanPosition_;
804     }
805     void OnAttachToFrameNode() override;
806     void OnDetachFromFrameNode(FrameNode* node) override;
807     void OnAfterModifyDone() override;
808     virtual bool ClickAISpan(const PointF& textOffset, const AISpan& aiSpan);
809     virtual void InitAISpanHoverEvent();
810     virtual void HandleAISpanHoverEvent(const MouseInfo& info);
811     void OnHover(bool isHover);
812     void InitMouseEvent();
813     void InitFocusEvent();
814     void InitHoverEvent();
815     void AddIsFocusActiveUpdateEvent();
816     void RemoveIsFocusActiveUpdateEvent();
817     void OnIsFocusActiveUpdate(bool isFocusAcitve);
818     void RecoverCopyOption();
819     void InitCopyOption(const RefPtr<GestureEventHub>& gestureEventHub, const RefPtr<EventHub>& eventHub);
820     void RecoverSelection();
HandleOnCameraInput()821     virtual void HandleOnCameraInput() {};
822     void InitSelection(const Offset& pos);
823     void StartVibratorByLongPress();
824     void HandleLongPress(GestureEvent& info);
825     void HandleClickEvent(GestureEvent& info);
826     void HandleSingleClickEvent(GestureEvent& info);
827     void HandleClickAISpanEvent(const PointF& info);
828     void HandleDoubleClickEvent(GestureEvent& info);
829     void CheckOnClickEvent(GestureEvent& info);
830     void HandleClickOnTextAndSpan(GestureEvent& info);
831     bool TryLinkJump(const RefPtr<SpanItem>& span);
832     void ActTextOnClick(GestureEvent& info);
833     RectF CalcAIMenuPosition(const AISpan& aiSpan, const CalculateHandleFunc& calculateHandleFunc);
834     bool ShowAIEntityMenu(const AISpan& aiSpan, const CalculateHandleFunc& calculateHandleFunc = nullptr,
835         const ShowSelectOverlayFunc& showSelectOverlayFunc = nullptr);
836     void SetOnClickMenu(const AISpan& aiSpan, const CalculateHandleFunc& calculateHandleFunc,
837         const ShowSelectOverlayFunc& showSelectOverlayFunc);
838     bool IsDraggable(const Offset& localOffset);
839     virtual void InitClickEvent(const RefPtr<GestureEventHub>& gestureHub);
840     void ShowSelectOverlay(const OverlayRequest& = OverlayRequest());
841     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config) override;
842     virtual void UpdateSelectorOnHandleMove(const OffsetF& localOffset, float handleHeight, bool isFirstHandle);
843     void CalcCaretMetricsByPosition(
844         int32_t extent, CaretMetricsF& caretCaretMetric, TextAffinity textAffinity = TextAffinity::DOWNSTREAM);
845     void UpdateSelectionType(const SelectionInfo& selection);
846     void CopyBindSelectionMenuParams(SelectOverlayInfo& selectInfo, std::shared_ptr<SelectionMenuParams> menuParams);
847     virtual void OnHandleSelectionMenuCallback(
848         SelectionMenuCalblackId callbackId, std::shared_ptr<SelectionMenuParams> menuParams);
849     bool IsSelectedBindSelectionMenu();
850     bool CheckAndClick(const RefPtr<SpanItem>& item);
851     bool CalculateClickedSpanPosition(const PointF& textOffset);
852     void HiddenMenu();
853     std::shared_ptr<SelectionMenuParams> GetMenuParams(TextSpanType type, TextResponseType responseType);
854     void AddUdmfTxtPreProcessor(const ResultObject src, ResultObject& result, bool isAppend);
855     void InitKeyEvent();
856     void UpdateShiftFlag(const KeyEvent& keyEvent);
857     bool HandleKeyEvent(const KeyEvent& keyEvent);
858     void HandleOnSelect(KeyCode code);
859     void HandleSelectionUp();
860     void HandleSelectionDown();
861     void HandleSelection(bool isEmojiStart, int32_t end);
862     double GetTextHeight(int32_t index, bool isNextLine);
863     int32_t GetActualTextLength();
864     bool IsSelectableAndCopy();
865     void SetResponseRegion(const SizeF& frameSize, const SizeF& boundsSize);
866 
867     virtual bool CanStartAITask();
868 
869     void MarkDirtySelf();
OnAttachToMainTree()870     void OnAttachToMainTree() override
871     {
872         isDetachFromMainTree_ = false;
873     }
874 
OnDetachFromMainTree()875     void OnDetachFromMainTree() override
876     {
877         isDetachFromMainTree_ = true;
878     }
879 
880     bool SetActionExecSubComponent();
881     void GetSubComponentInfosForAISpans(std::vector<SubComponentInfo>& subComponentInfos);
882     void GetSubComponentInfosForSpans(std::vector<SubComponentInfo>& subComponentInfos);
883     bool ExecSubComponent(int32_t spanId);
884     void AddSubComponentInfosByDataDetectorForSpan(std::vector<SubComponentInfo>& subComponentInfos,
885         const RefPtr<SpanItem>& span);
886     void AddSubComponentInfoForAISpan(std::vector<SubComponentInfo>& subComponentInfos, const std::string& content,
887         const AISpan& aiSpan);
888     void AddSubComponentInfoForSpan(std::vector<SubComponentInfo>& subComponentInfos, const std::string& content,
889         const RefPtr<SpanItem>& span);
890 
891     int32_t GetTouchIndex(const OffsetF& offset) override;
892     void OnTextGestureSelectionUpdate(int32_t start, int32_t end, const TouchEventInfo& info) override;
893     void OnTextGenstureSelectionEnd(const TouchLocationInfo& locationInfo) override;
894     void StartGestureSelection(int32_t start, int32_t end, const Offset& startOffset) override;
895 
896     void SetImageNodeGesture(RefPtr<ImageSpanNode> imageNode);
897     virtual std::pair<int32_t, int32_t> GetStartAndEnd(int32_t start, const RefPtr<SpanItem>& spanItem);
898 
899     bool enabled_ = true;
900     Status status_ = Status::NONE;
901     bool contChange_ = false;
902     int32_t recoverStart_ = 0;
903     int32_t recoverEnd_ = 0;
904     bool aiSpanHoverEventInitialized_ = false;
905     bool mouseEventInitialized_ = false;
906     bool isHover_ = false;
907     bool panEventInitialized_ = false;
908     bool clickEventInitialized_ = false;
909     bool touchEventInitialized_ = false;
910     bool focusInitialized_ = false;
911     bool hoverInitialized_ = false;
912     bool isSpanStringMode_ = false;
913     RefPtr<MutableSpanString> styledString_;
914     bool keyEventInitialized_ = false;
915 
916     RefPtr<FrameNode> dragNode_;
917     RefPtr<LongPressEvent> longPressEvent_;
918     // Deprecated: Use the selectOverlay_ instead.
919     RefPtr<SelectOverlayProxy> selectOverlayProxy_;
920     RefPtr<Clipboard> clipboard_;
921     RefPtr<TextContentModifier> contentMod_;
922     RefPtr<TextOverlayModifier> overlayMod_;
923     CopyOptions copyOption_ = CopyOptions::None;
924 
925     std::u16string textForDisplay_;
926     std::string paintInfo_ = "NA";
927     std::string frameRecord_ = "NA";
928     std::optional<TextStyle> textStyle_;
929     std::list<RefPtr<SpanItem>> spans_;
930     mutable std::list<RefPtr<UINode>> childNodes_;
931     float baselineOffset_ = 0.0f;
932     int32_t placeholderCount_ = 0;
933     SelectMenuInfo selectMenuInfo_;
934     std::vector<RectF> dragBoxes_;
935     std::map<std::pair<TextSpanType, TextResponseType>, std::shared_ptr<SelectionMenuParams>> selectionMenuMap_;
936     std::optional<TextSpanType> selectedType_;
937     SourceType sourceType_ = SourceType::NONE;
938     std::function<void(bool)> isFocusActiveUpdateEvent_;
939 
940     friend class TextContentModifier;
941     // properties for AI
942     bool textDetectEnable_ = false;
943     RefPtr<DataDetectorAdapter> dataDetectorAdapter_ = MakeRefPtr<DataDetectorAdapter>();
944 
945     OffsetF parentGlobalOffset_;
946     std::optional<TextResponseType> textResponseType_;
947 
948     struct SubComponentInfoEx {
949         std::optional<AISpan> aiSpan;
950         WeakPtr<SpanItem> span;
951     };
952     std::vector<SubComponentInfoEx> subComponentInfos_;
953     virtual std::vector<RectF> GetSelectedRects(int32_t start, int32_t end);
954     MouseFormat currentMouseStyle_ = MouseFormat::DEFAULT;
955     RefPtr<MultipleClickRecognizer> multipleClickRecognizer_ = MakeRefPtr<MultipleClickRecognizer>();
956     bool ShowShadow(const PointF& textOffset, const Color& color);
957     virtual PointF GetTextOffset(const Offset& localLocation, const RectF& contentRect);
958     bool hasUrlSpan_ = false;
959 
960 private:
961     void InitLongPressEvent(const RefPtr<GestureEventHub>& gestureHub);
962     void HandleSpanLongPressEvent(GestureEvent& info);
963     void HandleMouseEvent(const MouseInfo& info);
964     void OnHandleTouchUp();
965     void InitTouchEvent();
966     void HandleTouchEvent(const TouchEventInfo& info);
967     void ActSetSelection(int32_t start, int32_t end);
968     bool IsShowHandle();
969     void InitUrlMouseEvent();
970     void InitUrlTouchEvent();
971     void HandleUrlMouseEvent(const MouseInfo& info);
972     void HandleUrlTouchEvent(const TouchEventInfo& info);
973     void URLOnHover(bool isHover);
974     bool HandleUrlClick();
975     Color GetUrlHoverColor();
976     Color GetUrlPressColor();
977     void SetAccessibilityAction();
978     void CollectSpanNodes(std::stack<SpanNodeInfo> nodes, bool& isSpanHasClick);
979     void CollectTextSpanNodes(const RefPtr<SpanNode>& child, bool& isSpanHasClick);
980     void UpdateContainerChildren(const RefPtr<UINode>& parent, const RefPtr<UINode>& child);
981     RefPtr<RenderContext> GetRenderContext();
982     void ProcessBoundRectByTextShadow(RectF& rect);
983     void FireOnSelectionChange(int32_t start, int32_t end);
984     void FireOnMarqueeStateChange(const TextMarqueeState& state);
985     void HandleMouseLeftButton(const MouseInfo& info, const Offset& textOffset);
986     void HandleMouseRightButton(const MouseInfo& info, const Offset& textOffset);
987     void HandleMouseLeftPressAction(const MouseInfo& info, const Offset& textOffset);
988     void HandleMouseLeftReleaseAction(const MouseInfo& info, const Offset& textOffset);
989     void HandleMouseLeftMoveAction(const MouseInfo& info, const Offset& textOffset);
990     void InitSpanItem(std::stack<SpanNodeInfo> nodes);
991     int32_t GetSelectionSpanItemIndex(const MouseInfo& info);
992     void CopySelectionMenuParams(SelectOverlayInfo& selectInfo, TextResponseType responseType);
993     void ProcessBoundRectByTextMarquee(RectF& rect);
994     ResultObject GetBuilderResultObject(RefPtr<UINode> uiNode, int32_t index, int32_t start, int32_t end);
995     void CreateModifier();
996 
997     void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const override;
998     void ToTreeJson(std::unique_ptr<JsonValue>& json, const InspectorConfig& config) const override;
999     void ProcessOverlayAfterLayout();
1000     // SpanString
1001     void MountImageNode(const RefPtr<ImageSpanItem>& imageItem);
1002     ImageSourceInfo CreateImageSourceInfo(const ImageSpanOptions& options);
1003     void ProcessSpanString();
1004     // to check if drag is in progress
SetCurrentDragTool(SourceTool tool)1005     void SetCurrentDragTool(SourceTool tool)
1006     {
1007         lastDragTool_ = tool;
1008     }
1009 
GetContextParam()1010     std::optional<RenderContext::ContextParam> GetContextParam() const override
1011     {
1012         return RenderContext::ContextParam { .type = RenderContext::ContextType::CANVAS,
1013                                              .surfaceName = std::nullopt };
1014     }
1015 
GetCurrentDragTool()1016     SourceTool GetCurrentDragTool() const
1017     {
1018         return lastDragTool_;
1019     }
1020 
1021     Offset ConvertGlobalToLocalOffset(const Offset& globalOffset);
1022     Offset ConvertLocalOffsetToParagraphOffset(const Offset& offset);
1023     void ProcessMarqueeVisibleAreaCallback();
1024     void ParseOriText(const std::u16string& currentText);
1025     bool IsMarqueeOverflow() const;
1026     virtual void ResetAfterTextChange();
1027     bool GlobalOffsetInSelectedArea(const Offset& globalOffset);
1028     bool LocalOffsetInSelectedArea(const Offset& localOffset);
1029     void HandleOnCopyWithoutSpanString(const std::string& pasteData);
1030     void CheckPressedSpanPosition(const Offset& textOffset);
1031     void EncodeTlvNoChild(const std::string& pasteData, std::vector<uint8_t>& buff);
1032     void EncodeTlvFontStyleNoChild(std::vector<uint8_t>& buff);
1033     void EncodeTlvTextLineStyleNoChild(std::vector<uint8_t>& buff);
1034     void EncodeTlvSpanItems(const std::string& pasteData, std::vector<uint8_t>& buff);
1035     void UpdateMarqueeStartPolicy();
1036     void ProcessVisibleAreaCallback();
1037     void PauseSymbolAnimation();
1038     void ResumeSymbolAnimation();
1039     bool IsLocationInFrameRegion(const Offset& localOffset) const;
1040 
1041     bool isMeasureBoundary_ = false;
1042     bool isMousePressed_ = false;
1043     bool leftMousePressed_ = false;
1044     bool isCustomFont_ = false;
1045     bool blockPress_ = false;
1046     bool isDoubleClick_ = false;
1047     bool showSelected_ = false;
1048     bool isSensitive_ = false;
1049     bool hasSpanStringLongPressEvent_ = false;
1050     int32_t clickedSpanPosition_ = -1;
1051     Offset leftMousePressedOffset_;
1052     bool isEnableHapticFeedback_ = true;
1053 
1054     bool urlTouchEventInitialized_ = false;
1055     bool urlMouseEventInitialized_ = false;
1056     bool moveOverClickThreshold_ = false;
1057     bool isMarqueeRunning_ = false;
1058 
1059     RefPtr<ParagraphManager> pManager_;
1060     std::vector<int32_t> placeholderIndex_;
1061     std::vector<RectF> rectsForPlaceholders_;
1062     OffsetF imageOffset_;
1063 
1064     OffsetF contentOffset_;
1065     GestureEventFunc onClick_;
1066     double distanceThreshold_ = std::numeric_limits<double>::infinity();
1067     RefPtr<DragWindow> dragWindow_;
1068     RefPtr<DragDropProxy> dragDropProxy_;
1069     std::optional<int32_t> surfaceChangedCallbackId_;
1070     SourceTool lastDragTool_ = SourceTool::UNKNOWN;
1071     std::optional<int32_t> surfacePositionChangedCallbackId_;
1072     int32_t dragRecordSize_ = -1;
1073     RefPtr<TextController> textController_;
1074     TextSpanType oldSelectedType_ = TextSpanType::NONE;
1075     bool isShowMenu_ = true;
1076     RefPtr<TextSelectOverlay> selectOverlay_;
1077     std::vector<WeakPtr<FrameNode>> imageNodeList_;
1078     bool isDetachFromMainTree_ = false;
1079     std::vector<CustomSpanPlaceholderInfo> customSpanPlaceholder_;
1080     std::optional<void*> externalParagraph_;
1081     std::optional<ParagraphStyle> externalParagraphStyle_;
1082     bool isUserSetResponseRegion_ = false;
1083     WeakPtr<PipelineContext> pipeline_;
1084     WeakPtr<ScrollablePattern> scrollableParent_;
1085     ACE_DISALLOW_COPY_AND_MOVE(TextPattern);
1086     std::optional<std::function<void()>> afterLayoutCallback_;
1087     Offset lastLeftMouseMoveLocation_;
1088     bool isAutoScrollByMouse_ = false;
1089     bool shiftFlag_ = false;
1090     std::string textDetectTypes_ = "";
1091     // Used to record original caret position for "shift + up/down"
1092     // Less than 0 is invalid, initialized as invalid in constructor
1093     OffsetF originCaretPosition_;
1094 };
1095 } // namespace OHOS::Ace::NG
1096 
1097 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_TEXT_PATTERN_H
1098