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