• 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 <optional>
20 #include <string>
21 #include <unordered_map>
22 
23 #include "interfaces/inner_api/ace/ai/data_detector_interface.h"
24 
25 #include "base/geometry/dimension.h"
26 #include "base/geometry/ng/offset_t.h"
27 #include "base/memory/referenced.h"
28 #include "base/utils/noncopyable.h"
29 #include "base/utils/utils.h"
30 #include "core/common/ai/data_detector_adapter.h"
31 #include "core/components_ng/event/long_press_event.h"
32 #include "core/components_ng/pattern/pattern.h"
33 #include "core/components_ng/pattern/rich_editor/paragraph_manager.h"
34 #include "core/components_ng/pattern/rich_editor/selection_info.h"
35 #include "core/components_ng/pattern/scrollable/scrollable_pattern.h"
36 #include "core/components_ng/pattern/text/span_node.h"
37 #include "core/components_ng/pattern/text/text_accessibility_property.h"
38 #include "core/components_ng/pattern/text/text_base.h"
39 #include "core/components_ng/pattern/text/text_content_modifier.h"
40 #include "core/components_ng/pattern/text/text_controller.h"
41 #include "core/components_ng/pattern/text/text_event_hub.h"
42 #include "core/components_ng/pattern/text/text_layout_algorithm.h"
43 #include "core/components_ng/pattern/text/text_layout_property.h"
44 #include "core/components_ng/pattern/text/text_overlay_modifier.h"
45 #include "core/components_ng/pattern/text/text_paint_method.h"
46 #include "core/components_ng/pattern/text_drag/text_drag_base.h"
47 #include "core/components_ng/pattern/text_field/text_selector.h"
48 #include "core/components_ng/property/property.h"
49 #include "core/pipeline_ng/ui_task_scheduler.h"
50 
51 namespace OHOS::Ace::NG {
52 enum class Status { DRAGGING, ON_DROP, NONE };
53 using CalculateHandleFunc = std::function<void()>;
54 using ShowSelectOverlayFunc = std::function<void(const RectF&, const RectF&)>;
55 struct SpanNodeInfo {
56     RefPtr<UINode> node;
57     RefPtr<UINode> containerSpanNode;
58 };
59 // TextPattern is the base class for text render node to perform paint text.
60 class TextPattern : public virtual Pattern, public TextDragBase, public TextBase {
61     DECLARE_ACE_TYPE(TextPattern, Pattern, TextDragBase, TextBase);
62 
63 public:
64     TextPattern() = default;
65     ~TextPattern() override = default;
66 
67     SelectionInfo GetSpansInfo(int32_t start, int32_t end, GetSpansMethod method);
68 
69     virtual int32_t GetTextContentLength();
70 
71     RefPtr<NodePaintMethod> CreateNodePaintMethod() override;
72 
CreateLayoutProperty()73     RefPtr<LayoutProperty> CreateLayoutProperty() override
74     {
75         return MakeRefPtr<TextLayoutProperty>();
76     }
77 
CreateLayoutAlgorithm()78     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
79     {
80         return MakeRefPtr<TextLayoutAlgorithm>(spans_);
81     }
82 
CreateAccessibilityProperty()83     RefPtr<AccessibilityProperty> CreateAccessibilityProperty() override
84     {
85         return MakeRefPtr<TextAccessibilityProperty>();
86     }
87 
CreateEventHub()88     RefPtr<EventHub> CreateEventHub() override
89     {
90         return MakeRefPtr<TextEventHub>();
91     }
92 
IsDragging()93     bool IsDragging() const
94     {
95         return status_ == Status::DRAGGING;
96     }
97 
IsAtomicNode()98     bool IsAtomicNode() const override
99     {
100         auto host = GetHost();
101         CHECK_NULL_RETURN(host, false);
102         if (host->GetTag() == V2::SYMBOL_ETS_TAG) {
103             return true;
104         }
105         return false;
106     }
107 
DefaultSupportDrag()108     bool DefaultSupportDrag() override
109     {
110         return true;
111     }
112 
113     void OnModifyDone() override;
114 
115     void PreCreateLayoutWrapper();
116 
117     void BeforeCreateLayoutWrapper() override;
118 
119     void AddChildSpanItem(const RefPtr<UINode>& child);
120 
GetFocusPattern()121     FocusPattern GetFocusPattern() const override
122     {
123         return { FocusType::NODE, false };
124     }
125 
126     void DumpAdvanceInfo() override;
127     void DumpInfo() override;
128 
GetTextSelector()129     TextSelector GetTextSelector() const
130     {
131         return textSelector_;
132     }
133 
GetTextForDisplay()134     std::string GetTextForDisplay() const
135     {
136         return textForDisplay_;
137     }
138 
GetStartOffset()139     const OffsetF& GetStartOffset() const
140     {
141         return textSelector_.selectionBaseOffset;
142     }
143 
GetEndOffset()144     const OffsetF& GetEndOffset() const
145     {
146         return textSelector_.selectionDestinationOffset;
147     }
148 
GetSelectHeight()149     double GetSelectHeight() const
150     {
151         return textSelector_.GetSelectHeight();
152     }
153 
154     void GetGlobalOffset(Offset& offset);
155 
GetTextContentRect()156     const RectF& GetTextContentRect() const override
157     {
158         return contentRect_;
159     }
160 
GetBaselineOffset()161     float GetBaselineOffset() const
162     {
163         return baselineOffset_;
164     }
165 
GetContentModifier()166     RefPtr<TextContentModifier> GetContentModifier()
167     {
168         return contentMod_;
169     }
170 
SetMenuOptionItems(std::vector<MenuOptionsParam> && menuOptionItems)171     void SetMenuOptionItems(std::vector<MenuOptionsParam>&& menuOptionItems)
172     {
173         menuOptionItems_ = std::move(menuOptionItems);
174     }
175 
GetMenuOptionItems()176     const std::vector<MenuOptionsParam>&& GetMenuOptionItems() const
177     {
178         return std::move(menuOptionItems_);
179     }
180 
SetTextDetectEnable(bool enable)181     void SetTextDetectEnable(bool enable)
182     {
183         auto host = GetHost();
184         CHECK_NULL_VOID(host);
185         dataDetectorAdapter_->frameNode_ = host;
186         bool cache = textDetectEnable_;
187         textDetectEnable_ = enable;
188         if (cache != textDetectEnable_) {
189             host->MarkDirtyNode(PROPERTY_UPDATE_MEASURE);
190         }
191     }
GetTextDetectEnable()192     bool GetTextDetectEnable()
193     {
194         return textDetectEnable_;
195     }
SetTextDetectTypes(const std::string & types)196     void SetTextDetectTypes(const std::string& types)
197     {
198         dataDetectorAdapter_->SetTextDetectTypes(types);
199     }
GetTextDetectTypes()200     std::string GetTextDetectTypes()
201     {
202         return dataDetectorAdapter_->textDetectTypes_;
203     }
GetDataDetectorAdapter()204     RefPtr<DataDetectorAdapter> GetDataDetectorAdapter()
205     {
206         return dataDetectorAdapter_;
207     }
GetAISpanMap()208     const std::map<int32_t, AISpan>& GetAISpanMap()
209     {
210         return dataDetectorAdapter_->aiSpanMap_;
211     }
GetTextForAI()212     const std::string& GetTextForAI()
213     {
214         return dataDetectorAdapter_->textForAI_;
215     }
SetOnResult(std::function<void (const std::string &)> && onResult)216     void SetOnResult(std::function<void(const std::string&)>&& onResult)
217     {
218         dataDetectorAdapter_->onResult_ = std::move(onResult);
219     }
GetTextDetectResult()220     std::optional<TextDataDetectResult> GetTextDetectResult()
221     {
222         return dataDetectorAdapter_->textDetectResult_;
223     }
224 
225     void OnVisibleChange(bool isVisible) override;
226 
GetSpanItemChildren()227     std::list<RefPtr<SpanItem>> GetSpanItemChildren()
228     {
229         return spans_;
230     }
231 
GetDisplayWideTextLength()232     int32_t GetDisplayWideTextLength()
233     {
234         return StringUtils::ToWstring(textForDisplay_).length();
235     }
236 
237     // ===========================================================
238     // TextDragBase implementations
239 
IsTextArea()240     bool IsTextArea() const override
241     {
242         return false;
243     }
244 
GetTextRect()245     const RectF& GetTextRect() override
246     {
247         return contentRect_;
248     }
249     float GetLineHeight() const override;
250 
251     std::vector<RectF> GetTextBoxes() override;
252     OffsetF GetParentGlobalOffset() const override;
253 
MoveDragNode()254     const RefPtr<FrameNode>& MoveDragNode() override
255     {
256         return dragNode_;
257     }
258 
GetDragParagraph()259     ParagraphT GetDragParagraph() const override
260     {
261         return { paragraph_ };
262     }
263 
CloseKeyboard(bool)264     bool CloseKeyboard(bool /* forceClose */) override
265     {
266         return true;
267     }
268     virtual void CloseSelectOverlay() override;
269     void CloseSelectOverlay(bool animation);
270     void CreateHandles() override;
271 
272     bool BetweenSelectedPosition(const Offset& globalOffset) override;
273 
274     // end of TextDragBase implementations
275     // ===========================================================
276 
277     void InitSurfaceChangedCallback();
278     void InitSurfacePositionChangedCallback();
279     virtual void HandleSurfaceChanged(int32_t newWidth, int32_t newHeight, int32_t prevWidth, int32_t prevHeight);
HandleSurfacePositionChanged(int32_t posX,int32_t posY)280     virtual void HandleSurfacePositionChanged(int32_t posX, int32_t posY) {};
HasSurfaceChangedCallback()281     bool HasSurfaceChangedCallback()
282     {
283         return surfaceChangedCallbackId_.has_value();
284     }
UpdateSurfaceChangedCallbackId(int32_t id)285     void UpdateSurfaceChangedCallbackId(int32_t id)
286     {
287         surfaceChangedCallbackId_ = id;
288     }
289 
HasSurfacePositionChangedCallback()290     bool HasSurfacePositionChangedCallback()
291     {
292         return surfacePositionChangedCallbackId_.has_value();
293     }
UpdateSurfacePositionChangedCallbackId(int32_t id)294     void UpdateSurfacePositionChangedCallbackId(int32_t id)
295     {
296         surfacePositionChangedCallbackId_ = id;
297     }
298 
SetOnClickEvent(GestureEventFunc && onClick)299     void SetOnClickEvent(GestureEventFunc&& onClick)
300     {
301         onClick_ = std::move(onClick);
302     }
303     virtual void OnColorConfigurationUpdate() override;
304 
305     NG::DragDropInfo OnDragStart(const RefPtr<Ace::DragEvent>& event, const std::string& extraParams);
306     DragDropInfo OnDragStartNoChild(const RefPtr<Ace::DragEvent>& event, const std::string& extraParams);
307     void InitDragEvent();
308     void UpdateSpanItemDragStatus(const std::list<ResultObject>& resultObjects, bool IsDragging);
309     virtual std::function<void(Offset)> GetThumbnailCallback();
310     std::list<ResultObject> dragResultObjects_;
311     std::list<ResultObject> recoverDragResultObjects_;
312     void OnDragEnd(const RefPtr<Ace::DragEvent>& event);
313     void OnDragEndNoChild(const RefPtr<Ace::DragEvent>& event);
314     void CloseOperate();
315     void OnDragMove(const RefPtr<Ace::DragEvent>& event);
316 
317     std::string GetSelectedSpanText(std::wstring value, int32_t start, int32_t end) const;
318     TextStyleResult GetTextStyleObject(const RefPtr<SpanNode>& node);
319     SymbolSpanStyle GetSymbolSpanStyleObject(const RefPtr<SpanNode>& node);
320     RefPtr<UINode> GetChildByIndex(int32_t index) const;
321     RefPtr<SpanItem> GetSpanItemByIndex(int32_t index) const;
322     ResultObject GetTextResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
323     ResultObject GetSymbolSpanResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
324     ResultObject GetImageResultObject(RefPtr<UINode> uinode, int32_t index, int32_t start, int32_t end);
325 
GetDragContents()326     const std::vector<std::string>& GetDragContents() const
327     {
328         return dragContents_;
329     }
330 
InitSpanImageLayout(const std::vector<int32_t> & placeholderIndex,const std::vector<RectF> & rectsForPlaceholders,OffsetF contentOffset)331     void InitSpanImageLayout(const std::vector<int32_t>& placeholderIndex,
332         const std::vector<RectF>& rectsForPlaceholders, OffsetF contentOffset) override
333     {
334         placeholderIndex_ = placeholderIndex;
335         imageOffset_ = contentOffset;
336         rectsForPlaceholders_ = rectsForPlaceholders;
337     }
338 
GetPlaceHolderIndex()339     const std::vector<int32_t>& GetPlaceHolderIndex()
340     {
341         return placeholderIndex_;
342     }
343 
GetRectsForPlaceholders()344     const std::vector<RectF>& GetRectsForPlaceholders()
345     {
346         return rectsForPlaceholders_;
347     }
348 
GetContentOffset()349     OffsetF GetContentOffset() override
350     {
351         return imageOffset_;
352     }
353 
GetRightClickOffset()354     const OffsetF& GetRightClickOffset() const
355     {
356         return mouseReleaseOffset_;
357     }
358 
IsMeasureBoundary()359     bool IsMeasureBoundary() const override
360     {
361         return isMeasureBoundary_;
362     }
363 
SetIsMeasureBoundary(bool isMeasureBoundary)364     void SetIsMeasureBoundary(bool isMeasureBoundary)
365     {
366         isMeasureBoundary_ = isMeasureBoundary;
367     }
368 
SetIsCustomFont(bool isCustomFont)369     void SetIsCustomFont(bool isCustomFont)
370     {
371         isCustomFont_ = isCustomFont;
372     }
373 
GetIsCustomFont()374     bool GetIsCustomFont()
375     {
376         return isCustomFont_;
377     }
378     virtual void UpdateSelectOverlayOrCreate(SelectOverlayInfo& selectInfo, bool animation = false);
379     virtual void CheckHandles(SelectHandleInfo& handleInfo);
380     OffsetF GetDragUpperLeftCoordinates() override;
381     void SetTextSelection(int32_t selectionStart, int32_t selectionEnd);
382 
383 #ifndef USE_GRAPHIC_TEXT_GINE
384     static RSTypographyProperties::TextBox ConvertRect(const Rect& rect);
385 #else
386     static RSTextRect ConvertRect(const Rect& rect);
387 #endif
388     // override SelectOverlayClient methods
389     void OnHandleMoveDone(const RectF& handleRect, bool isFirstHandle) override;
390     void OnHandleMove(const RectF& handleRect, bool isFirstHandle) override;
OnSelectOverlayMenuClicked(SelectOverlayMenuId menuId)391     void OnSelectOverlayMenuClicked(SelectOverlayMenuId menuId) override
392     {
393         switch (menuId) {
394             case SelectOverlayMenuId::COPY:
395                 HandleOnCopy();
396                 return;
397             case SelectOverlayMenuId::SELECT_ALL:
398                 HandleOnSelectAll();
399                 return;
400             case SelectOverlayMenuId::CAMERA_INPUT:
401                 HandleOnCameraInput();
402                 return;
403             default:
404                 return;
405         }
406     }
407 
GetClientHost()408     RefPtr<FrameNode> GetClientHost() const override
409     {
410         return GetHost();
411     }
412 
GetParagraph()413     RefPtr<Paragraph> GetParagraph()
414     {
415         return paragraph_;
416     }
417 
MarkContentChange()418     void MarkContentChange()
419     {
420         contChange_ = true;
421     }
422 
ResetContChange()423     void ResetContChange()
424     {
425         contChange_ = false;
426     }
427 
GetContChange()428     bool GetContChange() const
429     {
430         return contChange_;
431     }
432 
GetShowSelect()433     bool GetShowSelect() const
434     {
435         return showSelect_;
436     }
437 
GetRecoverStart()438     int32_t GetRecoverStart() const
439     {
440         return recoverStart_;
441     }
442 
GetRecoverEnd()443     int32_t GetRecoverEnd() const
444     {
445         return recoverEnd_;
446     }
447 
448     void OnAreaChangedInner() override;
449     void RemoveAreaChangeInner();
450 
ResetDragOption()451     void ResetDragOption() override
452     {
453         CloseSelectOverlay();
454         ResetSelection();
455     }
456     virtual bool NeedShowAIDetect();
457 
GetDragRecordSize()458     int32_t GetDragRecordSize() override
459     {
460         return dragRecordSize_;
461     }
462 
ResetDragRecordSize(int32_t size)463     void ResetDragRecordSize(int32_t size)
464     {
465         dragRecordSize_ = size;
466     }
467 
468     void BindSelectionMenu(TextSpanType spanType, TextResponseType responseType, std::function<void()>& menuBuilder,
469         std::function<void(int32_t, int32_t)>& onAppear, std::function<void()>& onDisappear);
470 
SetTextController(const RefPtr<TextController> & controller)471     void SetTextController(const RefPtr<TextController>& controller)
472     {
473         textController_ = controller;
474     }
475 
GetTextController()476     const RefPtr<TextController>& GetTextController()
477     {
478         return textController_;
479     }
480 
481     void CloseSelectionMenu();
482 
ClearSelectionMenu()483     void ClearSelectionMenu()
484     {
485         selectionMenuMap_.clear();
486     }
487 
488     virtual const std::list<RefPtr<UINode>>& GetAllChildren() const;
489 
490     void HandleSelectionChange(int32_t start, int32_t end);
491 
492 protected:
493     void OnAttachToFrameNode() override;
494     void OnDetachFromFrameNode(FrameNode* node) override;
495     void OnAfterModifyDone() override;
496     virtual bool ClickAISpan(const PointF& textOffset, const AISpan& aiSpan);
497     void InitMouseEvent();
498     void ResetSelection();
499     void RecoverSelection();
500     virtual void HandleOnSelectAll();
HandleOnCameraInput()501     virtual void HandleOnCameraInput() {};
502     void InitSelection(const Offset& pos);
503     void HandleLongPress(GestureEvent& info);
504     void HandleClickEvent(GestureEvent& info);
505     void HandleSingleClickEvent(GestureEvent& info);
506     void HandleClickAISpanEvent(const PointF& info);
507     void HandleSpanSingleClickEvent(GestureEvent& info, RectF textContentRect, PointF textOffset, bool& isClickOnSpan);
508     void HandleDoubleClickEvent(GestureEvent& info);
509     void CheckOnClickEvent(GestureEvent& info);
510     bool ShowUIExtensionMenu(const AISpan& aiSpan, const CalculateHandleFunc& calculateHandleFunc = nullptr,
511         const ShowSelectOverlayFunc& showSelectOverlayFunc = nullptr);
512     void SetOnClickMenu(const AISpan& aiSpan, const CalculateHandleFunc& calculateHandleFunc,
513         const ShowSelectOverlayFunc& showSelectOverlayFunc);
514     bool IsDraggable(const Offset& localOffset);
515     virtual void InitClickEvent(const RefPtr<GestureEventHub>& gestureHub);
516     void CalculateHandleOffsetAndShowOverlay(bool isUsingMouse = false);
517     void PushSelectedByMouseInfoToManager();
518     void ShowSelectOverlay(const RectF& firstHandle, const RectF& secondHandle);
519     void ShowSelectOverlay(const RectF& firstHandle, const RectF& secondHandle,
520         bool animation, bool isUsingMouse = false, bool isShowMenu = true);
521     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config) override;
522     bool IsSelectAll();
523     virtual int32_t GetHandleIndex(const Offset& offset) const;
524     std::wstring GetWideText() const;
525     std::string GetSelectedText(int32_t start, int32_t end) const;
526     void CalcCaretMetricsByPosition(
527         int32_t extent, CaretMetricsF& caretCaretMetric, TextAffinity textAffinity = TextAffinity::DOWNSTREAM);
528     void UpdateSelectionType(const SelectionInfo& selection);
529     void CopyBindSelectionMenuParams(SelectOverlayInfo& selectInfo, std::shared_ptr<SelectionMenuParams> menuParams);
530     bool IsSelectedBindSelectionMenu();
531     std::shared_ptr<SelectionMenuParams> GetMenuParams(TextSpanType type, TextResponseType responseType);
532 
CanStartAITask()533     virtual bool CanStartAITask()
534     {
535         return copyOption_ != CopyOptions::None && textDetectEnable_ && enabled_ && dataDetectorAdapter_;
536     };
537 
538     Status status_ = Status::NONE;
539     bool contChange_ = false;
540     int32_t recoverStart_ = 0;
541     int32_t recoverEnd_ = 0;
542     bool enabled_ = true;
543     bool showSelectOverlay_ = false;
544     bool mouseEventInitialized_ = false;
545     bool panEventInitialized_ = false;
546     bool clickEventInitialized_ = false;
547     bool touchEventInitialized_ = false;
548 
549     RectF contentRect_;
550     RefPtr<FrameNode> dragNode_;
551     RefPtr<LongPressEvent> longPressEvent_;
552     RefPtr<SelectOverlayProxy> selectOverlayProxy_;
553     RefPtr<Clipboard> clipboard_;
554     RefPtr<TextContentModifier> contentMod_;
555     RefPtr<TextOverlayModifier> overlayMod_;
556     CopyOptions copyOption_ = CopyOptions::None;
557 
558     std::string textForDisplay_;
559     std::optional<TextStyle> textStyle_;
560     std::list<RefPtr<SpanItem>> spans_;
561     float baselineOffset_ = 0.0f;
562     int32_t placeholderCount_ = 0;
563     SelectMenuInfo selectMenuInfo_;
564     std::vector<RectF> dragBoxes_;
565     std::map<std::pair<TextSpanType, TextResponseType>, std::shared_ptr<SelectionMenuParams>> selectionMenuMap_;
566     std::optional<TextSpanType> selectedType_;
567 
568     // properties for AI
569     bool textDetectEnable_ = false;
570     RefPtr<DataDetectorAdapter> dataDetectorAdapter_ = MakeRefPtr<DataDetectorAdapter>();
571 
572 private:
573     void HandleOnCopy();
574     void InitLongPressEvent(const RefPtr<GestureEventHub>& gestureHub);
575     void HandleMouseEvent(const MouseInfo& info);
576     void OnHandleTouchUp();
577     void InitPanEvent(const RefPtr<GestureEventHub>& gestureHub);
578     void HandlePanStart(const GestureEvent& info);
579     void HandlePanUpdate(const GestureEvent& info);
580     void HandlePanEnd(const GestureEvent& info);
581     void InitTouchEvent();
582     void HandleTouchEvent(const TouchEventInfo& info);
583     void UpdateChildProperty(const RefPtr<SpanNode>& child) const;
584     void ActSetSelection(int32_t start, int32_t end);
585     void SetAccessibilityAction();
586     void CollectSpanNodes(std::stack<SpanNodeInfo> nodes, bool& isSpanHasClick);
587     void UpdateContainerChildren(const RefPtr<UINode>& parent, const RefPtr<UINode>& child);
588     RefPtr<RenderContext> GetRenderContext();
589     void ProcessBoundRectByTextShadow(RectF& rect);
590     void FireOnSelectionChange(int32_t start, int32_t end);
591     void HandleMouseLeftButton(const MouseInfo& info, const Offset& textOffset);
592     void HandleMouseRightButton(const MouseInfo& info, const Offset& textOffset);
593     void HandleMouseLeftPressAction(const MouseInfo& info, const Offset& textOffset);
594     void HandleMouseLeftReleaseAction(const MouseInfo& info, const Offset& textOffset);
595     void HandleMouseLeftMoveAction(const MouseInfo& info, const Offset& textOffset);
596     void InitSpanItem(std::stack<SpanNodeInfo> nodes);
597     void UpdateSelectionSpanType(int32_t selectStart, int32_t selectEnd);
598     int32_t GetSelectionSpanItemIndex(const MouseInfo& info);
599     void CopySelectionMenuParams(SelectOverlayInfo& selectInfo, TextResponseType responseType);
600     void RedisplaySelectOverlay();
601     void ProcessBoundRectByTextMarquee(RectF& rect);
602     ResultObject GetBuilderResultObject(RefPtr<UINode> uiNode, int32_t index, int32_t start, int32_t end);
603 
604     bool IsLineBreakOrEndOfParagraph(int32_t pos) const;
605     void ToJsonValue(std::unique_ptr<JsonValue>& json) const override;
606     // to check if drag is in progress
607 
608     bool isMeasureBoundary_ = false;
609     bool isMousePressed_ = false;
610     bool isCustomFont_ = false;
611     bool blockPress_ = false;
612     bool hasClicked_ = false;
613     bool isDoubleClick_ = false;
614     TimeStamp lastClickTimeStamp_;
615 
616     RefPtr<Paragraph> paragraph_;
617     std::vector<MenuOptionsParam> menuOptionItems_;
618     std::vector<int32_t> placeholderIndex_;
619     std::vector<RectF> rectsForPlaceholders_;
620     OffsetF imageOffset_;
621 
622     OffsetF mouseReleaseOffset_;
623     OffsetF contentOffset_;
624     OffsetF parentGlobalOffset_;
625     GestureEventFunc onClick_;
626     RefPtr<DragWindow> dragWindow_;
627     RefPtr<DragDropProxy> dragDropProxy_;
628     std::optional<int32_t> surfaceChangedCallbackId_;
629     std::optional<int32_t> surfacePositionChangedCallbackId_;
630     int32_t dragRecordSize_ = -1;
631     std::optional<TextResponseType> textResponseType_;
632     RefPtr<TextController> textController_;
633     TextSpanType oldSelectedType_ = TextSpanType::NONE;
634     mutable std::list<RefPtr<UINode>> childNodes_;
635     bool isShowMenu_ = true;
636     ACE_DISALLOW_COPY_AND_MOVE(TextPattern);
637 };
638 } // namespace OHOS::Ace::NG
639 
640 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_TEXT_TEXT_PATTERN_H
641