• 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 using OnAreaChangedFunc =
34     std::function<void(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)>;
35 
36 struct KeyboardShortcut {
37     std::string value;
38     uint8_t keys = 0;
39     std::function<void()> onKeyboardShortcutAction = nullptr;
40 };
41 
42 // The event hub is mainly used to handle common collections of events, such as gesture events, mouse events, etc.
43 class EventHub : public virtual AceType {
44     DECLARE_ACE_TYPE(EventHub, AceType)
45 
46 public:
47     EventHub() = default;
~EventHub()48     ~EventHub() override
49     {
50         keyboardShortcut_.clear();
51     };
52 
GetOrCreateGestureEventHub()53     const RefPtr<GestureEventHub>& GetOrCreateGestureEventHub()
54     {
55         if (!gestureEventHub_) {
56             gestureEventHub_ = MakeRefPtr<GestureEventHub>(WeakClaim(this));
57         }
58         return gestureEventHub_;
59     }
60 
GetGestureEventHub()61     const RefPtr<GestureEventHub>& GetGestureEventHub() const
62     {
63         return gestureEventHub_;
64     }
65 
GetOrCreateInputEventHub()66     const RefPtr<InputEventHub>& GetOrCreateInputEventHub()
67     {
68         if (!inputEventHub_) {
69             inputEventHub_ = MakeRefPtr<InputEventHub>(WeakClaim(this));
70         }
71         return inputEventHub_;
72     }
73 
GetInputEventHub()74     const RefPtr<InputEventHub>& GetInputEventHub() const
75     {
76         return inputEventHub_;
77     }
78 
79     const RefPtr<FocusHub>& GetOrCreateFocusHub(FocusType type = FocusType::DISABLE, bool focusable = false,
80         FocusStyleType focusStyleType = FocusStyleType::NONE,
81         const std::unique_ptr<FocusPaintParam>& paintParamsPtr = nullptr)
82     {
83         if (!focusHub_) {
84             focusHub_ = MakeRefPtr<FocusHub>(WeakClaim(this), type, focusable);
85             focusHub_->SetFocusStyleType(focusStyleType);
86             if (paintParamsPtr) {
87                 focusHub_->SetFocusPaintParamsPtr(paintParamsPtr);
88             }
89         }
90         return focusHub_;
91     }
92 
GetFocusHub()93     const RefPtr<FocusHub>& GetFocusHub() const
94     {
95         return focusHub_;
96     }
97 
98     void AttachHost(const WeakPtr<FrameNode>& host);
99 
100     RefPtr<FrameNode> GetFrameNode() const;
101 
102     GetEventTargetImpl CreateGetEventTargetImpl() const;
103 
OnContextAttached()104     void OnContextAttached()
105     {
106         if (gestureEventHub_) {
107             gestureEventHub_->OnContextAttached();
108         }
109     }
110 
ClearUserOnAppear()111     void ClearUserOnAppear()
112     {
113         if (onAppear_) {
114             onAppear_ = nullptr;
115         }
116     }
117 
SetOnAppear(std::function<void ()> && onAppear)118     void SetOnAppear(std::function<void()>&& onAppear)
119     {
120         onAppear_ = std::move(onAppear);
121     }
122 
FireOnAppear()123     void FireOnAppear()
124     {
125         if (onAppear_) {
126             auto pipeline = PipelineBase::GetCurrentContext();
127             CHECK_NULL_VOID(pipeline);
128             auto taskScheduler = pipeline->GetTaskExecutor();
129             CHECK_NULL_VOID(taskScheduler);
130             taskScheduler->PostTask(
131                 [weak = WeakClaim(this)]() {
132                     auto eventHub = weak.Upgrade();
133                     CHECK_NULL_VOID(eventHub);
134                     if (eventHub->onAppear_) {
135                         eventHub->onAppear_();
136                     }
137                 },
138                 TaskExecutor::TaskType::UI);
139         }
140     }
141 
ClearUserOnDisAppear()142     void ClearUserOnDisAppear()
143     {
144         if (onDisappear_) {
145             onDisappear_ = nullptr;
146         }
147     }
148 
SetOnDisappear(std::function<void ()> && onDisappear)149     void SetOnDisappear(std::function<void()>&& onDisappear)
150     {
151         onDisappear_ = std::move(onDisappear);
152     }
153 
FireOnDisappear()154     void FireOnDisappear()
155     {
156         if (onDisappear_) {
157             onDisappear_();
158         }
159     }
160 
ClearUserOnAreaChanged()161     void ClearUserOnAreaChanged()
162     {
163         if (onAreaChanged_) {
164             onAreaChanged_ = nullptr;
165         }
166     }
167 
SetOnAreaChanged(OnAreaChangedFunc && onAreaChanged)168     void SetOnAreaChanged(OnAreaChangedFunc&& onAreaChanged)
169     {
170         onAreaChanged_ = std::move(onAreaChanged);
171     }
172 
FireOnAreaChanged(const RectF & oldRect,const OffsetF & oldOrigin,const RectF & rect,const OffsetF & origin)173     void FireOnAreaChanged(const RectF& oldRect, const OffsetF& oldOrigin, const RectF& rect, const OffsetF& origin)
174     {
175         if (onAreaChanged_) {
176             onAreaChanged_(oldRect, oldOrigin, rect, origin);
177         }
178     }
179 
HasOnAreaChanged()180     bool HasOnAreaChanged() const
181     {
182         return static_cast<bool>(onAreaChanged_);
183     }
184 
185     using OnDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
186     using OnNewDragFunc = std::function<void(const RefPtr<OHOS::Ace::DragEvent>&)>;
187     using OnDragStartFunc = std::function<DragDropInfo(const RefPtr<OHOS::Ace::DragEvent>&, const std::string&)>;
SetOnDragStart(OnDragStartFunc && onDragStart)188     void SetOnDragStart(OnDragStartFunc&& onDragStart)
189     {
190         onDragStart_ = std::move(onDragStart);
191     }
192 
GetOnDragStart()193     const OnDragStartFunc& GetOnDragStart() const
194     {
195         return onDragStart_;
196     }
197 
HasOnDragStart()198     bool HasOnDragStart() const
199     {
200         return static_cast<bool>(onDragStart_);
201     }
202 
SetOnDragEnter(OnDragFunc && onDragEnter)203     void SetOnDragEnter(OnDragFunc&& onDragEnter)
204     {
205         onDragEnter_ = std::move(onDragEnter);
206     }
207 
FireOnDragEnter(const RefPtr<OHOS::Ace::DragEvent> & info,const std::string & extraParams)208     void FireOnDragEnter(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams)
209     {
210         if (SystemProperties::GetDebugEnabled()) {
211             LOGI("DragDropManager fire onDragEnter");
212         }
213         if (onDragEnter_) {
214             onDragEnter_(info, extraParams);
215         }
216     }
217 
SetOnDragLeave(OnDragFunc && onDragLeave)218     void SetOnDragLeave(OnDragFunc&& onDragLeave)
219     {
220         onDragLeave_ = std::move(onDragLeave);
221     }
222 
FireOnDragLeave(const RefPtr<OHOS::Ace::DragEvent> & info,const std::string & extraParams)223     void FireOnDragLeave(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams)
224     {
225         if (SystemProperties::GetDebugEnabled()) {
226             LOGI("DragDropManager fire onDragLeave");
227         }
228         if (onDragLeave_) {
229             onDragLeave_(info, extraParams);
230         }
231     }
232 
SetOnDragMove(OnDragFunc && onDragMove)233     void SetOnDragMove(OnDragFunc&& onDragMove)
234     {
235         onDragMove_ = std::move(onDragMove);
236     }
237 
FireOnDragMove(const RefPtr<OHOS::Ace::DragEvent> & info,const std::string & extraParams)238     void FireOnDragMove(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams)
239     {
240         if (SystemProperties::GetDebugEnabled()) {
241             LOGI("DragDropManager fire onDragMove");
242         }
243         if (onDragMove_) {
244             onDragMove_(info, extraParams);
245         }
246     }
247 
HasOnDragMove()248     bool HasOnDragMove() const
249     {
250         return static_cast<bool>(onDragMove_);
251     }
252 
SetOnDrop(OnDragFunc && onDrop)253     void SetOnDrop(OnDragFunc&& onDrop)
254     {
255         onDrop_ = std::move(onDrop);
256     }
257 
SetOnDragEnd(OnNewDragFunc && onDragEnd)258     void SetOnDragEnd(OnNewDragFunc&& onDragEnd)
259     {
260         onDragEnd_ = std::move(onDragEnd);
261     }
262 
GetOnDragEnd()263     const OnNewDragFunc& GetOnDragEnd() const
264     {
265         return onDragEnd_;
266     }
267 
HasOnDragEnd()268     bool HasOnDragEnd() const
269     {
270         return static_cast<bool>(onDragEnd_);
271     }
272 
HasOnItemDragMove()273     virtual bool HasOnItemDragMove()
274     {
275         return false;
276     }
277 
HasOnItemDrop()278     virtual bool HasOnItemDrop()
279     {
280         return false;
281     }
282 
FireOnDrop(const RefPtr<OHOS::Ace::DragEvent> & info,const std::string & extraParams)283     void FireOnDrop(const RefPtr<OHOS::Ace::DragEvent>& info, const std::string& extraParams)
284     {
285         if (SystemProperties::GetDebugEnabled()) {
286             LOGI("DragDropManager fire onDrop");
287         }
288         if (onDrop_) {
289             onDrop_(info, extraParams);
290         }
291     }
292 
HasOnDrop()293     bool HasOnDrop() const
294     {
295         return static_cast<bool>(onDrop_);
296     }
297 
GetDragExtraParams(const std::string & extraInfo,const Point & point,DragEventType isStart)298     virtual std::string GetDragExtraParams(const std::string& extraInfo, const Point& point, DragEventType isStart)
299     {
300         auto json = JsonUtil::Create(true);
301         if (!extraInfo.empty()) {
302             json->Put("extraInfo", extraInfo.c_str());
303         }
304         return json->ToString();
305     }
306 
IsEnabled()307     bool IsEnabled() const
308     {
309         return enabled_;
310     }
311 
SetEnabled(bool enabled)312     void SetEnabled(bool enabled)
313     {
314         enabled_ = enabled;
315         developerEnabled_ = enabled;
316     }
317 
SetEnabledInternal(bool enabled)318     void SetEnabledInternal(bool enabled)
319     {
320         enabled_ = enabled;
321     }
322 
323     // restore enabled value to what developer sets
RestoreEnabled()324     void RestoreEnabled()
325     {
326         enabled_ = developerEnabled_;
327     }
328 
329     // get XTS inspector value
ToJsonValue(std::unique_ptr<JsonValue> & json)330     virtual void ToJsonValue(std::unique_ptr<JsonValue>& json) const {}
331 
FromJson(const std::unique_ptr<JsonValue> & json)332     virtual void FromJson(const std::unique_ptr<JsonValue>& json) {}
333 
334     void MarkModifyDone();
335 
336     void SetCurrentUIState(UIState state, bool flag);
337 
UpdateCurrentUIState(UIState state)338     void UpdateCurrentUIState(UIState state)
339     {
340         if (stateStyleMgr_) {
341             stateStyleMgr_->UpdateCurrentUIState(state);
342         }
343     }
344 
ResetCurrentUIState(UIState state)345     void ResetCurrentUIState(UIState state)
346     {
347         if (stateStyleMgr_) {
348             stateStyleMgr_->ResetCurrentUIState(state);
349         }
350     }
351 
GetCurrentUIState()352     UIState GetCurrentUIState() const
353     {
354         return stateStyleMgr_ ? stateStyleMgr_->GetCurrentUIState() : UI_STATE_NORMAL;
355     }
356 
HasStateStyle(UIState state)357     bool HasStateStyle(UIState state) const
358     {
359         if (stateStyleMgr_) {
360             return stateStyleMgr_->HasStateStyle(state);
361         }
362         return false;
363     }
364 
365     void AddSupportedState(UIState state);
366 
367     void SetSupportedStates(UIState state);
368 
369     bool IsCurrentStateOn(UIState state);
370 
SetKeyboardShortcut(const std::string & value,uint8_t keys,const std::function<void ()> & onKeyboardShortcutAction)371     void SetKeyboardShortcut(
372         const std::string& value, uint8_t keys, const std::function<void()>& onKeyboardShortcutAction)
373     {
374         if (value.empty() && keys == 0) {
375             if (keyboardShortcut_.size() == 1) {
376                 keyboardShortcut_.clear();
377             }
378             return;
379         }
380         KeyboardShortcut keyboardShortcut;
381         for (auto&& ch : value) {
382             keyboardShortcut.value.push_back(static_cast<char>(std::toupper(ch)));
383         }
384         keyboardShortcut.keys = keys;
385         keyboardShortcut.onKeyboardShortcutAction = onKeyboardShortcutAction;
386         keyboardShortcut_.emplace_back(keyboardShortcut);
387     }
388 
GetKeyboardShortcut()389     std::vector<KeyboardShortcut>& GetKeyboardShortcut()
390     {
391         return keyboardShortcut_;
392     }
393 
394 protected:
OnModifyDone()395     virtual void OnModifyDone() {}
396 
397 private:
398     WeakPtr<FrameNode> host_;
399     RefPtr<GestureEventHub> gestureEventHub_;
400     RefPtr<InputEventHub> inputEventHub_;
401     RefPtr<FocusHub> focusHub_;
402     RefPtr<StateStyleManager> stateStyleMgr_;
403 
404     std::function<void()> onAppear_;
405     std::function<void()> onDisappear_;
406     OnAreaChangedFunc onAreaChanged_;
407 
408     OnDragStartFunc onDragStart_;
409     OnDragFunc onDragEnter_;
410     OnDragFunc onDragLeave_;
411     OnDragFunc onDragMove_;
412     OnDragFunc onDrop_;
413     OnNewDragFunc onDragEnd_;
414 
415     bool enabled_ { true };
416     bool developerEnabled_ { true };
417     std::vector<KeyboardShortcut> keyboardShortcut_;
418 
419     ACE_DISALLOW_COPY_AND_MOVE(EventHub);
420 };
421 
422 } // namespace OHOS::Ace::NG
423 
424 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_EVENT_HUB_H
425