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_EVENT_EVENT_HUB_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
18 
19 #include <list>
20 #include <utility>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/memory/referenced.h"
24 #include "base/utils/noncopyable.h"
25 #include "core/components_ng/event/focus_hub.h"
26 #include "core/components_ng/event/gesture_event_hub.h"
27 #include "core/components_ng/event/input_event_hub.h"
28 #include "core/components_ng/event/state_style_manager.h"
29 
30 namespace OHOS::Ace::NG {
31 
32 class FrameNode;
33 class InspectorFilter;
34 
35 using OnAreaChangedFunc =
36     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>;
37 using OnPreDragFunc = std::function<void(const PreDragStatus)>;
38 
39 using OnSizeChangedFunc = std::function<void(const RectF& oldRect, const RectF& rect)>;
40 
41 struct KeyboardShortcut {
42     std::string value;
43     uint8_t keys = 0;
44     std::function<void()> onKeyboardShortcutAction = nullptr;
IsEqualTriggerKeyboardShortcut45     bool IsEqualTrigger(const KeyboardShortcut& other)
46     {
47         return (keys == other.keys) && (value == other.value);
48     }
49 };
50 
51 enum class DragFuncType {
52     DRAG_ENTER,
53     DRAG_LEAVE,
54     DRAG_MOVE,
55     DRAG_DROP,
56     DRAG_END,
57 };
58 
59 enum class VisibleAreaChangeTriggerReason : int32_t {
60     IDLE = 0,
61     VISIBLE_AREA_CHANGE = 1,
62     DETACH_FROM_MAINTREE = 2,
63     BACKGROUND = 3,
64     SELF_INVISIBLE = 4,
65     FRAMENODE_DESTROY = 5,
66     IS_NOT_ON_MAINTREE = 6,
67     ANCESTOR_INVISIBLE = 7,
68 };
69 
70 // The event hub is mainly used to handle common collections of events, such as gesture events, mouse events, etc.
71 class ACE_FORCE_EXPORT EventHub : public virtual AceType {
72     DECLARE_ACE_TYPE(EventHub, AceType)
73 
74 public:
75     EventHub() = default;
~EventHub()76     ~EventHub() override
77     {
78         keyboardShortcut_.clear();
79     };
80 
GetOrCreateGestureEventHub()81     const RefPtr<GestureEventHub>& GetOrCreateGestureEventHub()
82     {
83         if (!gestureEventHub_) {
84             gestureEventHub_ = CreateGestureEventHub();
85         }
86         return gestureEventHub_;
87     }
88 
CreateGestureEventHub()89     virtual RefPtr<GestureEventHub> CreateGestureEventHub()
90     {
91         return MakeRefPtr<GestureEventHub>(WeakClaim(this));
92     }
93 
GetGestureEventHub()94     const RefPtr<GestureEventHub>& GetGestureEventHub() const
95     {
96         return gestureEventHub_;
97     }
98 
SetGestureEventHub(const RefPtr<GestureEventHub> & gestureEventHub)99     void SetGestureEventHub(const RefPtr<GestureEventHub>& gestureEventHub)
100     {
101         gestureEventHub_ = gestureEventHub;
102     }
103 
GetOrCreateInputEventHub()104     const RefPtr<InputEventHub>& GetOrCreateInputEventHub()
105     {
106         if (!inputEventHub_) {
107             inputEventHub_ = MakeRefPtr<InputEventHub>(WeakClaim(this));
108         }
109         return inputEventHub_;
110     }
111 
GetInputEventHub()112     const RefPtr<InputEventHub>& GetInputEventHub() const
113     {
114         return inputEventHub_;
115     }
116 
117     const RefPtr<FocusHub>& GetOrCreateFocusHub(FocusType type = FocusType::DISABLE, bool focusable = false,
118         FocusStyleType focusStyleType = FocusStyleType::NONE,
119         const std::unique_ptr<FocusPaintParam>& paintParamsPtr = nullptr)
120     {
121         if (!focusHub_) {
122             focusHub_ = MakeRefPtr<FocusHub>(WeakClaim(this), type, focusable);
123             focusHub_->SetFocusStyleType(focusStyleType);
124             if (paintParamsPtr) {
125                 focusHub_->SetFocusPaintParamsPtr(paintParamsPtr);
126             }
127         }
128         return focusHub_;
129     }
130 
GetOrCreateFocusHub(const FocusPattern & focusPattern)131     const RefPtr<FocusHub>& GetOrCreateFocusHub(const FocusPattern& focusPattern)
132     {
133         if (!focusHub_) {
134             focusHub_ = MakeRefPtr<FocusHub>(WeakClaim(this), focusPattern);
135         }
136         return focusHub_;
137     }
138 
GetFocusHub()139     const RefPtr<FocusHub>& GetFocusHub() const
140     {
141         return focusHub_;
142     }
143 
144     void AttachHost(const WeakPtr<FrameNode>& host);
145     void OnAttachContext(PipelineContext *context);
146     void OnDetachContext(PipelineContext *context);
147 
148     RefPtr<FrameNode> GetFrameNode() const;
149 
150     GetEventTargetImpl CreateGetEventTargetImpl() const;
151 
OnContextAttached()152     void OnContextAttached()
153     {
154         if (gestureEventHub_) {
155             gestureEventHub_->OnContextAttached();
156         }
157     }
158 
ClearUserOnAppear()159     void ClearUserOnAppear()
160     {
161         if (onAppear_) {
162             onAppear_ = nullptr;
163         }
164     }
165 
SetOnAppear(std::function<void ()> && onAppear)166     void SetOnAppear(std::function<void()>&& onAppear)
167     {
168         onAppear_ = std::move(onAppear);
169     }
170 
171     void SetJSFrameNodeOnAppear(std::function<void()>&& onAppear);
172 
173     void ClearJSFrameNodeOnAppear();
174 
175     virtual void FireOnAppear();
176 
ClearUserOnDisAppear()177     void ClearUserOnDisAppear()
178     {
179         if (onDisappear_) {
180             onDisappear_ = nullptr;
181         }
182     }
183 
SetOnDisappear(std::function<void ()> && onDisappear)184     void SetOnDisappear(std::function<void()>&& onDisappear)
185     {
186         onDisappear_ = std::move(onDisappear);
187     }
188 
189     void SetJSFrameNodeOnDisappear(std::function<void()>&& onDisappear);
190 
191     void ClearJSFrameNodeOnDisappear();
192 
193     virtual void FireOnDisappear();
194 
ClearUserOnAreaChanged()195     void ClearUserOnAreaChanged()
196     {
197         if (onAreaChanged_) {
198             onAreaChanged_ = nullptr;
199         }
200     }
201 
SetOnAreaChanged(OnAreaChangedFunc && onAreaChanged)202     void SetOnAreaChanged(OnAreaChangedFunc&& onAreaChanged)
203     {
204         onAreaChanged_ = std::move(onAreaChanged);
205     }
206 
FireOnAreaChanged(const RectF & oldRect,const OffsetF & oldOrigin,const RectF & rect,const OffsetF & origin)207     void FireOnAreaChanged(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)
208     {
209         if (onAreaChanged_) {
210             // callback may be overwritten in its invoke so we copy it first
211             auto onAreaChanged = onAreaChanged_;
212             onAreaChanged(oldRect, oldOrigin, rect, origin);
213         }
214     }
215 
FireInnerOnAreaChanged(const RectF & oldRect,const OffsetF & oldOrigin,const RectF & rect,const OffsetF & origin)216     void FireInnerOnAreaChanged(
217         const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)
218     {
219         for (auto& innerCallbackInfo : onAreaChangedInnerCallbacks_) {
220             if (innerCallbackInfo.second) {
221                 auto innerOnAreaCallback = innerCallbackInfo.second;
222                 innerOnAreaCallback(oldRect, oldOrigin, rect, origin);
223             }
224         }
225     }
226 
HasOnAreaChanged()227     bool HasOnAreaChanged() const
228     {
229         return static_cast<bool>(onAreaChanged_);
230     }
231 
HasInnerOnAreaChanged()232     bool HasInnerOnAreaChanged() const
233     {
234         return !onAreaChangedInnerCallbacks_.empty();
235     }
236 
237     void SetOnSizeChanged(OnSizeChangedFunc&& onSizeChanged);
238     void FireOnSizeChanged(const RectF& oldRect, const RectF& rect);
239     bool HasOnSizeChanged() const;
240 
241     void AddInnerOnSizeChanged(int32_t id, OnSizeChangedFunc&& onSizeChanged);
242     void FireInnerOnSizeChanged(const RectF& oldRect, const RectF& rect);
243     bool HasInnerOnSizeChanged() const;
244     void ClearInnerOnSizeChanged();
245 
246     void SetJSFrameNodeOnSizeChangeCallback(OnSizeChangedFunc&& onSizeChanged);
247     void FireJSFrameNodeOnSizeChanged(const RectF& oldRect, const RectF& rect);
248     void ClearJSFrameNodeOnSizeChange();
249     using OnDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
250     using OnNewDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)>;
251     using OnDragStartFunc = std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
252 
SetOnPreDrag(OnPreDragFunc && onPreDragFunc)253     void SetOnPreDrag(OnPreDragFunc&& onPreDragFunc)
254     {
255         onPreDragFunc_ = std::move(onPreDragFunc);
256     }
257 
GetOnPreDrag()258     const OnPreDragFunc& GetOnPreDrag() const
259     {
260         return onPreDragFunc_;
261     }
262 
SetOnDragStart(OnDragStartFunc && onDragStart)263     void SetOnDragStart(OnDragStartFunc&& onDragStart)
264     {
265         onDragStart_ = std::move(onDragStart);
266     }
267 
GetOnDragStart()268     const OnDragStartFunc& GetOnDragStart() const
269     {
270         return onDragStart_;
271     }
272 
HasOnDragStart()273     bool HasOnDragStart() const
274     {
275         return static_cast<bool>(onDragStart_) || static_cast<bool>(defaultOnDragStart_);
276     }
277 
SetOnDragEnter(OnDragFunc && onDragEnter)278     void SetOnDragEnter(OnDragFunc&& onDragEnter)
279     {
280         onDragEnter_ = std::move(onDragEnter);
281     }
282 
283     void FireOnDragEnter(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
284 
SetOnDragLeave(OnDragFunc && onDragLeave)285     void SetOnDragLeave(OnDragFunc&& onDragLeave)
286     {
287         onDragLeave_ = std::move(onDragLeave);
288     }
289 
290     void FireOnDragLeave(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
291 
SetOnDragMove(OnDragFunc && onDragMove)292     void SetOnDragMove(OnDragFunc&& onDragMove)
293     {
294         onDragMove_ = std::move(onDragMove);
295     }
296 
297     void FireOnDragMove(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
298 
HasOnDragMove()299     bool HasOnDragMove() const
300     {
301         return static_cast<bool>(onDragMove_);
302     }
303 
SetOnDrop(OnDragFunc && onDrop)304     void SetOnDrop(OnDragFunc&& onDrop)
305     {
306         onDrop_ = std::move(onDrop);
307     }
308 
SetOnDragEnd(OnNewDragFunc && onDragEnd)309     void SetOnDragEnd(OnNewDragFunc&& onDragEnd)
310     {
311         onDragEnd_ = std::move(onDragEnd);
312     }
313 
GetOnDragEnd()314     const OnNewDragFunc& GetOnDragEnd() const
315     {
316         return onDragEnd_;
317     }
318 
HasOnDragEnter()319     bool HasOnDragEnter() const
320     {
321         return static_cast<bool>(onDragEnter_);
322     }
323 
HasOnDragLeave()324     bool HasOnDragLeave() const
325     {
326         return static_cast<bool>(onDragLeave_);
327     }
328 
HasOnDragEnd()329     bool HasOnDragEnd() const
330     {
331         return static_cast<bool>(onDragEnd_);
332     }
333 
HasOnItemDragMove()334     virtual bool HasOnItemDragMove()
335     {
336         return false;
337     }
338 
HasOnItemDrop()339     virtual bool HasOnItemDrop()
340     {
341         return false;
342     }
343 
344     void FireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
345 
HasOnDrop()346     bool HasOnDrop() const
347     {
348         return onDrop_ != nullptr;
349     }
350 
HasCustomerOnDragEnter()351     bool HasCustomerOnDragEnter() const
352     {
353         return customerOnDragEnter_ != nullptr;
354     }
355 
HasCustomerOnDragLeave()356     bool HasCustomerOnDragLeave() const
357     {
358         return customerOnDragLeave_ != nullptr;
359     }
360 
HasCustomerOnDragMove()361     bool HasCustomerOnDragMove() const
362     {
363         return customerOnDragMove_ != nullptr;
364     }
365 
HasCustomerOnDragEnd()366     bool HasCustomerOnDragEnd() const
367     {
368         return customerOnDragEnd_ != nullptr;
369     }
370 
HasCustomerOnDrop()371     bool HasCustomerOnDrop() const
372     {
373         return customerOnDrop_ != nullptr;
374     }
375 
GetDragExtraParams(const std::string & extraInfo,const Point & point,DragEventType isStart)376     virtual std::string GetDragExtraParams(const std::string& extraInfo, const Point& point, DragEventType isStart)
377     {
378         auto json = JsonUtil::Create(true);
379         if (!extraInfo.empty()) {
380             json->Put("extraInfo", extraInfo.c_str());
381         }
382         return json->ToString();
383     }
384 
IsEnabled()385     bool IsEnabled() const
386     {
387         return enabled_;
388     }
389 
IsDeveloperEnabled()390     bool IsDeveloperEnabled() const
391     {
392         return developerEnabled_;
393     }
394 
395     void SetEnabled(bool enabled);
396 
SetEnabledInternal(bool enabled)397     void SetEnabledInternal(bool enabled)
398     {
399         enabled_ = enabled;
400     }
401 
402     // restore enabled value to what developer sets
RestoreEnabled()403     void RestoreEnabled()
404     {
405         enabled_ = developerEnabled_;
406     }
407 
408     // get XTS inspector value
ToJsonValue(std::unique_ptr<JsonValue> & json,const InspectorFilter & filter)409     virtual void ToJsonValue(std::unique_ptr<JsonValue>& json, const InspectorFilter& filter) const {}
410 
FromJson(const std::unique_ptr<JsonValue> & json)411     virtual void FromJson(const std::unique_ptr<JsonValue>& json) {}
412 
413     void MarkModifyDone();
414 
415     void SetCurrentUIState(UIState state, bool flag);
416 
UpdateCurrentUIState(UIState state)417     void UpdateCurrentUIState(UIState state)
418     {
419         if (stateStyleMgr_) {
420             stateStyleMgr_->UpdateCurrentUIState(state);
421         }
422     }
423 
ResetCurrentUIState(UIState state)424     void ResetCurrentUIState(UIState state)
425     {
426         if (stateStyleMgr_) {
427             stateStyleMgr_->ResetCurrentUIState(state);
428         }
429     }
430 
GetCurrentUIState()431     UIState GetCurrentUIState() const
432     {
433         return stateStyleMgr_ ? stateStyleMgr_->GetCurrentUIState() : UI_STATE_NORMAL;
434     }
435 
HasStateStyle(UIState state)436     bool HasStateStyle(UIState state) const
437     {
438         if (stateStyleMgr_) {
439             return stateStyleMgr_->HasStateStyle(state);
440         }
441         return false;
442     }
443 
444     void AddSupportedState(UIState state);
445 
446     void SetSupportedStates(UIState state);
447 
448     bool IsCurrentStateOn(UIState state);
449 
SetKeyboardShortcut(const std::string & value,uint8_t keys,const std::function<void ()> & onKeyboardShortcutAction)450     void SetKeyboardShortcut(
451         const std::string& value, uint8_t keys, const std::function<void()>& onKeyboardShortcutAction)
452     {
453         KeyboardShortcut keyboardShortcut;
454         for (auto&& ch : value) {
455             keyboardShortcut.value.push_back(static_cast<char>(std::toupper(ch)));
456         }
457         keyboardShortcut.keys = keys;
458         keyboardShortcut.onKeyboardShortcutAction = onKeyboardShortcutAction;
459 
460         for (auto& shortCut : keyboardShortcut_) {
461             if (shortCut.IsEqualTrigger(keyboardShortcut)) {
462                 shortCut.onKeyboardShortcutAction = onKeyboardShortcutAction;
463                 return;
464             }
465         }
466         keyboardShortcut_.emplace_back(keyboardShortcut);
467     }
468 
ClearSingleKeyboardShortcut()469     void ClearSingleKeyboardShortcut()
470     {
471         if (keyboardShortcut_.size() == 1) {
472             keyboardShortcut_.clear();
473         }
474     }
475 
GetKeyboardShortcut()476     std::vector<KeyboardShortcut>& GetKeyboardShortcut()
477     {
478         return keyboardShortcut_;
479     }
480 
481     void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnDragFunc&& onDragFunc);
482 
483     void SetCustomerOnDragFunc(DragFuncType dragFuncType, OnNewDragFunc&& onDragEnd);
484 
GetCustomerOnDragFunc(DragFuncType dragFuncType)485     const OnDragFunc GetCustomerOnDragFunc(DragFuncType dragFuncType) const
486     {
487         OnDragFunc dragFunc;
488         switch (dragFuncType) {
489             case DragFuncType::DRAG_ENTER:
490                 dragFunc = customerOnDragEnter_;
491                 break;
492             case DragFuncType::DRAG_LEAVE:
493                 dragFunc = customerOnDragLeave_;
494                 break;
495             case DragFuncType::DRAG_MOVE:
496                 dragFunc = customerOnDragMove_;
497                 break;
498             case DragFuncType::DRAG_DROP:
499                 dragFunc = customerOnDrop_;
500                 break;
501             default:
502                 LOGW("unsuport dragFuncType");
503                 break;
504         }
505         return dragFunc;
506     }
507 
GetCustomerOnDragEndFunc()508     const OnNewDragFunc& GetCustomerOnDragEndFunc() const
509     {
510         return customerOnDragEnd_;
511     }
512 
513     void ClearCustomerOnDragFunc();
514 
515     void ClearCustomerOnDragStart();
516 
517     void ClearCustomerOnDragEnter();
518 
519     void ClearCustomerOnDragMove();
520 
521     void ClearCustomerOnDragLeave();
522 
523     void ClearCustomerOnDrop();
524 
525     void ClearCustomerOnDragEnd();
526 
527     void FireCustomerOnDragFunc(
528         DragFuncType dragFuncType, const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams = "");
529 
530     bool IsFireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info);
531 
532     void HandleInternalOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams);
533 
534     void PostEnabledTask();
535 
536     void AddInnerOnAreaChangedCallback(int32_t id, OnAreaChangedFunc&& callback);
537 
538     void RemoveInnerOnAreaChangedCallback(int32_t id);
539 
540     void ClearOnAreaChangedInnerCallbacks();
541 
542     bool HasImmediatelyVisibleCallback();
543 
GetThrottledVisibleAreaRatios()544     std::vector<double>& GetThrottledVisibleAreaRatios()
545     {
546         return throttledVisibleAreaRatios_;
547     }
548 
GetThrottledVisibleAreaCallback()549     VisibleCallbackInfo& GetThrottledVisibleAreaCallback()
550     {
551         return throttledVisibleAreaCallback_;
552     }
553 
GetVisibleAreaRatios(bool isUser)554     std::vector<double>& GetVisibleAreaRatios(bool isUser)
555     {
556         if (isUser) {
557             return visibleAreaUserRatios_;
558         } else {
559             return visibleAreaInnerRatios_;
560         }
561     }
562 
GetVisibleAreaCallback(bool isUser)563     VisibleCallbackInfo& GetVisibleAreaCallback(bool isUser)
564     {
565         if (isUser) {
566             return visibleAreaUserCallback_;
567         } else {
568             return visibleAreaInnerCallback_;
569         }
570     }
571 
SetVisibleAreaRatiosAndCallback(const VisibleCallbackInfo & callback,const std::vector<double> & radios,bool isUser)572     void SetVisibleAreaRatiosAndCallback(
573         const VisibleCallbackInfo& callback, const std::vector<double>& radios, bool isUser)
574     {
575         if (isUser) {
576             VisibleCallbackInfo* cbInfo =
577                 (callback.period == 0) ? &visibleAreaUserCallback_ : &throttledVisibleAreaCallback_;
578             auto ratioInfo = (callback.period == 0) ? &visibleAreaUserRatios_ : &throttledVisibleAreaRatios_;
579             *cbInfo = callback;
580             *ratioInfo = radios;
581         } else {
582             visibleAreaInnerCallback_ = callback;
583             visibleAreaInnerRatios_ = radios;
584         }
585     }
586 
587     void CleanVisibleAreaCallback(bool isUser, bool isThrottled = false)
588     {
589         if (!isUser) {
590             visibleAreaInnerRatios_.clear();
591             visibleAreaInnerCallback_.callback = nullptr;
592         } else if (isThrottled) {
593             throttledVisibleAreaRatios_.clear();
594             throttledVisibleAreaCallback_.callback = nullptr;
595         } else {
596             visibleAreaUserRatios_.clear();
597             visibleAreaUserCallback_.callback = nullptr;
598         }
599     }
600 
SetDefaultOnDragStart(OnDragStartFunc && defaultOnDragStart)601     void SetDefaultOnDragStart(OnDragStartFunc&& defaultOnDragStart)
602     {
603         defaultOnDragStart_ = std::move(defaultOnDragStart);
604     }
605 
GetDefaultOnDragStart()606     const OnDragStartFunc& GetDefaultOnDragStart() const
607     {
608         return defaultOnDragStart_;
609     }
610 
HasDefaultOnDragStart()611     bool HasDefaultOnDragStart() const
612     {
613         return static_cast<bool>(defaultOnDragStart_);
614     }
615 
HasVisibleAreaCallback(bool isUser)616     bool HasVisibleAreaCallback(bool isUser)
617     {
618         if (isUser) {
619             return static_cast<bool>(visibleAreaUserCallback_.callback);
620         } else {
621             return static_cast<bool>(visibleAreaInnerCallback_.callback);
622         }
623     }
624 
625     void SetOnAttach(std::function<void()>&& onAttach);
626     void ClearOnAttach();
627     void FireOnAttach();
628     void SetOnDetach(std::function<void()>&& onDetach);
629     void ClearOnDetach();
630     void FireOnDetach();
631     void ClearStateStyle();
632     void OnDetachClear();
633 
634 protected:
OnModifyDone()635     virtual void OnModifyDone() {}
636     std::function<void()> onAppear_;
637     std::function<void()> onJSFrameNodeAppear_;
638 
639 private:
640     WeakPtr<FrameNode> host_;
641     RefPtr<GestureEventHub> gestureEventHub_;
642     RefPtr<InputEventHub> inputEventHub_;
643     RefPtr<FocusHub> focusHub_;
644     RefPtr<StateStyleManager> stateStyleMgr_;
645 
646     std::function<void()> onDisappear_;
647     std::function<void()> onJSFrameNodeDisappear_;
648     OnAreaChangedFunc onAreaChanged_;
649     std::unordered_map<int32_t, OnAreaChangedFunc> onAreaChangedInnerCallbacks_;
650     OnSizeChangedFunc onSizeChanged_;
651     std::unordered_map<int32_t, OnSizeChangedFunc> onSizeChangedInnerCallbacks_;
652     OnSizeChangedFunc onJsFrameNodeSizeChanged_;
653 
654     std::function<void()> onAttach_;
655     std::function<void()> onDetach_;
656 
657     OnPreDragFunc onPreDragFunc_;
658     OnDragStartFunc onDragStart_;
659     OnDragFunc onDragEnter_;
660     OnDragFunc onDragLeave_;
661     OnDragFunc onDragMove_;
662     OnDragFunc onDrop_;
663     OnNewDragFunc onDragEnd_;
664 
665     OnDragStartFunc defaultOnDragStart_;
666     OnDragFunc customerOnDragEnter_;
667     OnDragFunc customerOnDragLeave_;
668     OnDragFunc customerOnDragMove_;
669     OnDragFunc customerOnDrop_;
670     OnNewDragFunc customerOnDragEnd_;
671 
672     bool enabled_ { true };
673     bool developerEnabled_ { true };
674     std::vector<KeyboardShortcut> keyboardShortcut_;
675 
676     std::vector<double> visibleAreaUserRatios_;
677     VisibleCallbackInfo visibleAreaUserCallback_;
678     std::vector<double> visibleAreaInnerRatios_;
679     VisibleCallbackInfo visibleAreaInnerCallback_;
680     std::vector<double> throttledVisibleAreaRatios_;
681     VisibleCallbackInfo throttledVisibleAreaCallback_;
682 
683     ACE_DISALLOW_COPY_AND_MOVE(EventHub);
684 };
685 
686 class TextCommonEvent : public BaseEventInfo {
DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent,BaseEventInfo)687     DECLARE_RELATIONSHIP_OF_CLASSES(TextCommonEvent, BaseEventInfo)
688 public:
689     TextCommonEvent() : BaseEventInfo("TextCommonEvent") {}
690     ~TextCommonEvent() override = default;
691 };
692 
693 } // namespace OHOS::Ace::NG
694 
695 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
696