• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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_RICH_EDITOR_RICH_EDITOR_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_RICH_EDITOR_RICH_EDITOR_PATTERN_H
18 
19 #include <cstdint>
20 #include <optional>
21 #include <string>
22 
23 #include "core/common/ime/text_edit_controller.h"
24 #include "core/common/ime/text_input_action.h"
25 #include "core/common/ime/text_input_client.h"
26 #include "core/common/ime/text_input_configuration.h"
27 #include "core/common/ime/text_input_connection.h"
28 #include "core/common/ime/text_input_formatter.h"
29 #include "core/common/ime/text_input_proxy.h"
30 #include "core/common/ime/text_input_type.h"
31 #include "core/common/ime/text_selection.h"
32 #include "core/components_ng/pattern/rich_editor/paragraph_manager.h"
33 #include "core/components_ng/pattern/rich_editor/rich_editor_content_modifier.h"
34 #include "core/components_ng/pattern/rich_editor/rich_editor_controller.h"
35 #include "core/components_ng/pattern/rich_editor/rich_editor_event_hub.h"
36 #include "core/components_ng/pattern/rich_editor/rich_editor_layout_algorithm.h"
37 #include "core/components_ng/pattern/rich_editor/rich_editor_layout_property.h"
38 #include "core/components_ng/pattern/rich_editor/rich_editor_overlay_modifier.h"
39 #include "core/components_ng/pattern/rich_editor/rich_editor_paint_method.h"
40 #include "core/components_ng/pattern/rich_editor/selection_info.h"
41 #include "core/components_ng/pattern/scrollable/scrollable_pattern.h"
42 #include "core/components_ng/pattern/text/span_node.h"
43 #include "core/components_ng/pattern/text/text_pattern.h"
44 
45 #if not defined(ACE_UNITTEST)
46 #if defined(ENABLE_STANDARD_INPUT)
47 #include "commonlibrary/c_utils/base/include/refbase.h"
48 
49 namespace OHOS::MiscServices {
50 class OnTextChangedListener;
51 struct TextConfig;
52 } // namespace OHOS::MiscServices
53 #endif
54 #endif
55 
56 namespace OHOS::Ace::NG {
57 // TextPattern is the base class for text render node to perform paint text.
58 enum class MoveDirection { FORWARD, BACKWARD };
59 
60 enum class AutoScrollEvent { HANDLE, DRAG, MOUSE, NONE };
61 enum class EdgeDetectionStrategy { OUT_BOUNDARY, IN_BOUNDARY, DISABLE };
62 struct AutoScrollParam {
63     AutoScrollEvent autoScrollEvent = AutoScrollEvent::NONE;
64     RectF handleRect;
65     bool isFirstHandle = false;
66     float offset = 0.0f;
67     bool showScrollbar = false;
68     Offset eventOffset;
69     bool isFirstRun_ = true;
70 };
71 
72 class RichEditorPattern : public TextPattern, public ScrollablePattern, public TextInputClient {
73     DECLARE_ACE_TYPE(RichEditorPattern, TextPattern, ScrollablePattern, TextInputClient);
74 
75 public:
76     RichEditorPattern();
77     ~RichEditorPattern() override;
78 
79     struct OperationRecord {
80         std::optional<std::string> addText;
81         std::optional<std::string> deleteText;
82         int32_t beforeCaretPosition;
83         int32_t afterCaretPosition;
84     };
85 
86     // RichEditor needs softkeyboard, override function.
NeedSoftKeyboard()87     bool NeedSoftKeyboard() const override
88     {
89         return true;
90     }
91 
92     bool CheckBlurReason();
93 
94     uint32_t GetSCBSystemWindowId();
95 
CreateEventHub()96     RefPtr<EventHub> CreateEventHub() override
97     {
98         return MakeRefPtr<RichEditorEventHub>();
99     }
100 
CreateLayoutProperty()101     RefPtr<LayoutProperty> CreateLayoutProperty() override
102     {
103         return MakeRefPtr<RichEditorLayoutProperty>();
104     }
105 
CreateLayoutAlgorithm()106     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
107     {
108         return MakeRefPtr<RichEditorLayoutAlgorithm>(spans_, &paragraphs_);
109     }
110 
GetFocusPattern()111     FocusPattern GetFocusPattern() const override
112     {
113         FocusPattern focusPattern = { FocusType::NODE, true, FocusStyleType::INNER_BORDER };
114         focusPattern.SetIsFocusActiveWhenFocused(true);
115         return focusPattern;
116     }
117 
118     RefPtr<NodePaintMethod> CreateNodePaintMethod() override;
119 
GetRichEditorController()120     const RefPtr<RichEditorController>& GetRichEditorController()
121     {
122         return richEditorController_;
123     }
124 
SetRichEditorController(const RefPtr<RichEditorController> & controller)125     void SetRichEditorController(const RefPtr<RichEditorController>& controller)
126     {
127         richEditorController_ = controller;
128     }
129 
GetTimestamp()130     long long GetTimestamp() const
131     {
132         return timestamp_;
133     }
134 
UpdateSpanPosition()135     void UpdateSpanPosition()
136     {
137         uint32_t spanTextLength = 0;
138         for (auto& span : spans_) {
139             spanTextLength += StringUtils::ToWstring(span->content).length();
140             span->position = static_cast<int32_t>(spanTextLength);
141         }
142     }
143 
144     void ResetBeforePaste();
145     void ResetAfterPaste();
146 
147     void OnVisibleChange(bool isVisible) override;
148     void OnModifyDone() override;
149     void BeforeCreateLayoutWrapper() override;
150     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config) override;
151     void MoveCaretOnLayoutSwap();
152 
153     void UpdateEditingValue(const std::shared_ptr<TextEditingValue>& value, bool needFireChangeEvent = true) override;
154     void PerformAction(TextInputAction action, bool forceCloseKeyboard = true) override;
155     void InsertValue(const std::string& insertValue) override;
156     void InsertValueOperation(const std::string& insertValue, OperationRecord* const record = nullptr);
157     void InsertValueAfterBeforeSpan(RefPtr<SpanNode>& spanNodeBefore, RefPtr<SpanNode>& spanNode,
158         const TextInsertValueInfo& info, const std::string& insertValue);
159     void InsertDiffStyleValueInSpan(
160         RefPtr<SpanNode>& spanNode, const TextInsertValueInfo& info, const std::string& insertValue);
161     void InsertValueWithoutSpan(
162         RefPtr<SpanNode>& spanNode, const TextInsertValueInfo& info, const std::string& insertValue);
163     void InsertValueByPaste(const std::string& insertValue);
164     bool IsLineSeparatorInLast(RefPtr<SpanNode>& spanNode);
165     void InsertValueToSpanNode(
166         RefPtr<SpanNode>& spanNode, const std::string& insertValue, const TextInsertValueInfo& info);
167     void SpanNodeFission(RefPtr<SpanNode>& spanNode, const std::string& insertValue, const TextInsertValueInfo& info);
168     void SpanNodeFission(RefPtr<SpanNode>& spanNode);
169     void CreateTextSpanNode(
170         RefPtr<SpanNode>& spanNode, const TextInsertValueInfo& info, const std::string& insertValue, bool isIME = true);
171     void HandleOnDelete(bool backward) override;
172     void DeleteBackward(int32_t length = 0) override;
173     std::wstring DeleteBackwardOperation(int32_t length = 0);
174     void DeleteForward(int32_t length) override;
175     std::wstring DeleteForwardOperation(int32_t length);
176     void SetInputMethodStatus(bool keyboardShown) override;
177     bool ClickAISpan(const PointF& textOffset, const AISpan& aiSpan) override;
NotifyKeyboardClosedByUser()178     void NotifyKeyboardClosedByUser() override
179     {
180         FocusHub::LostFocusToViewRoot();
181     }
182     void ClearOperationRecords();
183     void ClearRedoOperationRecords();
184     void AddOperationRecord(const OperationRecord& record);
HandleOnEnter()185     void HandleOnEnter() override
186     {
187         PerformAction(TextInputAction::NEW_LINE, false);
188     }
189     bool HandleOnEscape() override;
190     void HandleOnUndoAction() override;
191     void HandleOnRedoAction() override;
192     void CursorMove(CaretMoveIntent direction) override;
193     bool CursorMoveLeft();
194     bool CursorMoveRight();
195     bool CursorMoveUp();
196     bool CursorMoveDown();
197     bool CursorMoveLeftWord();
198     bool CursorMoveRightWord();
199     bool CursorMoveToParagraphBegin();
200     bool CursorMoveToParagraphEnd();
201     bool CursorMoveHome();
202     bool CursorMoveEnd();
203     int32_t GetLeftWordPosition(int32_t caretPosition);
204     int32_t GetRightWordPosition(int32_t caretPosition);
205     int32_t GetParagraphBeginPosition(int32_t caretPosition);
206     int32_t GetParagraphEndPosition(int32_t caretPosition);
207     void HandleSelect(CaretMoveIntent direction) override;
208     bool SetCaretPosition(int32_t pos);
209     int32_t GetCaretPosition();
210     int32_t GetTextContentLength() override;
211     bool GetCaretVisible() const;
212     OffsetF CalcCursorOffsetByPosition(int32_t position, float& selectLineHeight,
213         bool downStreamFirst = false, bool needLineHighest = true);
214     void CopyTextSpanStyle(RefPtr<SpanNode>& source, RefPtr<SpanNode>& target, bool needLeadingMargin = false);
215     void CopyTextSpanFontStyle(RefPtr<SpanNode>& source, RefPtr<SpanNode>& target);
216     void CopyTextSpanLineStyle(RefPtr<SpanNode>& source, RefPtr<SpanNode>& target, bool needLeadingMargin = false);
217     int32_t TextSpanSplit(int32_t position, bool needLeadingMargin = false);
218     SpanPositionInfo GetSpanPositionInfo(int32_t position);
219     std::function<ImageSourceInfo()> CreateImageSourceInfo(const ImageSpanOptions& options);
220     void DeleteSpans(const RangeOptions& options);
221     void DeleteSpanByRange(int32_t start, int32_t end, SpanPositionInfo info);
222     void DeleteSpansByRange(int32_t start, int32_t end, SpanPositionInfo startInfo, SpanPositionInfo endInfo);
223     void ClearContent(const RefPtr<UINode>& child);
224     void CloseSelectionMenu();
225     bool SetCaretOffset(int32_t caretPosition);
226     void ResetFirstNodeStyle();
227     void FireOnDeleteComplete(const RichEditorDeleteValue& info);
228 
229     void UpdateSpanStyle(int32_t start, int32_t end, const TextStyle& textStyle, const ImageSpanAttribute& imageStyle);
230     bool SymbolSpanUpdateStyle(
231         RefPtr<SpanNode>& spanNode, struct UpdateSpanStyle updateSpanStyle, TextStyle textStyle);
232     void SetUpdateSpanStyle(struct UpdateSpanStyle updateSpanStyle);
233     void UpdateParagraphStyle(int32_t start, int32_t end, const UpdateParagraphStyle& style);
234     std::vector<ParagraphInfo> GetParagraphInfo(int32_t start, int32_t end);
235     void SetTypingStyle(struct UpdateSpanStyle typingStyle, TextStyle textStyle);
236     int32_t AddImageSpan(const ImageSpanOptions& options, bool isPaste = false, int32_t index = -1);
237     int32_t AddTextSpan(const TextSpanOptions& options, bool isPaste = false, int32_t index = -1);
238     int32_t AddTextSpanOperation(const TextSpanOptions& options, bool isPaste = false, int32_t index = -1,
239         bool needLeadingMargin = false, bool updateCaretOPosition = true);
240     int32_t AddSymbolSpan(const SymbolSpanOptions& options, bool isPaste = false, int32_t index = -1);
241     int32_t AddSymbolSpanOperation(const SymbolSpanOptions& options, bool isPaste = false, int32_t index = -1);
242     void AddSpanItem(const RefPtr<SpanItem>& item, int32_t offset);
243     int32_t AddPlaceholderSpan(const RefPtr<UINode>& customNode, const SpanOptionBase& options);
244     void SetSelection(int32_t start, int32_t end);
245     void OnHandleMoveDone(const RectF& handleRect, bool isFirstHandle) override;
246     std::u16string GetLeftTextOfCursor(int32_t number) override;
247     std::u16string GetRightTextOfCursor(int32_t number) override;
248     int32_t GetTextIndexAtCursor() override;
249     void ShowSelectOverlay(const RectF& firstHandle, const RectF& secondHandle, bool isCopyAll = false,
250         TextResponseType responseType = TextResponseType::LONG_PRESS, bool handlReverse = false);
251     void CheckEditorTypeChange();
252     void OnHandleMove(const RectF& handleRect, bool isFirstHandle) override;
253     int32_t GetHandleIndex(const Offset& offset) const override;
254     void OnAreaChangedInner() override;
255     void CreateHandles() override;
256     void HandleMenuCallbackOnSelectAll();
257     void HandleOnSelectAll() override;
258     void HandleOnCopy(bool isUsingExternalKeyboard = false) override;
259     bool JudgeDraggable(GestureEvent& info);
260 
IsUsingMouse()261     bool IsUsingMouse() const
262     {
263         return isMousePressed_;
264     }
265 
ResetIsMousePressed()266     void ResetIsMousePressed()
267     {
268         isMousePressed_ = false;
269     }
270 
GetSelectionMenuOffset()271     OffsetF GetSelectionMenuOffset() const
272     {
273         return selectionMenuOffsetByMouse_;
274     }
275 
GetLastClickOffset()276     OffsetF GetLastClickOffset() const
277     {
278         return lastClickOffset_;
279     }
280 
SetLastClickOffset(const OffsetF & lastClickOffset)281     void SetLastClickOffset(const OffsetF& lastClickOffset)
282     {
283         lastClickOffset_ = lastClickOffset;
284     }
285 
ResetLastClickOffset()286     void ResetLastClickOffset()
287     {
288         lastClickOffset_.SetX(-1);
289         lastClickOffset_.SetY(-1);
290     }
291 
GetCaretSpanIndex()292     int32_t GetCaretSpanIndex()
293     {
294         return caretSpanIndex_;
295     }
296 
GetParagraphs()297     const std::list<ParagraphManager::ParagraphInfo>& GetParagraphs() const
298     {
299         return paragraphs_.GetParagraphs();
300     }
301 
302     RectF GetCaretRect() const override;
303     void CloseSelectOverlay() override;
304     void CalculateHandleOffsetAndShowOverlay(bool isUsingMouse = false);
305     void CopySelectionMenuParams(SelectOverlayInfo& selectInfo, TextResponseType responseType);
306     std::function<void(Offset)> GetThumbnailCallback() override;
307     void HandleOnDragStatusCallback(
308         const DragEventType& dragEventType, const RefPtr<NotifyDragEvent>& notifyDragEvent) override;
309     void AdjustHandleRect(OffsetF& firstHandleOffset, OffsetF& secondHandleOffset, SizeF& firstHandlePaintSize,
310         SizeF& secondHandlePaintSize);
311     void ResetSelection();
312     bool BetweenSelectedPosition(const Offset& globalOffset) override;
313     void HandleSurfaceChanged(int32_t newWidth, int32_t newHeight, int32_t prevWidth, int32_t prevHeight) override;
314     void HandleSurfacePositionChanged(int32_t posX, int32_t posY) override;
315     bool RequestCustomKeyboard();
316     bool CloseCustomKeyboard();
GetPasteStr()317     const std::string& GetPasteStr() const
318     {
319         return pasteStr_;
320     }
AddPasteStr(const std::string & addedStr)321     void AddPasteStr(const std::string& addedStr)
322     {
323         pasteStr_.append(addedStr);
324     }
ClearPasteStr()325     void ClearPasteStr()
326     {
327         pasteStr_.clear();
328     }
SetCustomKeyboard(const std::function<void ()> && keyboardBuilder)329     void SetCustomKeyboard(const std::function<void()>&& keyboardBuilder)
330     {
331         if (customKeyboardBuilder_ && isCustomKeyboardAttached_ && !keyboardBuilder) {
332             // close customKeyboard and request system keyboard
333             CloseCustomKeyboard();
334             customKeyboardBuilder_ = keyboardBuilder; // refresh current keyboard
335             RequestKeyboard(false, true, true);
336             return;
337         }
338         if (!customKeyboardBuilder_ && keyboardBuilder) {
339             // close system keyboard and request custom keyboard
340 #if defined(OHOS_STANDARD_SYSTEM) && !defined(PREVIEW)
341             if (imeShown_) {
342                 CloseKeyboard(true);
343                 customKeyboardBuilder_ = keyboardBuilder; // refresh current keyboard
344                 RequestKeyboard(false, true, true);
345                 return;
346             }
347 #endif
348         }
349         customKeyboardBuilder_ = keyboardBuilder;
350     }
351     void BindSelectionMenu(TextResponseType type, TextSpanType richEditorType, std::function<void()>& menuBuilder,
352         std::function<void(int32_t, int32_t)>& onAppear, std::function<void()>& onDisappear);
ClearSelectionMenu()353     void ClearSelectionMenu()
354     {
355         selectionMenuMap_.clear();
356     }
357     void DumpInfo() override;
358     void InitSelection(const Offset& pos);
359     bool HasFocus() const;
360     void OnColorConfigurationUpdate() override;
361     bool IsDisabled() const;
362     float GetLineHeight() const override;
363     std::vector<RectF> GetTextBoxes() override;
364     bool OnBackPressed() override;
365 
366     // Add for Scroll
367 
OnAttachToFrameNode()368     void OnAttachToFrameNode() override
369     {
370         TextPattern::OnAttachToFrameNode();
371     }
372 
OnDetachFromFrameNode(FrameNode * node)373     void OnDetachFromFrameNode(FrameNode* node) override
374     {
375         TextPattern::OnDetachFromFrameNode(node);
376         ScrollablePattern::OnDetachFromFrameNode(node);
377     }
378 
IsAtBottom()379     bool IsAtBottom() const override
380     {
381         return true;
382     }
383 
IsAtTop()384     bool IsAtTop() const override
385     {
386         return true;
387     }
388 
UpdateCurrentOffset(float offset,int32_t source)389     bool UpdateCurrentOffset(float offset, int32_t source) override
390     {
391         return true;
392     }
393 
GetTextRect()394     const RectF& GetTextRect() override
395     {
396         return richTextRect_;
397     }
398 
GetScrollOffset()399     float GetScrollOffset() const
400     {
401         return scrollOffset_;
402     }
403 
GetScrollControllerBar()404     RefPtr<ScrollBar> GetScrollControllerBar()
405     {
406         return GetScrollBar();
407     }
408 
409     bool OnScrollCallback(float offset, int32_t source) override;
410     void OnScrollEndCallback() override;
IsScrollable()411     bool IsScrollable() const override
412     {
413         return scrollable_;
414     }
415 
IsAtomicNode()416     bool IsAtomicNode() const override
417     {
418         return true;
419     }
420 
421     void CheckHandles(SelectHandleInfo& handleInfo) override;
422 
423     bool CheckHandleVisible(const RectF& paintRect) override;
424 
425     bool IsShowSelectMenuUsingMouse();
426 
427     void HandleOnCameraInput() override;
428 
429     RefPtr<FocusHub> GetFocusHub() const;
430     void ResetDragOption() override;
431     bool NeedShowAIDetect() override;
432 
GetEditorType()433     TextSpanType GetEditorType() const
434     {
435         return selectedType_.value_or(TextSpanType::NONE);
436     }
437     void GetCaretMetrics(CaretMetricsF& caretCaretMetric) override;
438 
SetShowSelect(bool isShowSelect)439     void SetShowSelect(bool isShowSelect)
440     {
441         showSelect_ = isShowSelect;
442     }
443 
GetAllChildren()444     const std::list<RefPtr<UINode>>& GetAllChildren() const override
445     {
446         auto host = GetHost();
447         CHECK_NULL_RETURN(host, TextPattern::GetAllChildren());
448         return host->GetChildren();
449     }
450 
451     void OnVirtualKeyboardAreaChanged() override;
452 
453 protected:
454     bool CanStartAITask() override;
455 
456 private:
457     void UpdateSelectMenuInfo(bool hasData, SelectOverlayInfo& selectInfo, bool isCopyAll);
458     void UpdateSelectOverlayOrCreate(SelectOverlayInfo& selectInfo, bool animation = false) override;
459     void HandleOnPaste() override;
460     void HandleOnCut() override;
461     void InitClickEvent(const RefPtr<GestureEventHub>& gestureHub) override;
462     void InitFocusEvent(const RefPtr<FocusHub>& focusHub);
463     void HandleBlurEvent();
464     void HandleFocusEvent();
465     void HandleClickEvent(GestureEvent& info);
466     void HandleSingleClickEvent(GestureEvent& info);
467     void HandleDoubleClickEvent(GestureEvent& info);
468     bool HandleUserClickEvent(GestureEvent& info);
469     bool HandleUserLongPressEvent(GestureEvent& info);
470     bool HandleUserGestureEvent(
471         GestureEvent& info, std::function<bool(RefPtr<SpanItem> item, GestureEvent& info)>&& gestureFunc);
472     void CalcCaretInfoByClick(GestureEvent& info);
473     void HandleEnabled();
474     void InitMouseEvent();
475     void ScheduleCaretTwinkling();
476     void OnCaretTwinkling();
477     void StartTwinkling();
478     void StopTwinkling();
479     void UpdateTextStyle(RefPtr<SpanNode>& spanNode, struct UpdateSpanStyle updateSpanStyle, TextStyle textStyle);
480     void UpdateSymbolStyle(RefPtr<SpanNode>& spanNode, struct UpdateSpanStyle updateSpanStyle, TextStyle textStyle);
481     void UpdateImageStyle(RefPtr<FrameNode>& imageNode, const ImageSpanAttribute& imageStyle);
482     void InitTouchEvent();
483     bool SelectOverlayIsOn();
484     void HandleLongPress(GestureEvent& info);
485     void HandleDoubleClickOrLongPress(GestureEvent& info);
486     std::string GetPositionSpansText(int32_t position, int32_t& startSpan);
487     void FireOnSelect(int32_t selectStart, int32_t selectEnd);
488     void FireOnSelectionChange(const int32_t caretPosition);
489     void FireOnSelectionChange(const TextSelector& selector);
490     void FireOnSelectionChange(int32_t selectStart, int32_t selectEnd);
491     void MouseRightFocus(const MouseInfo& info);
492     bool IsScrollBarPressed(const MouseInfo& info);
493     void HandleMouseLeftButtonMove(const MouseInfo& info);
494     void HandleMouseLeftButtonPress(const MouseInfo& info);
495     void HandleMouseLeftButtonRelease(const MouseInfo& info);
496     void HandleMouseLeftButton(const MouseInfo& info);
497     void HandleMouseRightButton(const MouseInfo& info);
498     void HandleMouseEvent(const MouseInfo& info);
499     void HandleTouchEvent(const TouchEventInfo& info);
500     void InitLongPressEvent(const RefPtr<GestureEventHub>& gestureHub);
501     void UseHostToUpdateTextFieldManager();
502     void UpdateTextFieldManager(const Offset& offset, float height);
503     void ScrollToSafeArea() const override;
504     void InitDragDropEvent();
505     void onDragDropAndLeave();
506     void ClearDragDropEvent();
507     void OnDragMove(const RefPtr<OHOS::Ace::DragEvent>& event);
508     void OnDragEnd(const RefPtr<Ace::DragEvent>& event);
509     void ToJsonValue(std::unique_ptr<JsonValue>& json) const override;
510 
AddDragFrameNodeToManager(const RefPtr<FrameNode> & frameNode)511     void AddDragFrameNodeToManager(const RefPtr<FrameNode>& frameNode)
512     {
513         auto context = PipelineContext::GetCurrentContext();
514         CHECK_NULL_VOID(context);
515         auto dragDropManager = context->GetDragDropManager();
516         CHECK_NULL_VOID(dragDropManager);
517         dragDropManager->AddDragFrameNode(frameNode->GetId(), AceType::WeakClaim(AceType::RawPtr(frameNode)));
518     }
519 
RemoveDragFrameNodeFromManager(const RefPtr<FrameNode> & frameNode)520     void RemoveDragFrameNodeFromManager(const RefPtr<FrameNode>& frameNode)
521     {
522         auto context = PipelineContext::GetCurrentContext();
523         CHECK_NULL_VOID(context);
524         auto dragDropManager = context->GetDragDropManager();
525         CHECK_NULL_VOID(dragDropManager);
526         dragDropManager->RemoveDragFrameNode(frameNode->GetId());
527     }
528 
529     void HandleCursorOnDragMoved(const RefPtr<NotifyDragEvent>& notifyDragEvent);
530     void HandleCursorOnDragLeaved(const RefPtr<NotifyDragEvent>& notifyDragEvent);
531     void HandleCursorOnDragEnded(const RefPtr<NotifyDragEvent>& notifyDragEvent);
532 
533     int32_t GetParagraphLength(const std::list<RefPtr<UINode>>& spans) const;
534     // REQUIRES: 0 <= start < end
535     std::vector<RefPtr<SpanNode>> GetParagraphNodes(int32_t start, int32_t end) const;
536     void OnHover(bool isHover);
537     bool RequestKeyboard(bool isFocusViewChanged, bool needStartTwinkling, bool needShowSoftKeyboard);
538     void UpdateCaretInfoToController();
539 #if defined(ENABLE_STANDARD_INPUT)
540     bool EnableStandardInput(bool needShowSoftKeyboard);
541     std::optional<MiscServices::TextConfig> GetMiscTextConfig();
542 #else
543     bool UnableStandardInput(bool isFocusViewChanged);
544 #endif
545 
546     bool HasConnection() const;
547     bool CloseKeyboard(bool forceClose) override;
548     void CalcInsertValueObj(TextInsertValueInfo& info);
549     void CalcDeleteValueObj(int32_t currentPosition, int32_t length, RichEditorDeleteValue& info);
550     int32_t DeleteValueSetBuilderSpan(const RefPtr<SpanItem>& spanItem, RichEditorAbstractSpanResult& spanResult);
551     int32_t DeleteValueSetImageSpan(const RefPtr<SpanItem>& spanItem, RichEditorAbstractSpanResult& spanResult);
552     int32_t DeleteValueSetSymbolSpan(const RefPtr<SpanItem>& spanItem, RichEditorAbstractSpanResult& spanResult);
553     int32_t DeleteValueSetTextSpan(const RefPtr<SpanItem>& spanItem, int32_t currentPosition, int32_t length,
554         RichEditorAbstractSpanResult& spanResult);
555     void DeleteByDeleteValueInfo(const RichEditorDeleteValue& info);
556     bool OnKeyEvent(const KeyEvent& keyEvent);
557     void MoveCaretAfterTextChange();
558     bool BeforeIMEInsertValue(const std::string& insertValue);
559     void AfterIMEInsertValue(const RefPtr<SpanNode>& spanNode, int32_t moveLength, bool isCreate);
560     RefPtr<SpanNode> InsertValueToBeforeSpan(RefPtr<SpanNode>& spanNodeBefore, const std::string& insertValue);
561     void SetCaretSpanIndex(int32_t index);
562     bool HasSameTypingStyle(const RefPtr<SpanNode>& spanNode);
563 
564     // add for scroll.
565     void UpdateChildrenOffset();
566     void MoveFirstHandle(float offset);
567     void MoveSecondHandle(float offset);
568     void InitScrollablePattern();
569     bool IsReachedBoundary(float offset);
570     void UpdateScrollBarOffset() override;
571     void CheckScrollable();
572     void UpdateScrollStateAfterLayout(bool shouldDisappear);
573     void ScheduleAutoScroll(AutoScrollParam param);
574     void OnAutoScroll(AutoScrollParam param);
575     void StopAutoScroll();
576     void AutoScrollByEdgeDetection(AutoScrollParam param, OffsetF offset, EdgeDetectionStrategy strategy);
577     float CalcDragSpeed(float hotAreaStart, float hotAreaEnd, float point);
578     float MoveTextRect(float offset);
579     void MoveCaretToContentRect();
580     void MoveCaretToContentRect(const OffsetF& caretOffset, float caretHeight);
IsTextArea()581     bool IsTextArea() const override
582     {
583         return true;
584     }
585     void ProcessInnerPadding();
IsReachTop()586     bool IsReachTop()
587     {
588         return NearEqual(richTextRect_.GetY(), contentRect_.GetY());
589     }
590 
IsReachBottom()591     bool IsReachBottom()
592     {
593         return NearEqual(richTextRect_.Bottom(), contentRect_.Bottom());
594     }
595     // ai analysis fun
596     bool NeedAiAnalysis(
597         const CaretUpdateType targeType, const int32_t pos, const int32_t& spanStart, const std::string& content);
598     void AdjustCursorPosition(int32_t& pos);
599     void AdjustPlaceholderSelection(int32_t& start, int32_t& end, const Offset& pos);
600     bool AdjustWordSelection(int32_t& start, int32_t& end);
601     bool IsClickBoundary(const int32_t position);
602     bool EraseEmoji();
603     bool EraseEmoji(const RefPtr<SpanItem>& spanItem);
604     void InsertValueInSpanOffset(const TextInsertValueInfo& info, std::wstring& text, const std::wstring& insertValue);
605     void SetSelfAndChildDraggableFalse(const RefPtr<UINode>& customNode);
606 
607     RectF GetSelectArea();
608     void UpdateOverlaySelectArea();
609     bool IsTouchInFrameArea(const PointF& touchPoint);
610 
611 #if defined(ENABLE_STANDARD_INPUT)
612     sptr<OHOS::MiscServices::OnTextChangedListener> richEditTextChangeListener_;
613 #else
614     RefPtr<TextInputConnection> connection_ = nullptr;
615 #endif
616     bool isMouseSelect_ = false;
617     bool isMousePressed_ = false;
618     bool isFirstMouseSelect_ = true;
619     bool leftMousePress_ = false;
620     bool isLongPress_ = false;
621     bool isDragging_ = false;
622 #if defined(OHOS_STANDARD_SYSTEM) && !defined(PREVIEW)
623     bool imeAttached_ = false;
624     bool imeShown_ = false;
625 #endif
626     bool isTextChange_ = false;
627     bool caretVisible_ = false;
628     bool caretTwinkling_ = false;
629     bool isRichEditorInit_ = false;
630     bool clickEventInitialized_ = false;
631     bool focusEventInitialized_ = false;
632     bool blockPress_ = false;
633     bool isCustomKeyboardAttached_ = false;
634     bool usingMouseRightButton_ = false;
635     bool isCursorAlwaysDisplayed_ = false;
636     bool isClickOnAISpan_ = false;
637 
638     int32_t moveLength_ = 0;
639     int32_t caretPosition_ = 0;
640     int32_t caretSpanIndex_ = -1;
641     long long timestamp_ = 0;
642     OffsetF parentGlobalOffset_;
643     OffsetF selectionMenuOffsetByMouse_;
644     OffsetF lastClickOffset_;
645     std::string pasteStr_;
646 
647     // still in progress
648     ParagraphManager paragraphs_;
649 
650     std::vector<OperationRecord> operationRecords_;
651     std::vector<OperationRecord> redoOperationRecords_;
652 
653     RefPtr<TouchEventImpl> touchListener_;
654     struct UpdateSpanStyle updateSpanStyle_;
655     CancelableCallback<void()> caretTwinklingTask_;
656     RefPtr<RichEditorController> richEditorController_;
657     MoveDirection moveDirection_ = MoveDirection::FORWARD;
658     RectF frameRect_;
659     std::optional<struct UpdateSpanStyle> typingStyle_;
660     std::optional<TextStyle> typingTextStyle_;
661     std::list<ResultObject> dragResultObjects_;
662 
663     std::function<void()> customKeyboardBuilder_;
664     RefPtr<OverlayManager> keyboardOverlay_;
665     Offset selectionMenuOffset_;
666     // add for scroll
667     RectF richTextRect_;
668     float scrollOffset_ = 0.0f;
669     bool isFirstCallOnReady_ = false;
670     bool scrollable_ = true;
671     CancelableCallback<void()> autoScrollTask_;
672     OffsetF prevAutoScrollOffset_;
673     AutoScrollParam currentScrollParam_;
674     bool isAutoScrollRunning_ = false;
675     // add for ai input analysis
676     bool hasClicked_ = false;
677     CaretUpdateType caretUpdateType_ = CaretUpdateType::NONE;
678     TimeStamp lastClickTimeStamp_;
679     TimeStamp lastAiPosTimeStamp_;
680     bool adjusted_ = false;
681     bool isShowMenu_ = true;
682     ACE_DISALLOW_COPY_AND_MOVE(RichEditorPattern);
683 };
684 } // namespace OHOS::Ace::NG
685 
686 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_RICH_EDITOR_RICH_EDITOR_PATTERN_H
687