1  /*
2   * Copyright (c) 2021 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  #include "core/components/text_overlay/text_overlay_component.h"
17  
18  #include "base/i18n/localization.h"
19  #include "base/json/json_util.h"
20  #include "core/components/box/box_component.h"
21  #include "core/components/button/button_component.h"
22  #include "core/components/clip/clip_component.h"
23  #include "core/components/common/properties/shadow_config.h"
24  #include "core/components/flex/flex_component.h"
25  #include "core/components/focus_collaboration/focus_collaboration_component.h"
26  #include "core/components/image/image_component.h"
27  #include "core/components/padding/padding_component.h"
28  #include "core/components/text/text_component.h"
29  #include "core/components/text_overlay/render_text_overlay.h"
30  #include "core/components/text_overlay/text_overlay_element.h"
31  #include "core/components/theme/theme_manager.h"
32  #include "core/event/ace_event_helper.h"
33  #include "core/event/back_end_event_manager.h"
34  
35  namespace OHOS::Ace {
36  namespace {
37  
38  constexpr char BUTTON_COPY_ALL[] = "textoverlay.select_all";
39  constexpr char BUTTON_CUT[] = "textoverlay.cut";
40  constexpr char BUTTON_COPY[] = "textoverlay.copy";
41  constexpr char BUTTON_PASTE[] = "textoverlay.paste";
42  constexpr char BUTTON_TRANSLATE[] = "textoverlay.translate";
43  constexpr char BUTTON_SHARE[] = "textoverlay.share";
44  constexpr char BUTTON_SEARCH[] = "textoverlay.search";
45  constexpr char OVERLAY_TRANSLATE[] = "translate";
46  constexpr char OVERLAY_SHARE[] = "share";
47  constexpr char OVERLAY_SEARCH[] = "search";
48  
49  constexpr Dimension OVERLAY_MARGIN_BOTTOM = 8.0_vp;
50  constexpr Dimension TOOL_BAR_HEIGHT = 40.0_vp;
51  
52  } // namespace
53  
TextOverlayComponent(const RefPtr<ThemeManager> & themeManager,const RefPtr<AccessibilityManager> & accessibilityManager)54  TextOverlayComponent::TextOverlayComponent(
55      const RefPtr<ThemeManager>& themeManager, const RefPtr<AccessibilityManager>& accessibilityManager)
56  {
57      themeManager_ = themeManager;
58      accessibilityManager_ = accessibilityManager;
59      InitThemeStyle(themeManager);
60  }
61  
CreateElement()62  RefPtr<Element> TextOverlayComponent::CreateElement()
63  {
64      return AceType::MakeRefPtr<TextOverlayElement>();
65  }
66  
CreateRenderNode()67  RefPtr<RenderNode> TextOverlayComponent::CreateRenderNode()
68  {
69      return RenderTextOverlay::Create();
70  }
71  
InitThemeStyle(const RefPtr<ThemeManager> & themeManager)72  void TextOverlayComponent::InitThemeStyle(const RefPtr<ThemeManager>& themeManager)
73  {
74      theme_ = themeManager->GetTheme<TextOverlayTheme>();
75      if (!theme_) {
76          return;
77      }
78      handleColor_ = theme_->GetHandleColor();
79      handleColorInner_ = theme_->GetHandleColorInner();
80      handleDiameter_ = theme_->GetHandleDiameter();
81      handleDiameterInner_ = theme_->GetHandleDiameterInner();
82      menuSpacingWithText_ = theme_->GetMenuSpacingWithText();
83  }
84  
BuildChild(bool isSingleHandle,bool hasToolBar,bool hasMenu,bool hasIcon,bool hasAnimation)85  RefPtr<Component> TextOverlayComponent::BuildChild(
86      bool isSingleHandle, bool hasToolBar, bool hasMenu, bool hasIcon, bool hasAnimation)
87  {
88      // if type of input is password, don't show tool menu.
89      if (isPassword_) {
90          return nullptr;
91      }
92      if (!hasToolBar && !hasMenu && !hasIcon) {
93          return nullptr;
94      }
95      std::list<RefPtr<Component>> columnChildren;
96      auto column = AceType::MakeRefPtr<ColumnComponent>(FlexAlign::SPACE_AROUND, FlexAlign::FLEX_END, columnChildren);
97      if (GetTextDirection() == TextDirection::RTL) {
98          column->SetCrossAxisAlign(FlexAlign::FLEX_START);
99      }
100      column->SetMainAxisSize(MainAxisSize::MIN);
101  
102      if (!isUsingMouse_) {
103          column->AppendChild(BuildToolBar(isSingleHandle, hasToolBar, hasMenu, hasIcon, hasAnimation));
104      } else {
105          column->AppendChild(BuildMenu());
106      }
107      // Add toolbar.
108      if (hasMenu && !isUsingMouse_) {
109          // Add menu.
110          column->AppendChild(BuildMenu());
111      } else {
112          menu_.Reset();
113      }
114  
115      // Add focus collaboration to show focus animation.
116      auto focusCollaboration = AceType::MakeRefPtr<FocusCollaborationComponent>();
117      focusCollaboration->InsertChild(0, column);
118      return focusCollaboration;
119  }
120  
BuildToolBar(bool isSingleHandle,bool hasToolBar,bool hasMenu,bool hasIcon,bool hasAnimation)121  RefPtr<Component> TextOverlayComponent::BuildToolBar(
122      bool isSingleHandle, bool hasToolBar, bool hasMenu, bool hasIcon, bool hasAnimation)
123  {
124      if (!hasToolBar && !hasMenu && !hasIcon) {
125          return nullptr;
126      }
127  
128      std::list<RefPtr<Component>> operations;
129      auto row = AceType::MakeRefPtr<RowComponent>(FlexAlign::SPACE_AROUND, FlexAlign::FLEX_START, operations);
130      row->SetMainAxisSize(MainAxisSize::MIN);
131      row->SetStretchToParent(true);
132      if (hasToolBar) {
133          if (!isSingleHandle) {
134              if (onCut_) {
135                  row->AppendChild(
136                      BuildButton(Localization::GetInstance()->GetEntryLetters(BUTTON_CUT), cutButtonMarker_));
137              }
138              if (onCopy_) {
139                  row->AppendChild(
140                      BuildButton(Localization::GetInstance()->GetEntryLetters(BUTTON_COPY), copyButtonMarker_));
141              }
142          }
143          if (onPaste_) {
144              row->AppendChild(
145                  BuildButton(Localization::GetInstance()->GetEntryLetters(BUTTON_PASTE), pasteButtonMarker_));
146          }
147          if (onCopyAll_) {
148              row->AppendChild(
149                  BuildButton(Localization::GetInstance()->GetEntryLetters(BUTTON_COPY_ALL), copyAllButtonMarker_));
150          }
151          if (!translateButtonMarker_.IsEmpty()) {
152              const auto& translateButtonMarker = BackEndEventManager<void()>::GetInstance().GetAvailableMarker();
153              BackEndEventManager<void()>::GetInstance().BindBackendEvent(
154                  translateButtonMarker, [weak = WeakClaim(this)]() {
155                      auto overlay = weak.Upgrade();
156                      if (overlay) {
157                          overlay->OnToolBarButtonClick(overlay->translateButtonMarker_, OVERLAY_TRANSLATE);
158                      }
159                  });
160              row->AppendChild(
161                  BuildButton(Localization::GetInstance()->GetEntryLetters(BUTTON_TRANSLATE), translateButtonMarker));
162          }
163      }
164      if (hasIcon && (!options_.empty() || !shareButtonMarker_.IsEmpty() || !searchButtonMarker_.IsEmpty())) {
165          hasMoreButton_ = true;
166          row->AppendChild(BuildMoreIconButton(hasMenu));
167      } else {
168          hasMoreButton_ = false;
169      }
170      auto firstButton = DynamicCast<ButtonComponent>(row->GetChildren().front());
171      if (firstButton) {
172          firstButton->SetAutoFocusState(true);
173      }
174      auto box = AceType::MakeRefPtr<BoxComponent>();
175      if (theme_) {
176          auto backDecoration = AceType::MakeRefPtr<Decoration>();
177          backDecoration->SetBackgroundColor(theme_->GetMenuBackgroundColor());
178          backDecoration->SetBorder(theme_->GetMenuBorder());
179          backDecoration->SetBorderRadius(Radius(theme_->GetMenuButtonHeight()));
180          box->SetBackDecoration(backDecoration);
181          box->SetPadding(theme_->GetMenuPadding());
182      }
183  
184      if (hasAnimation) {
185          if (innerComposeId_.empty()) {
186              innerComposeId_ = TweenComponent::AllocTweenComponentId();
187          }
188          auto innerTween = AceType::MakeRefPtr<TweenComponent>(innerComposeId_, innerComposeId_, row);
189          innerTween->SetIsFirstFrameShow(true);
190          box->SetChild(innerTween);
191      } else {
192          box->SetChild(row);
193      }
194      box->SetTextDirection(GetTextDirection());
195      return BuildAnimation(box, hasAnimation);
196  }
197  
BuildButton(const std::string & data,const EventMarker & onClick)198  RefPtr<ButtonComponent> TextOverlayComponent::BuildButton(const std::string& data, const EventMarker& onClick)
199  {
200      if (!theme_) {
201          return nullptr;
202      }
203      auto text = AceType::MakeRefPtr<TextComponent>(data);
204      text->SetTextStyle(theme_->GetMenuButtonTextStyle());
205      text->SetFocusColor(theme_->GetMenuButtonTextStyle().GetTextColor());
206  
207      auto padding = AceType::MakeRefPtr<PaddingComponent>();
208      padding->SetPadding(theme_->GetMenuButtonPadding());
209      padding->SetChild(text);
210  
211      std::list<RefPtr<Component>> children;
212      children.emplace_back(padding);
213      auto button = AceType::MakeRefPtr<ButtonComponent>(children);
214      button->SetIsInnerBorder(true);
215      button->SetClickedEventId(onClick);
216      button->SetHeight(theme_->GetMenuButtonHeight());
217      button->SetRectRadius(theme_->GetMenuButtonHeight() / 2.0);
218      button->SetBackgroundColor(theme_->GetMenuBackgroundColor());
219      button->SetHoverColor(theme_->GetButtonHoverColor());
220      button->SetClickedColor(theme_->GetButtonClickedColor());
221      button->SetFocusColor(theme_->GetMenuBackgroundColor());
222      button->SetFocusable(false);
223      return button;
224  }
225  
BuildMoreIconButton(bool hasMenu)226  RefPtr<ButtonComponent> TextOverlayComponent::BuildMoreIconButton(bool hasMenu)
227  {
228      if (!theme_) {
229          return nullptr;
230      }
231  
232      std::list<RefPtr<Component>> children;
233      auto context = context_.Upgrade();
234      if (context && context->GetIsDeclarative()) {
235          children.emplace_back(AceType::MakeRefPtr<ImageComponent>(InternalResource::ResourceId::IC_MORE));
236      }
237      auto button = AceType::MakeRefPtr<ButtonComponent>(children);
238      button->SetIsInnerBorder(true);
239      button->SetClickedEventId(moreButtonMarker_);
240      button->SetHeight(theme_->GetMenuButtonHeight());
241      button->SetWidth(theme_->GetMenuButtonHeight());
242      button->SetRectRadius(theme_->GetMenuButtonHeight() / 2.0);
243      button->SetBackgroundColor(Color::TRANSPARENT);
244      button->SetHoverColor(theme_->GetButtonHoverColor());
245      button->SetClickedColor(theme_->GetButtonClickedColor());
246      button->SetFocusColor(theme_->GetMenuBackgroundColor());
247      return button;
248  }
249  
BuildAnimation(const RefPtr<Component> & child,bool hasAnimation)250  RefPtr<Component> TextOverlayComponent::BuildAnimation(const RefPtr<Component>& child, bool hasAnimation)
251  {
252      auto box = AceType::MakeRefPtr<BoxComponent>();
253      if (hasAnimation) {
254          auto clip = AceType::MakeRefPtr<ClipComponent>(child);
255          clip->SetTopLeftRadius(Radius(theme_->GetMenuButtonHeight()));
256          clip->SetTopRightRadius(Radius(theme_->GetMenuButtonHeight()));
257          clip->SetBottomLeftRadius(Radius(theme_->GetMenuButtonHeight()));
258          clip->SetBottomRightRadius(Radius(theme_->GetMenuButtonHeight()));
259          clip->SetHeight(TOOL_BAR_HEIGHT);
260          clip->SetClipWithShadow(true);
261  
262          if (outerComposeId_.empty()) {
263              outerComposeId_ = TweenComponent::AllocTweenComponentId();
264          }
265          auto outerTween = AceType::MakeRefPtr<TweenComponent>(outerComposeId_, outerComposeId_, clip);
266          outerTween->SetIsFirstFrameShow(true);
267          box->SetChild(outerTween);
268      } else {
269          box->SetChild(child);
270      }
271  
272      auto backDecoration = AceType::MakeRefPtr<Decoration>();
273      backDecoration->AddShadow(ShadowConfig::DefaultShadowM);
274      backDecoration->SetBackgroundColor(theme_->GetMenuBackgroundColor());
275      backDecoration->SetBorder(theme_->GetMenuBorder());
276      backDecoration->SetBorderRadius(Radius(theme_->GetMenuButtonHeight()));
277      box->SetBackDecoration(backDecoration);
278      return box;
279  }
280  
BuildMenuForDeclative(bool isSingleHandle)281  void TextOverlayComponent::BuildMenuForDeclative(bool isSingleHandle)
282  {
283      if (onCut_ && !isSingleHandle) {
284          auto optionComponent = BuildMenuOption(
285              "", InternalResource::ResourceId::NO_ID, Localization::GetInstance()->GetEntryLetters(BUTTON_CUT), false);
286          optionComponent->SetClickEvent(cutButtonMarker_);
287          menu_->AppendSelectOption(optionComponent);
288      }
289      if (onCopy_ && !isSingleHandle) {
290          auto optionComponent = BuildMenuOption(
291              "", InternalResource::ResourceId::NO_ID, Localization::GetInstance()->GetEntryLetters(BUTTON_COPY), false);
292          optionComponent->SetClickEvent(copyButtonMarker_);
293          menu_->AppendSelectOption(optionComponent);
294      }
295  
296      if (onPaste_) {
297          auto optionComponent = BuildMenuOption(
298              "", InternalResource::ResourceId::NO_ID, Localization::GetInstance()->GetEntryLetters(BUTTON_PASTE), false);
299          optionComponent->SetClickEvent(pasteButtonMarker_);
300          menu_->AppendSelectOption(optionComponent);
301      }
302      if (onCopyAll_) {
303          auto optionComponent = BuildMenuOption("", InternalResource::ResourceId::NO_ID,
304              Localization::GetInstance()->GetEntryLetters(BUTTON_COPY_ALL), false);
305          optionComponent->SetClickEvent(copyAllButtonMarker_);
306          menu_->AppendSelectOption(optionComponent);
307      }
308  }
309  
BuildMenu(bool isSingleHandle)310  RefPtr<Component> TextOverlayComponent::BuildMenu(bool isSingleHandle)
311  {
312      if (!menu_) {
313          menu_ = AceType::MakeRefPtr<SelectPopupComponent>();
314          menu_->ClearAllOptions();
315          auto context = context_.Upgrade();
316          if (context && context->GetIsDeclarative() && isUsingMouse_) {
317              BuildMenuForDeclative(isSingleHandle);
318          } else {
319              if (!shareButtonMarker_.IsEmpty()) {
320                  auto optionComponent = BuildMenuOption("", InternalResource::ResourceId::SHARE_SVG,
321                      Localization::GetInstance()->GetEntryLetters(BUTTON_SHARE), true);
322                  const auto& shareButtonMarker = BackEndEventManager<void()>::GetInstance().GetAvailableMarker();
323                  optionComponent->SetClickEvent(shareButtonMarker);
324                  BackEndEventManager<void()>::GetInstance().BindBackendEvent(
325                      shareButtonMarker, [weak = WeakClaim(this)]() {
326                          auto overlay = weak.Upgrade();
327                          if (overlay) {
328                              overlay->OnToolBarButtonClick(overlay->shareButtonMarker_, OVERLAY_SHARE);
329                          }
330                      });
331                  menu_->AppendSelectOption(optionComponent);
332              }
333              if (!searchButtonMarker_.IsEmpty()) {
334                  auto optionComponent = BuildMenuOption("", InternalResource::ResourceId::SEARCH_SVG,
335                      Localization::GetInstance()->GetEntryLetters(BUTTON_SEARCH), true);
336                  const auto& searchButtonMarker = BackEndEventManager<void()>::GetInstance().GetAvailableMarker();
337                  optionComponent->SetClickEvent(searchButtonMarker);
338                  BackEndEventManager<void()>::GetInstance().BindBackendEvent(
339                      searchButtonMarker, [weak = WeakClaim(this)]() {
340                          auto overlay = weak.Upgrade();
341                          if (overlay) {
342                              overlay->OnToolBarButtonClick(overlay->searchButtonMarker_, OVERLAY_SEARCH);
343                          }
344                      });
345                  menu_->AppendSelectOption(optionComponent);
346              }
347          }
348          AddOptionForMenu();
349          menu_->SetIsFullScreen(false);
350          menu_->InitTheme(themeManager_);
351          menu_->Initialize(accessibilityManager_.Upgrade());
352      }
353  
354      auto box = AceType::MakeRefPtr<BoxComponent>();
355      box->SetChild(menu_);
356      box->SetMargin(Edge(0.0_vp, OVERLAY_MARGIN_BOTTOM, 0.0_vp, 0.0_vp));
357      return box;
358  }
359  
AddOptionForMenu()360  void TextOverlayComponent::AddOptionForMenu()
361  {
362      int32_t index = 0;
363      for (const auto& option : options_) {
364          auto optionComponent = BuildMenuOption(option.image, InternalResource::ResourceId::NO_ID, option.text, false);
365          EventMarker clickEvent = BackEndEventManager<void()>::GetInstance().GetAvailableMarker();
366          optionComponent->SetClickEvent(clickEvent);
367          BackEndEventManager<void()>::GetInstance().BindBackendEvent(clickEvent, [weak = WeakClaim(this), index]() {
368              auto overlay = weak.Upgrade();
369              overlay->OnOptionClick(index);
370          });
371          menu_->AppendSelectOption(optionComponent);
372          ++index;
373      }
374  }
375  
BuildMenuOption(const std::string & imageSrc,InternalResource::ResourceId resourceId,const std::string & text,bool useResource)376  RefPtr<OptionComponent> TextOverlayComponent::BuildMenuOption(
377      const std::string& imageSrc, InternalResource::ResourceId resourceId, const std::string& text, bool useResource)
378  {
379      auto optionComponent = AceType::MakeRefPtr<OptionComponent>();
380      RefPtr<ImageComponent> image;
381      if (useResource) {
382          image = AceType::MakeRefPtr<ImageComponent>(resourceId);
383          if (theme_) {
384              // fill color only effect svg image color
385              image->SetImageFill(theme_->GetMenuIconColor());
386          }
387      } else {
388          image = AceType::MakeRefPtr<ImageComponent>(imageSrc);
389          if (image) {
390              // fill color only effect svg image color
391              image->SetImageFill(imageFill_);
392          }
393      }
394      if (!isUsingMouse_) {
395          optionComponent->SetIcon(image);
396      } else {
397          optionComponent->SetNeedDrawDividerLine(false);
398      }
399      auto textComponent = AceType::MakeRefPtr<TextComponent>(text);
400      optionComponent->SetText(textComponent);
401      optionComponent->SetValue(text);
402      optionComponent->InitTheme(themeManager_);
403      optionComponent->Initialize(accessibilityManager_.Upgrade());
404      return optionComponent;
405  }
406  
OnOptionClick(int32_t index)407  void TextOverlayComponent::OnOptionClick(int32_t index)
408  {
409      const auto& event = AceAsyncEvent<void(const std::string&)>::Create(optionsClickMarker_, context_);
410      if (event) {
411          auto jsonResult = JsonUtil::Create(true);
412          jsonResult->Put("index", index);
413          jsonResult->Put("value", GetSelectedText().c_str());
414          event(std::string(R"("optionselect",)").append(jsonResult->ToString()));
415      }
416      if (popOverlay_) {
417          popOverlay_();
418      }
419  }
420  
OnToolBarButtonClick(const EventMarker & marker,const std::string & eventName)421  void TextOverlayComponent::OnToolBarButtonClick(const EventMarker& marker, const std::string& eventName)
422  {
423      const auto& event = AceAsyncEvent<void(const std::string&)>::Create(marker, context_);
424      if (event) {
425          auto jsonResult = JsonUtil::Create(true);
426          jsonResult->Put("value", GetSelectedText().c_str());
427          if (eventName == OVERLAY_TRANSLATE) {
428              event(std::string(R"("translate",)").append(jsonResult->ToString()));
429          } else if (eventName == OVERLAY_SHARE) {
430              event(std::string(R"("share",)").append(jsonResult->ToString()));
431          } else if (eventName == OVERLAY_SEARCH) {
432              event(std::string(R"("search",)").append(jsonResult->ToString()));
433          }
434      }
435      if (popOverlay_) {
436          popOverlay_();
437      }
438  }
439  
GetSelectedText() const440  std::string TextOverlayComponent::GetSelectedText() const
441  {
442      const auto& textField = weakTextField_.Upgrade();
443      if (textField) {
444          return textField->GetEditingValue().GetSelectedText();
445      }
446      return "";
447  }
448  
HasMoreButton() const449  bool TextOverlayComponent::HasMoreButton() const
450  {
451      return hasMoreButton_;
452  }
453  
SetIsPassword(bool isPassword)454  void TextOverlayComponent::SetIsPassword(bool isPassword)
455  {
456      isPassword_ = isPassword;
457  }
458  
GetIsPassword() const459  bool TextOverlayComponent::GetIsPassword() const
460  {
461      return isPassword_;
462  }
463  
SetIsSingleHandle(bool isSingleHandle)464  void TextOverlayComponent::SetIsSingleHandle(bool isSingleHandle)
465  {
466      isSingleHandle_ = isSingleHandle;
467  }
468  
GetIsSingleHandle() const469  bool TextOverlayComponent::GetIsSingleHandle() const
470  {
471      return isSingleHandle_;
472  }
473  
SetLineHeight(double lineHeight)474  void TextOverlayComponent::SetLineHeight(double lineHeight)
475  {
476      lineHeight_ = lineHeight;
477  }
478  
GetLineHeight() const479  double TextOverlayComponent::GetLineHeight() const
480  {
481      return lineHeight_;
482  }
483  
SetStartHandleHeight(double startHandleHeight)484  void TextOverlayComponent::SetStartHandleHeight(double startHandleHeight)
485  {
486      startHandleHeight_ = startHandleHeight;
487  }
488  
GetStartHandleHeight() const489  const std::optional<double>& TextOverlayComponent::GetStartHandleHeight() const
490  {
491      return startHandleHeight_;
492  }
493  
SetEndHandleHeight(double endHandleHeight)494  void TextOverlayComponent::SetEndHandleHeight(double endHandleHeight)
495  {
496      endHandleHeight_ = endHandleHeight;
497  }
498  
GetEndHandleHeight() const499  const std::optional<double>& TextOverlayComponent::GetEndHandleHeight() const
500  {
501      return endHandleHeight_;
502  }
503  
SetClipRect(const Rect & clipRect)504  void TextOverlayComponent::SetClipRect(const Rect& clipRect)
505  {
506      clipRect_ = clipRect;
507  }
508  
GetClipRect() const509  const Rect& TextOverlayComponent::GetClipRect() const
510  {
511      return clipRect_;
512  }
513  
SetHandleColor(const Color & handleColor)514  void TextOverlayComponent::SetHandleColor(const Color& handleColor)
515  {
516      handleColor_ = handleColor;
517  }
518  
GetHandleColor() const519  const Color& TextOverlayComponent::GetHandleColor() const
520  {
521      return handleColor_;
522  }
523  
SetHandleColorInner(const Color & handleColorInner)524  void TextOverlayComponent::SetHandleColorInner(const Color& handleColorInner)
525  {
526      handleColorInner_ = handleColorInner;
527  }
528  
GetHandleColorInner() const529  const Color& TextOverlayComponent::GetHandleColorInner() const
530  {
531      return handleColorInner_;
532  }
533  
SetHandleDiameter(const Dimension & handleDiameter)534  void TextOverlayComponent::SetHandleDiameter(const Dimension& handleDiameter)
535  {
536      handleDiameter_ = handleDiameter;
537  }
538  
GetHandleDiameter() const539  const Dimension& TextOverlayComponent::GetHandleDiameter() const
540  {
541      return handleDiameter_;
542  }
543  
SetHandleDiameterInner(const Dimension & handleDiameterInner)544  void TextOverlayComponent::SetHandleDiameterInner(const Dimension& handleDiameterInner)
545  {
546      handleDiameterInner_ = handleDiameterInner;
547  }
548  
GetHandleDiameterInner() const549  const Dimension& TextOverlayComponent::GetHandleDiameterInner() const
550  {
551      return handleDiameterInner_;
552  }
553  
SetMenuSpacingWithText(const Dimension & menuSpacingWithText)554  void TextOverlayComponent::SetMenuSpacingWithText(const Dimension& menuSpacingWithText)
555  {
556      menuSpacingWithText_ = menuSpacingWithText;
557  }
558  
GetMenuSpacingWithText() const559  const Dimension& TextOverlayComponent::GetMenuSpacingWithText() const
560  {
561      return menuSpacingWithText_;
562  }
563  
SetOnFocusChange(const std::function<void (bool,bool)> & onFocusChange)564  void TextOverlayComponent::SetOnFocusChange(const std::function<void(bool, bool)>& onFocusChange)
565  {
566      onFocusChange_ = onFocusChange;
567  }
568  
GetOnFocusChange() const569  const std::function<void(bool, bool)>& TextOverlayComponent::GetOnFocusChange() const
570  {
571      return onFocusChange_;
572  }
573  
SetOnCut(const CommonCallback & onCut)574  void TextOverlayComponent::SetOnCut(const CommonCallback& onCut)
575  {
576      onCut_ = onCut;
577  }
578  
GetOnCut() const579  const CommonCallback& TextOverlayComponent::GetOnCut() const
580  {
581      return onCut_;
582  }
583  
SetOnCopy(const CommonCallback & onCopy)584  void TextOverlayComponent::SetOnCopy(const CommonCallback& onCopy)
585  {
586      onCopy_ = onCopy;
587  }
588  
GetOnCopy() const589  const CommonCallback& TextOverlayComponent::GetOnCopy() const
590  {
591      return onCopy_;
592  }
593  
SetOnPaste(const CommonCallback & onPaste)594  void TextOverlayComponent::SetOnPaste(const CommonCallback& onPaste)
595  {
596      onPaste_ = onPaste;
597  }
598  
GetOnPaste() const599  const CommonCallback& TextOverlayComponent::GetOnPaste() const
600  {
601      return onPaste_;
602  }
603  
SetOnCopyAll(const CopyAllCallback & onCopyAll)604  void TextOverlayComponent::SetOnCopyAll(const CopyAllCallback& onCopyAll)
605  {
606      onCopyAll_ = onCopyAll;
607  }
608  
GetOnCopyAll() const609  const CopyAllCallback& TextOverlayComponent::GetOnCopyAll() const
610  {
611      return onCopyAll_;
612  }
613  
SetCutButtonMarker(const EventMarker & cutButtonMarker)614  void TextOverlayComponent::SetCutButtonMarker(const EventMarker& cutButtonMarker)
615  {
616      cutButtonMarker_ = cutButtonMarker;
617  }
618  
GetCutButtonMarker() const619  const EventMarker& TextOverlayComponent::GetCutButtonMarker() const
620  {
621      return cutButtonMarker_;
622  }
623  
SetCopyButtonMarker(const EventMarker & copyButtonMarker)624  void TextOverlayComponent::SetCopyButtonMarker(const EventMarker& copyButtonMarker)
625  {
626      copyButtonMarker_ = copyButtonMarker;
627  }
628  
GetCopyButtonMarker() const629  const EventMarker& TextOverlayComponent::GetCopyButtonMarker() const
630  {
631      return copyButtonMarker_;
632  }
633  
SetPasteButtonMarker(const EventMarker & pasteButtonMarker)634  void TextOverlayComponent::SetPasteButtonMarker(const EventMarker& pasteButtonMarker)
635  {
636      pasteButtonMarker_ = pasteButtonMarker;
637  }
638  
GetPasteButtonMarker() const639  const EventMarker& TextOverlayComponent::GetPasteButtonMarker() const
640  {
641      return pasteButtonMarker_;
642  }
643  
SetCopyAllButtonMarker(const EventMarker & copyAllButtonMarker)644  void TextOverlayComponent::SetCopyAllButtonMarker(const EventMarker& copyAllButtonMarker)
645  {
646      copyAllButtonMarker_ = copyAllButtonMarker;
647  }
648  
GetCopyAllButtonMarker() const649  const EventMarker& TextOverlayComponent::GetCopyAllButtonMarker() const
650  {
651      return copyAllButtonMarker_;
652  }
653  
SetMoreButtonMarker(const EventMarker & moreButtonMarker)654  void TextOverlayComponent::SetMoreButtonMarker(const EventMarker& moreButtonMarker)
655  {
656      moreButtonMarker_ = moreButtonMarker;
657  }
658  
GetMoreButtonMarker() const659  const EventMarker& TextOverlayComponent::GetMoreButtonMarker() const
660  {
661      return moreButtonMarker_;
662  }
663  
SetStartHandleOffset(const Offset & offset)664  void TextOverlayComponent::SetStartHandleOffset(const Offset& offset)
665  {
666      startHandleOffset_ = offset;
667  }
668  
GetStartHandleOffset() const669  const Offset& TextOverlayComponent::GetStartHandleOffset() const
670  {
671      return startHandleOffset_;
672  }
673  
SetEndHandleOffset(const Offset & offset)674  void TextOverlayComponent::SetEndHandleOffset(const Offset& offset)
675  {
676      endHandleOffset_ = offset;
677  }
678  
GetEndHandleOffset() const679  const Offset& TextOverlayComponent::GetEndHandleOffset() const
680  {
681      return endHandleOffset_;
682  }
683  
SetMouseOffset(const Offset & mouseOffset)684  void TextOverlayComponent::SetMouseOffset(const Offset& mouseOffset)
685  {
686      mouseOffset_ = mouseOffset;
687  }
688  
GetMouseOffset() const689  const Offset& TextOverlayComponent::GetMouseOffset() const
690  {
691      return mouseOffset_;
692  }
693  
SetOnStartHandleMove(const StartHandleMoveCallback & onStartHandleMove)694  void TextOverlayComponent::SetOnStartHandleMove(const StartHandleMoveCallback& onStartHandleMove)
695  {
696      onStartHandleMove_ = onStartHandleMove;
697  }
698  
GetOnStartHandleMove() const699  const StartHandleMoveCallback& TextOverlayComponent::GetOnStartHandleMove() const
700  {
701      return onStartHandleMove_;
702  }
703  
SetOnEndHandleMove(const EndHandleMoveCallback & onEndHandleMove)704  void TextOverlayComponent::SetOnEndHandleMove(const EndHandleMoveCallback& onEndHandleMove)
705  {
706      onEndHandleMove_ = onEndHandleMove;
707  }
708  
GetOnEndHandleMove() const709  const EndHandleMoveCallback& TextOverlayComponent::GetOnEndHandleMove() const
710  {
711      return onEndHandleMove_;
712  }
713  
SetWeakTextField(const WeakPtr<RenderTextField> & weakTextField)714  void TextOverlayComponent::SetWeakTextField(const WeakPtr<RenderTextField>& weakTextField)
715  {
716      weakTextField_ = weakTextField;
717  }
718  
GetWeakTextField() const719  const WeakPtr<RenderTextField>& TextOverlayComponent::GetWeakTextField() const
720  {
721      return weakTextField_;
722  }
723  
SetWeakText(const WeakPtr<RenderText> & weakText)724  void TextOverlayComponent::SetWeakText(const WeakPtr<RenderText>& weakText)
725  {
726      weakText_ = weakText;
727  }
728  
GetWeakText() const729  const WeakPtr<RenderText>& TextOverlayComponent::GetWeakText() const
730  {
731      return weakText_;
732  }
733  
SetWeakImage(const WeakPtr<RenderImage> & weakImage)734  void TextOverlayComponent::SetWeakImage(const WeakPtr<RenderImage>& weakImage)
735  {
736      weakImage_ = weakImage;
737  }
738  
GetWeakImage() const739  const WeakPtr<RenderImage>& TextOverlayComponent::GetWeakImage() const
740  {
741      return weakImage_;
742  }
743  
744  #ifdef WEB_SUPPORTED
SetWeakWeb(const WeakPtr<RenderWeb> & weakWeb)745  void TextOverlayComponent::SetWeakWeb(const WeakPtr<RenderWeb>& weakWeb)
746  {
747      weakWeb_ = weakWeb;
748  }
749  
GetWeakWeb() const750  const WeakPtr<RenderWeb>& TextOverlayComponent::GetWeakWeb() const
751  {
752      return weakWeb_;
753  }
754  #endif
755  
SetRealTextDirection(TextDirection realTextDirection)756  void TextOverlayComponent::SetRealTextDirection(TextDirection realTextDirection)
757  {
758      realTextDirection_ = realTextDirection;
759  }
760  
GetRealTextDirection() const761  TextDirection TextOverlayComponent::GetRealTextDirection() const
762  {
763      return realTextDirection_;
764  }
765  
SetOptions(const std::vector<InputOption> & options)766  void TextOverlayComponent::SetOptions(const std::vector<InputOption>& options)
767  {
768      options_ = options;
769  }
770  
GetOptions() const771  const std::vector<InputOption>& TextOverlayComponent::GetOptions() const
772  {
773      return options_;
774  }
775  
SetImageFill(const std::optional<Color> & imageFill)776  void TextOverlayComponent::SetImageFill(const std::optional<Color>& imageFill)
777  {
778      imageFill_ = imageFill;
779  }
780  
SetOptionsClickMarker(const EventMarker & onOptionsClick)781  void TextOverlayComponent::SetOptionsClickMarker(const EventMarker& onOptionsClick)
782  {
783      optionsClickMarker_ = onOptionsClick;
784  }
785  
SetTranslateButtonMarker(const EventMarker & onTranslate)786  void TextOverlayComponent::SetTranslateButtonMarker(const EventMarker& onTranslate)
787  {
788      translateButtonMarker_ = onTranslate;
789  }
790  
SetShareButtonMarker(const EventMarker & onShare)791  void TextOverlayComponent::SetShareButtonMarker(const EventMarker& onShare)
792  {
793      shareButtonMarker_ = onShare;
794  }
795  
SetSearchButtonMarker(const EventMarker & onSearch)796  void TextOverlayComponent::SetSearchButtonMarker(const EventMarker& onSearch)
797  {
798      searchButtonMarker_ = onSearch;
799  }
800  
SetPopOverlay(const CommonCallback & popOverlay)801  void TextOverlayComponent::SetPopOverlay(const CommonCallback& popOverlay)
802  {
803      popOverlay_ = popOverlay;
804  }
805  
SetContext(const WeakPtr<PipelineContext> & context)806  void TextOverlayComponent::SetContext(const WeakPtr<PipelineContext>& context)
807  {
808      context_ = context;
809  }
810  
GetMenu() const811  const RefPtr<SelectPopupComponent>& TextOverlayComponent::GetMenu() const
812  {
813      return menu_;
814  }
815  
816  } // namespace OHOS::Ace
817