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