• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022 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_MENU_MENU_WRAPPER_PATTERN_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_MENU_MENU_WRAPPER_PATTERN_H
18 
19 #include "base/memory/ace_type.h"
20 #include "base/memory/referenced.h"
21 #include "base/utils/string_utils.h"
22 #include "base/utils/utils.h"
23 #include "core/components/common/properties/color.h"
24 #include "core/components/common/properties/placement.h"
25 #include "core/components_ng/base/frame_node.h"
26 #include "core/components_ng/pattern/menu/menu_item/menu_item_pattern.h"
27 #include "core/components_ng/pattern/menu/menu_layout_algorithm.h"
28 #include "core/components_ng/pattern/menu/menu_pattern.h"
29 #include "core/components_ng/pattern/menu/wrapper/menu_wrapper_layout_algorithm.h"
30 #include "core/components_ng/pattern/menu/wrapper/menu_wrapper_paint_method.h"
31 #include "core/components_ng/pattern/menu/wrapper/menu_wrapper_paint_property.h"
32 #include "core/components_ng/pattern/overlay/popup_base_pattern.h"
33 #include "core/components_ng/pattern/pattern.h"
34 #include "core/components_v2/inspector/inspector_constants.h"
35 #include "core/pipeline_ng/ui_task_scheduler.h"
36 
37 namespace OHOS::Ace::NG {
38 
39 enum class MenuStatus {
40     INIT,              // Neither exists in the menuMap_ nor on the tree
41     ON_SHOW_ANIMATION, // Exists in the menuMap_ also exists on the tree
42     SHOW,              // Exists in the menuMap_ also exists on the tree
43     ON_HIDE_ANIMATION, // Exists in the menuMap_ also exists on the tree
44     HIDE               // Exists in the menuMap_ but not on the tree
45 };
46 
47 // has full screen size
48 // used for detecting clicks outside Menu area
49 class MenuWrapperPattern : public PopupBasePattern {
50     DECLARE_ACE_TYPE(MenuWrapperPattern, Pattern);
51 
52 public:
targetId_(Id)53     explicit MenuWrapperPattern(int32_t Id, const std::string& tag = "") : targetId_(Id), targetTag_(tag) {}
54     ~MenuWrapperPattern() override = default;
55 
IsAtomicNode()56     bool IsAtomicNode() const override
57     {
58         return false;
59     }
60 
GetFocusPattern()61     FocusPattern GetFocusPattern() const override
62     {
63         return { FocusType::SCOPE, true };
64     }
65 
CreateLayoutAlgorithm()66     RefPtr<LayoutAlgorithm> CreateLayoutAlgorithm() override
67     {
68         return MakeRefPtr<MenuWrapperLayoutAlgorithm>();
69     }
70 
CreatePaintProperty()71     RefPtr<PaintProperty> CreatePaintProperty() override
72     {
73         return MakeRefPtr<MenuWrapperPaintProperty>();
74     }
75 
CreateNodePaintMethod()76     RefPtr<NodePaintMethod> CreateNodePaintMethod() override
77     {
78         return AceType::MakeRefPtr<MenuWrapperPaintMethod>();
79     }
80 
81     void HandleMouseEvent(const MouseInfo& info, RefPtr<MenuItemPattern>& menuItem);
82 
GetTargetId()83     int32_t GetTargetId() const override
84     {
85         return targetId_;
86     }
87 
88     void HideMenu(const HideMenuType& reason = HideMenuType::NORMAL);
89 
IsHide()90     bool IsHide() const
91     {
92         return menuStatus_ == MenuStatus::ON_HIDE_ANIMATION || menuStatus_ == MenuStatus::HIDE;
93     }
94 
IsContextMenu()95     bool IsContextMenu() const
96     {
97         auto menu = GetMenu();
98         CHECK_NULL_RETURN(menu, false);
99         auto menuPattern = menu->GetPattern<MenuPattern>();
100         CHECK_NULL_RETURN(menuPattern, false);
101         return menuPattern->IsContextMenu();
102     }
103 
GetPreviewMode()104     MenuPreviewMode GetPreviewMode() const
105     {
106         auto menu = GetMenu();
107         CHECK_NULL_RETURN(menu, MenuPreviewMode::NONE);
108         auto menuPattern = menu->GetPattern<MenuPattern>();
109         CHECK_NULL_RETURN(menuPattern, MenuPreviewMode::NONE);
110         return menuPattern->GetPreviewMode();
111     }
112 
IsSelectMenu()113     bool IsSelectMenu() const
114     {
115         auto menu = GetMenu();
116         CHECK_NULL_RETURN(menu, false);
117         auto menuPattern = menu->GetPattern<MenuPattern>();
118         CHECK_NULL_RETURN(menuPattern, false);
119         return menuPattern->IsSelectMenu();
120     }
121 
122     void HideSubMenu();
123     void ShowSubMenuDisappearAnimation(const RefPtr<FrameNode>& host, const RefPtr<UINode>& subMenu);
124     void HideSubMenuByDepth(const RefPtr<FrameNode>& menuItem);
125     void HideStackExpandMenu(const RefPtr<UINode>& subMenu);
126     void GetExpandingMode(const RefPtr<UINode>& subMenu, SubMenuExpandingMode& expandingMode, bool& hasAnimation);
GetMenu()127     RefPtr<FrameNode> GetMenu() const
128     {
129         auto host = GetHost();
130         CHECK_NULL_RETURN(host, nullptr);
131         auto menu = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(0));
132         CHECK_NULL_RETURN(menu, nullptr);
133         return menu;
134     }
135 
GetHoverImageFlexNode()136     RefPtr<FrameNode> GetHoverImageFlexNode() const
137     {
138         auto host = GetHost();
139         CHECK_NULL_RETURN(host, nullptr);
140         auto node = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(1));
141         CHECK_NULL_RETURN(node, nullptr);
142         if (node->GetTag() != V2::FLEX_ETS_TAG) {
143             return nullptr;
144         }
145         return node;
146     }
147 
GetHoverImageStackNode()148     RefPtr<FrameNode> GetHoverImageStackNode() const
149     {
150         auto hoverImageFlexNode = GetHoverImageFlexNode();
151         CHECK_NULL_RETURN(hoverImageFlexNode, nullptr);
152         auto node = AceType::DynamicCast<FrameNode>(hoverImageFlexNode->GetChildAtIndex(0));
153         CHECK_NULL_RETURN(node, nullptr);
154         if (node->GetTag() != V2::STACK_ETS_TAG) {
155             return nullptr;
156         }
157         return node;
158     }
159 
GetHoverImagePreview()160     RefPtr<FrameNode> GetHoverImagePreview() const
161     {
162         auto hoverImageStackNode = GetHoverImageStackNode();
163         CHECK_NULL_RETURN(hoverImageStackNode, nullptr);
164         auto node = AceType::DynamicCast<FrameNode>(hoverImageStackNode->GetChildAtIndex(0));
165         CHECK_NULL_RETURN(node, nullptr);
166         if (node->GetTag() != V2::IMAGE_ETS_TAG) {
167             return nullptr;
168         }
169         return node;
170     }
171 
GetHoverImageCustomPreview()172     RefPtr<FrameNode> GetHoverImageCustomPreview() const
173     {
174         auto hoverImageStackNode = GetHoverImageStackNode();
175         CHECK_NULL_RETURN(hoverImageStackNode, nullptr);
176         auto node = AceType::DynamicCast<FrameNode>(hoverImageStackNode->GetChildAtIndex(1));
177         CHECK_NULL_RETURN(node, nullptr);
178         if (node->GetTag() != V2::MENU_PREVIEW_ETS_TAG) {
179             return nullptr;
180         }
181         return node;
182     }
183 
GetPreview()184     RefPtr<FrameNode> GetPreview() const
185     {
186         auto host = GetHost();
187         CHECK_NULL_RETURN(host, nullptr);
188         auto preview = AceType::DynamicCast<FrameNode>(host->GetChildAtIndex(1));
189         CHECK_NULL_RETURN(preview, nullptr);
190         if (preview->GetTag() == V2::FLEX_ETS_TAG) {
191             auto hoverImageCustomPreview = GetHoverImageCustomPreview();
192             CHECK_NULL_RETURN(hoverImageCustomPreview, preview);
193             return hoverImageCustomPreview;
194         }
195         return preview;
196     }
197 
198     // used to obtain the Badge node and delete it.
GetBadgeNode()199     RefPtr<FrameNode> GetBadgeNode() const
200     {
201         auto host = GetHost();
202         CHECK_NULL_RETURN(host, nullptr);
203         for (const auto& child : host->GetChildren()) {
204             auto node = DynamicCast<FrameNode>(child);
205             if (node && node->GetTag() == V2::TEXT_ETS_TAG) {
206                 return node;
207             }
208         }
209         return nullptr;
210     }
211 
212     OffsetT<Dimension> GetAnimationOffset();
213     void SetAniamtinOption(const AnimationOption& animationOption);
214 
SetMenuPlacementAfterLayout(const Placement & placement)215     void SetMenuPlacementAfterLayout(const Placement& placement)
216     {
217         menuPlacement_ = placement;
218     }
219 
SetFirstShow()220     void SetFirstShow()
221     {
222         isFirstShow_ = true;
223     }
224 
GetIsFirstShow()225     bool GetIsFirstShow() const
226     {
227         return isFirstShow_;
228     }
229 
SetIsShowHoverImage(bool isShow)230     void SetIsShowHoverImage(bool isShow)
231     {
232         isShowHoverImage_ = isShow;
233     }
234 
GetIsShowHoverImage()235     bool GetIsShowHoverImage() const
236     {
237         return isShowHoverImage_;
238     }
239 
SetHoverScaleInterruption(bool interruption)240     void SetHoverScaleInterruption(bool interruption)
241     {
242         hoverScaleInterruption_ = interruption;
243     }
244 
GetHoverScaleInterruption()245     bool GetHoverScaleInterruption() const
246     {
247         return hoverScaleInterruption_;
248     }
249 
SetIsStopHoverImageAnimation(bool isStop)250     void SetIsStopHoverImageAnimation(bool isStop)
251     {
252         isStopHoverImageAnimation_ = isStop;
253     }
254 
IsStopHoverImageAnimation()255     bool IsStopHoverImageAnimation() const
256     {
257         return isStopHoverImageAnimation_;
258     }
259 
SetIsShowHoverImagePreviewStartDrag(bool isStart)260     void SetIsShowHoverImagePreviewStartDrag(bool isStart)
261     {
262         isShowHoverImagePreviewStartDrag_ = isStart;
263     }
264 
GetIsShowHoverImagePreviewStartDrag()265     bool GetIsShowHoverImagePreviewStartDrag() const
266     {
267         return isShowHoverImagePreviewStartDrag_;
268     }
269 
SetOnMenuDisappear(bool isDisappear)270     void SetOnMenuDisappear(bool isDisappear)
271     {
272         onMenuDisappear_ = isDisappear;
273     }
274 
GetOnMenuDisappear()275     bool GetOnMenuDisappear() const
276     {
277         return onMenuDisappear_;
278     }
279 
SetOnPreviewDisappear(bool isDisappear)280     void SetOnPreviewDisappear(bool isDisappear)
281     {
282         onPreviewDisappear_ = isDisappear;
283     }
284 
GetOnPreviewDisappear()285     bool GetOnPreviewDisappear() const
286     {
287         return onPreviewDisappear_;
288     }
289 
290     void RegisterMenuCallback(const RefPtr<FrameNode>& menuWrapperNode, const MenuParam& menuParam);
291 
RegisterMenuAppearCallback(const std::function<void ()> & onAppear)292     void RegisterMenuAppearCallback(const std::function<void()>& onAppear)
293     {
294         onAppearCallback_ = onAppear;
295     }
296 
RegisterMenuDisappearCallback(const std::function<void ()> & onDisappear)297     void RegisterMenuDisappearCallback(const std::function<void()>& onDisappear)
298     {
299         onDisappearCallback_ = onDisappear;
300     }
301 
RegisterMenuAboutToAppearCallback(const std::function<void ()> & aboutToAppear)302     void RegisterMenuAboutToAppearCallback(const std::function<void()>& aboutToAppear)
303     {
304         aboutToAppearCallback_ = aboutToAppear;
305     }
306 
RegisterMenuAboutToDisappearCallback(const std::function<void ()> & aboutToDisappear)307     void RegisterMenuAboutToDisappearCallback(const std::function<void()>& aboutToDisappear)
308     {
309         aboutToDisappearCallback_ = aboutToDisappear;
310     }
311 
RegisterMenuOnWillAppearCallback(const std::function<void ()> & onWillAppear)312     void RegisterMenuOnWillAppearCallback(const std::function<void()>& onWillAppear)
313     {
314         onWillAppearCallback_ = onWillAppear;
315     }
316 
RegisterMenuOnDidAppearCallback(const std::function<void ()> & onDidAppear)317     void RegisterMenuOnDidAppearCallback(const std::function<void()>& onDidAppear)
318     {
319         onDidAppearCallback_ = onDidAppear;
320     }
321 
RegisterMenuOnWillDisappearCallback(const std::function<void ()> & onWillDisappear)322     void RegisterMenuOnWillDisappearCallback(const std::function<void()>& onWillDisappear)
323     {
324         onWillDisappearCallback_ = onWillDisappear;
325     }
326 
RegisterMenuOnDidDisappearCallback(const std::function<void ()> & onDidDisappear)327     void RegisterMenuOnDidDisappearCallback(const std::function<void()>& onDidDisappear)
328     {
329         onDidDisappearCallback_ = onDidDisappear;
330     }
331 
RegisterMenuStateChangeCallback(const std::function<void (const std::string &)> & callback)332     void RegisterMenuStateChangeCallback(const std::function<void(const std::string&)>& callback)
333     {
334         onStateChangeCallback_ = callback;
335     }
336 
CallMenuAppearCallback()337     void CallMenuAppearCallback()
338     {
339         if (onAppearCallback_) {
340             onAppearCallback_();
341         }
342     }
343 
CallMenuDisappearCallback()344     void CallMenuDisappearCallback()
345     {
346         if (onDisappearCallback_) {
347             onDisappearCallback_();
348         }
349     }
350 
CallMenuAboutToAppearCallback()351     void CallMenuAboutToAppearCallback()
352     {
353         if (aboutToAppearCallback_) {
354             aboutToAppearCallback_();
355         }
356     }
357 
CallMenuAboutToDisappearCallback()358     void CallMenuAboutToDisappearCallback()
359     {
360         if (aboutToDisappearCallback_) {
361             aboutToDisappearCallback_();
362         }
363     }
364 
CallMenuOnWillAppearCallback()365    void CallMenuOnWillAppearCallback()
366    {
367        if (onWillAppearCallback_) {
368            onWillAppearCallback_();
369        }
370    }
371 
CallMenuOnDidAppearCallback()372    void CallMenuOnDidAppearCallback()
373    {
374        if (onDidAppearCallback_) {
375            onDidAppearCallback_();
376        }
377    }
378 
CallMenuOnWillDisappearCallback()379    void CallMenuOnWillDisappearCallback()
380    {
381        if (onWillDisappearCallback_) {
382            onWillDisappearCallback_();
383        }
384    }
385 
CallMenuOnDidDisappearCallback()386    void CallMenuOnDidDisappearCallback()
387    {
388        if (onDidDisappearCallback_) {
389            onDidDisappearCallback_();
390        }
391    }
392 
CallMenuStateChangeCallback(const std::string & value)393     void CallMenuStateChangeCallback(const std::string& value)
394     {
395         if (onStateChangeCallback_) {
396             onStateChangeCallback_(value);
397         }
398     }
399 
GetMenuDisappearCallback()400     const std::function<void()>& GetMenuDisappearCallback()
401     {
402         return onDisappearCallback_;
403     }
404 
IsShow()405     bool IsShow() const
406     {
407         return menuStatus_ == MenuStatus::ON_SHOW_ANIMATION || menuStatus_ == MenuStatus::SHOW;
408     }
409 
SetMenuStatus(MenuStatus value)410     void SetMenuStatus(MenuStatus value)
411     {
412         menuStatus_ = value;
413         RequestPathRender();
414     }
415 
GetMenuStatus()416     MenuStatus GetMenuStatus() const
417     {
418         return menuStatus_;
419     }
420 
HasTransitionEffect()421     bool HasTransitionEffect() const
422     {
423         return hasTransitionEffect_;
424     }
425 
SetHasTransitionEffect(bool hasTransitionEffect)426     void SetHasTransitionEffect(bool hasTransitionEffect)
427     {
428         hasTransitionEffect_ = hasTransitionEffect;
429     }
430 
431     void SetMenuTransitionEffect(const RefPtr<FrameNode>& menuWrapperNode, const MenuParam& menuParam);
432 
HasPreviewTransitionEffect()433     bool HasPreviewTransitionEffect() const
434     {
435         return hasPreviewTransitionEffect_;
436     }
437 
SetHasPreviewTransitionEffect(bool hasPreviewTransitionEffect)438     void SetHasPreviewTransitionEffect(bool hasPreviewTransitionEffect)
439     {
440         hasPreviewTransitionEffect_ = hasPreviewTransitionEffect;
441     }
442 
HasFoldModeChangedTransition()443     bool HasFoldModeChangedTransition() const
444     {
445         return hasFoldModeChangeTransition_;
446     }
447 
SetHasFoldModeChangedTransition(bool hasTransition)448     void SetHasFoldModeChangedTransition(bool hasTransition)
449     {
450         hasFoldModeChangeTransition_ = hasTransition;
451     }
452 
SetFilterColumnNode(const RefPtr<FrameNode> & columnNode)453     void SetFilterColumnNode(const RefPtr<FrameNode>& columnNode)
454     {
455         filterColumnNode_ = columnNode;
456     }
457 
GetFilterColumnNode()458     RefPtr<FrameNode> GetFilterColumnNode()
459     {
460         return filterColumnNode_;
461     }
462 
SetIsFilterInSubwindow(bool inSubwindow)463     void SetIsFilterInSubwindow(bool inSubwindow)
464     {
465         isFilterInSubWindow_ = inSubwindow;
466     }
467 
GetIsFilterInSubwindow()468     bool GetIsFilterInSubwindow() const
469     {
470         return isFilterInSubWindow_;
471     }
472 
473     void DumpInfo() override;
474     void DumpInfo(std::unique_ptr<JsonValue>& json) override;
DumpSimplifyInfo(std::shared_ptr<JsonValue> & json)475     void DumpSimplifyInfo(std::shared_ptr<JsonValue>& json) override {}
476 
GetDumpInfo()477     MenuDumpInfo GetDumpInfo() const
478     {
479         return dumpInfo_;
480     }
481 
SetDumpInfo(const MenuDumpInfo & dumpInfo)482     void SetDumpInfo(const MenuDumpInfo& dumpInfo)
483     {
484         dumpInfo_.menuPreviewMode = dumpInfo.menuPreviewMode;
485         dumpInfo_.menuType = dumpInfo.menuType;
486         dumpInfo_.enableArrow = dumpInfo.enableArrow;
487         dumpInfo_.offset = dumpInfo.offset;
488         dumpInfo_.targetNode = dumpInfo.targetNode;
489         dumpInfo_.targetOffset = dumpInfo.targetOffset;
490         dumpInfo_.targetSize = dumpInfo.targetSize;
491         dumpInfo_.menuWindowRect = dumpInfo.menuWindowRect;
492         dumpInfo_.wrapperRect = dumpInfo.wrapperRect;
493         dumpInfo_.previewBeginScale = dumpInfo.previewBeginScale;
494         dumpInfo_.previewEndScale = dumpInfo.previewEndScale;
495         dumpInfo_.top = dumpInfo.top;
496         dumpInfo_.bottom = dumpInfo.bottom;
497         dumpInfo_.left = dumpInfo.left;
498         dumpInfo_.right = dumpInfo.right;
499         dumpInfo_.globalLocation = dumpInfo.globalLocation;
500         dumpInfo_.originPlacement = dumpInfo.originPlacement;
501         dumpInfo_.defaultPlacement = dumpInfo.defaultPlacement;
502         dumpInfo_.finalPosition = dumpInfo.finalPosition;
503         dumpInfo_.finalPlacement = dumpInfo.finalPlacement;
504         dumpInfo_.anchorPosition = dumpInfo.anchorPosition;
505     }
506 
GetHasCustomRadius()507     bool GetHasCustomRadius() const
508     {
509         return hasCustomRadius_;
510     }
511 
SetHasCustomRadius(bool hasCustomRadius)512     void SetHasCustomRadius(bool hasCustomRadius)
513     {
514         hasCustomRadius_ = hasCustomRadius;
515     }
516 
GetLastTouchItem()517     RefPtr<FrameNode> GetLastTouchItem()
518     {
519         return lastTouchItem_;
520     }
521 
SetLastTouchItem(const RefPtr<FrameNode> & lastTouchItem)522     void SetLastTouchItem(const RefPtr<FrameNode>& lastTouchItem)
523     {
524         lastTouchItem_ = lastTouchItem;
525     }
526 
IncreaseEmbeddedSubMenuCount()527     int IncreaseEmbeddedSubMenuCount()
528     {
529         ++embeddedSubMenuExpandTotalCount_;
530         return ++embeddedSubMenuCount_;
531     }
532 
DecreaseEmbeddedSubMenuCount()533     int DecreaseEmbeddedSubMenuCount()
534     {
535         return --embeddedSubMenuCount_;
536     }
537 
GetEmbeddedSubMenuExpandTotalCount()538     int GetEmbeddedSubMenuExpandTotalCount() const
539     {
540         return embeddedSubMenuExpandTotalCount_;
541     }
542 
SetForceUpdateEmbeddedMenu(bool forceUpdate)543     void SetForceUpdateEmbeddedMenu(bool forceUpdate)
544     {
545         forceUpdateEmbeddedMenu_ = forceUpdate;
546     }
547 
GetForceUpdateEmbeddedMenu()548     bool GetForceUpdateEmbeddedMenu() const
549     {
550         return forceUpdateEmbeddedMenu_;
551     }
552 
553     RefPtr<FrameNode> GetMenuChild(const RefPtr<UINode>& node);
554     RefPtr<FrameNode> GetShowedSubMenu();
555     bool IsSelectOverlayCustomMenu(const RefPtr<FrameNode>& menu) const;
556     bool IsSelectOverlayRightClickMenu(const RefPtr<FrameNode>& menu) const;
557     bool HasEmbeddedSubMenu();
558     void UpdateMenuAnimation(const RefPtr<FrameNode>& host);
559     bool HasStackSubMenu();
560     void ClearAllSubMenu();
561     int embeddedSubMenuCount_ = 0;
562 
SetAnimationClipRate(float rate)563     void SetAnimationClipRate(float rate)
564     {
565         animationInfo_.clipRate = rate;
566     }
567 
SetAnimationBorderRadius(double rate,const BorderRadiusProperty & radius)568     void SetAnimationBorderRadius(double rate, const BorderRadiusProperty& radius)
569     {
570         animationInfo_.borderRadius.radiusTopLeft = Dimension(radius.radiusTopLeft->ConvertToPx() * rate);
571         animationInfo_.borderRadius.radiusTopRight = Dimension(radius.radiusTopRight->ConvertToPx() * rate);
572         animationInfo_.borderRadius.radiusBottomLeft = Dimension(radius.radiusBottomLeft->ConvertToPx() * rate);
573         animationInfo_.borderRadius.radiusBottomRight = Dimension(radius.radiusBottomRight->ConvertToPx() * rate);
574     }
575 
GetPreviewMenuAnimationInfo()576     PreviewMenuAnimationInfo GetPreviewMenuAnimationInfo()
577     {
578         return animationInfo_;
579     }
580 
SetMenuParam(const MenuParam & param)581     void SetMenuParam(const MenuParam& param)
582     {
583         menuParam_ = param;
584     }
585 
GetMenuParam()586     const MenuParam& GetMenuParam() const
587     {
588         return menuParam_;
589     }
590 
SetIsShowFromUser(bool isShow)591     void SetIsShowFromUser(bool isShow)
592     {
593         isShowFromUser_ = isShow;
594     }
595 
GetIsShowFromUser()596     bool GetIsShowFromUser() const
597     {
598         return isShowFromUser_;
599     }
600 
601     void RequestPathRender();
602 
SetChildLayoutConstraint(LayoutConstraintF constraint)603     void SetChildLayoutConstraint(LayoutConstraintF constraint)
604     {
605         childLayoutConstraint_ = constraint;
606     }
607 
GetChildLayoutConstraint()608     LayoutConstraintF GetChildLayoutConstraint() const
609     {
610         return childLayoutConstraint_;
611     }
612 
SetPreviewDisappearStartOffset(OffsetF offset)613     void SetPreviewDisappearStartOffset(OffsetF offset)
614     {
615         previewDisappearStartOffset_ = offset;
616     }
617 
618     bool IsMenuPreviewNode(const RefPtr<FrameNode>& frameNode) const;
619 
SetIsOpenMenu(bool isOpenMenu)620     void SetIsOpenMenu(bool isOpenMenu)
621     {
622         isOpenMenu_ = isOpenMenu;
623     }
624 
GetIsOpenMenu()625     bool GetIsOpenMenu() const
626     {
627         return isOpenMenu_;
628     }
629 
SetHoverMode(std::optional<bool> enableFold)630     void SetHoverMode(std::optional<bool> enableFold)
631     {
632         enableFold_ = enableFold;
633     }
634 
GetHoverMode()635     std::optional<bool> GetHoverMode() const
636     {
637         return enableFold_;
638     }
639 
HasHoverMode()640     bool HasHoverMode() const
641     {
642         return enableFold_.has_value();
643     }
644 
GetIsSelectOverlaySubWindowWrapper()645     bool GetIsSelectOverlaySubWindowWrapper() const
646     {
647         return isSelectOverlaySubWindowWrapper_;
648     }
649 
SetIsSelectOverlaySubWindowWrapper(bool isSelectOverlaySubWindowWrapper)650     void SetIsSelectOverlaySubWindowWrapper(bool isSelectOverlaySubWindowWrapper)
651     {
652         isSelectOverlaySubWindowWrapper_ = isSelectOverlaySubWindowWrapper;
653     }
654 
GetHasCustomOutlineWidth()655     bool GetHasCustomOutlineWidth() const
656     {
657         return hasCustomOutlineWidth_;
658     }
659 
SetHasCustomOutlineWidth(bool hasCustomOutlineWidth)660     void SetHasCustomOutlineWidth(bool hasCustomOutlineWidth)
661     {
662         hasCustomOutlineWidth_ = hasCustomOutlineWidth;
663     }
664 
GetHasCustomOutlineColor()665     bool GetHasCustomOutlineColor() const
666     {
667         return hasCustomOutlineColor_;
668     }
669 
SetHasCustomOutlineColor(bool hasCustomOutlineColor)670     void SetHasCustomOutlineColor(bool hasCustomOutlineColor)
671     {
672         hasCustomOutlineColor_ = hasCustomOutlineColor;
673     }
674 
675     bool GetMenuMaskEnable() const;
676     Color GetMenuMaskColor() const;
677     BlurStyle GetMenuMaskBlurStyle() const;
678     void UpdateFilterMaskType();
679     void CheckAndShowAnimation();
680 
681 protected:
682     void OnTouchEvent(const TouchEventInfo& info);
683 
684 private:
AvoidKeyboard()685     bool AvoidKeyboard() const override
686     {
687         return false;
688     }
AvoidBottom()689     bool AvoidBottom() const override
690     {
691         return false;
692     }
693     void OnModifyDone() override;
694     void InitFocusEvent();
695     void OnAttachToFrameNode() override;
696     void OnDetachFromMainTree() override;
697     void RegisterOnTouch();
698     bool OnDirtyLayoutWrapperSwap(const RefPtr<LayoutWrapper>& dirty, const DirtySwapConfig& config) override;
699     // mark self and all children no-draggable
700     void MarkWholeSubTreeNoDraggable(const RefPtr<FrameNode>& frameNode);
701     void MarkAllMenuNoDraggable();
702     void SetHotAreas(const RefPtr<LayoutWrapper>& layoutWrapper);
703     void StartShowAnimation();
704     void HandleInteraction(const TouchEventInfo& info);
705     void ChangeTouchItem(const TouchEventInfo& info, TouchType touchType);
706     void ChangeCurMenuItemBgColor();
707     void ClearLastMenuItem();
708     bool GetInnerMenu(RefPtr<UINode>& innerMenuNode, const PointF& position);
709     RefPtr<FrameNode> FindTouchedMenuItem(const RefPtr<UINode>& menuNode, const PointF& position);
710     bool IsNeedSetHotAreas(const RefPtr<LayoutWrapper>& layoutWrapper);
711 
712     void HideMenu(const RefPtr<FrameNode>& menu, const HideMenuType& reason = HideMenuType::NORMAL);
713     void HideMenu(const RefPtr<MenuPattern>& menuPattern, const RefPtr<FrameNode>& menu, const PointF& position,
714         const HideMenuType& reason = HideMenuType::NORMAL);
715     void SetExitAnimation(const RefPtr<FrameNode>& host);
716     void SendToAccessibility(const RefPtr<UINode>& subMenu, bool isShow);
717     bool CheckPointInMenuZone(const RefPtr<FrameNode>& node, const PointF& point);
718     bool HasSideSubMenu();
719     bool IsTouchWithinParentMenuItemZone(std::list<RefPtr<UINode>>::reverse_iterator& child,
720         const std::list<RefPtr<UINode>>& children, const PointF& position);
721     RefPtr<FrameNode> GetParentMenu(const RefPtr<UINode>& subMenu);
722     void MenuFocusViewShow(const RefPtr<FrameNode>& menuNode);
723     void AddTargetWindowHotArea(std::vector<Rect>& rects);
724     void AddWrapperChildHotArea(std::vector<Rect>& rects, const RefPtr<LayoutWrapper>& layoutWrapper);
725     void AddFilterHotArea(std::vector<Rect>& rects);
726     std::function<void()> onAppearCallback_ = nullptr;
727     std::function<void()> onDisappearCallback_ = nullptr;
728     std::function<void()> aboutToAppearCallback_ = nullptr;
729     std::function<void()> aboutToDisappearCallback_ = nullptr;
730     std::function<void()> onWillAppearCallback_ = nullptr;
731     std::function<void()> onDidAppearCallback_ = nullptr;
732     std::function<void()> onWillDisappearCallback_ = nullptr;
733     std::function<void()> onDidDisappearCallback_ = nullptr;
734     std::function<void(const std::string&)> onStateChangeCallback_ = nullptr;
735     RefPtr<TouchEventImpl> onTouch_;
736     RefPtr<FrameNode> lastTouchItem_ = nullptr;
737     RefPtr<FrameNode> currentTouchItem_ = nullptr;
738     // menuId in OverlayManager's map
739     int32_t targetId_ = -1;
740     std::string targetTag_ = "";
741     int embeddedSubMenuExpandTotalCount_ = 0;
742     bool forceUpdateEmbeddedMenu_ = false;
743     LayoutConstraintF childLayoutConstraint_;
744 
745     AnimationOption animationOption_;
746     Placement menuPlacement_ = Placement::NONE;
747     bool isFirstShow_ = true;
748     bool isShowInSubWindow_ = true;
749     bool isShowHoverImage_ = false;
750     bool hoverScaleInterruption_ = false;
751     bool isStopHoverImageAnimation_ = false;
752     bool isShowHoverImagePreviewStartDrag_ = false;
753     bool onMenuDisappear_ = false;
754     bool onPreviewDisappear_ = false;
755     MenuStatus menuStatus_ = MenuStatus::INIT;
756     bool hasTransitionEffect_ = false;
757     bool hasPreviewTransitionEffect_ = false;
758     bool hasFoldModeChangeTransition_ = false;
759     OffsetF previewDisappearStartOffset_;
760     RefPtr<FrameNode> filterColumnNode_;
761     bool isFilterInSubWindow_ = false;
762     MenuDumpInfo dumpInfo_;
763     bool hasCustomRadius_ = false;
764     PreviewMenuAnimationInfo animationInfo_;
765     MenuParam menuParam_;
766     bool isShowFromUser_ = false;
767     int32_t fingerId_ = -1;
768     bool isOpenMenu_ = false;
769     std::optional<bool> enableFold_;
770     // Identify whether the menuWrapper is used by selectOverlay in the subwindow.
771     bool isSelectOverlaySubWindowWrapper_ = false;
772     bool hasCustomOutlineWidth_ = false;
773     bool hasCustomOutlineColor_ = false;
774     bool isClearLastMenuItem_ = true;
775     ACE_DISALLOW_COPY_AND_MOVE(MenuWrapperPattern);
776 };
777 } // namespace OHOS::Ace::NG
778 
779 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_PATTERNS_MENU_MENU_WRAPPER_PATTERN_H
780