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