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_EVENT_ON_MOUSE_EVENT_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_ON_MOUSE_EVENT_H
18 
19 #include "core/event/mouse_event.h"
20 
21 namespace OHOS::Ace::NG {
22 
23 class InputEventHub;
24 class FrameNode;
25 
26 class InputEvent : public virtual AceType {
DECLARE_ACE_TYPE(InputEvent,AceType)27     DECLARE_ACE_TYPE(InputEvent, AceType)
28 public:
29     explicit InputEvent(OnMouseEventFunc&& callback) : onMouseCallback_(std::move(callback)) {}
30 
InputEvent(OnHoverEventFunc && callback)31     explicit InputEvent(OnHoverEventFunc&& callback) : onHoverCallback_(std::move(callback)) {}
32 
InputEvent(OnHoverFunc && callback)33     explicit InputEvent(OnHoverFunc&& callback) : onHoverEventCallback_(std::move(callback)) {}
34 
InputEvent(OnAxisEventFunc && callback)35     explicit InputEvent(OnAxisEventFunc&& callback) : onAxisCallback_(std::move(callback)) {}
36 
InputEvent(OnAccessibilityHoverFunc && callback)37     explicit InputEvent(OnAccessibilityHoverFunc&& callback) : onAccessibilityHoverFunc_(std::move(callback)) {}
38 
39     ~InputEvent() override = default;
40 
GetOnMouseEventFunc()41     const OnMouseEventFunc& GetOnMouseEventFunc() const
42     {
43         return onMouseCallback_;
44     }
45 
GetOnHoverEventFunc()46     const OnHoverEventFunc& GetOnHoverEventFunc() const
47     {
48         return onHoverCallback_;
49     }
50 
GetOnHoverFunc()51     const OnHoverFunc& GetOnHoverFunc() const
52     {
53         return onHoverEventCallback_;
54     }
55 
GetOnAxisEventFunc()56     const OnAxisEventFunc& GetOnAxisEventFunc() const
57     {
58         return onAxisCallback_;
59     }
60 
GetOnAccessibilityHoverFunc()61     const OnAccessibilityHoverFunc& GetOnAccessibilityHoverFunc() const
62     {
63         return onAccessibilityHoverFunc_;
64     }
65 
operator()66     void operator()(MouseInfo& info) const
67     {
68         if (onMouseCallback_) {
69             onMouseCallback_(info);
70         }
71     }
72 
operator()73     void operator()(bool state, HoverInfo& info) const
74     {
75         if (onHoverEventCallback_) {
76             onHoverEventCallback_(state, info);
77         }
78     }
operator()79     void operator()(bool state) const
80     {
81         if (onHoverCallback_) {
82             onHoverCallback_(state);
83         }
84     }
85 
operator()86     void operator()(AxisInfo& info) const
87     {
88         if (onAxisCallback_) {
89             onAxisCallback_(info);
90         }
91     }
92 
operator()93     void operator()(bool state, AccessibilityHoverInfo& info) const
94     {
95         if (onAccessibilityHoverFunc_) {
96             onAccessibilityHoverFunc_(state, info);
97         }
98     }
99 
100 private:
101     OnMouseEventFunc onMouseCallback_;
102     OnHoverEventFunc onHoverCallback_;
103     OnHoverFunc onHoverEventCallback_;
104     OnAxisEventFunc onAxisCallback_;
105     OnAccessibilityHoverFunc onAccessibilityHoverFunc_;
106 };
107 
108 class ACE_EXPORT InputEventActuator : public virtual AceType {
109     DECLARE_ACE_TYPE(InputEventActuator, AceType)
110 public:
111     explicit InputEventActuator(const WeakPtr<InputEventHub>& inputEventHub);
112     ~InputEventActuator() override = default;
113 
ClearUserCallback()114     void ClearUserCallback()
115     {
116         if (userCallback_) {
117             userCallback_.Reset();
118         }
119     }
120 
ClearJSFrameNodeCallback()121     void ClearJSFrameNodeCallback()
122     {
123         if (userJSFrameNodeCallback_) {
124             userJSFrameNodeCallback_.Reset();
125         }
126     }
127 
ReplaceJSFrameNodeInputEvent(OnMouseEventFunc && callback)128     void ReplaceJSFrameNodeInputEvent(OnMouseEventFunc&& callback)
129     {
130         if (userJSFrameNodeCallback_) {
131             userJSFrameNodeCallback_.Reset();
132         }
133         userJSFrameNodeCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
134     }
ReplaceJSFrameNodeInputEvent(OnHoverFunc && callback)135     void ReplaceJSFrameNodeInputEvent(OnHoverFunc&& callback)
136     {
137         if (userJSFrameNodeCallback_) {
138             userJSFrameNodeCallback_.Reset();
139         }
140         userJSFrameNodeCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
141     }
142 
ReplaceInputEvent(OnMouseEventFunc && callback)143     void ReplaceInputEvent(OnMouseEventFunc&& callback)
144     {
145         if (userCallback_) {
146             userCallback_.Reset();
147         }
148         userCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
149     }
ReplaceInputEvent(OnHoverFunc && callback)150     void ReplaceInputEvent(OnHoverFunc&& callback)
151     {
152         if (userCallback_) {
153             userCallback_.Reset();
154         }
155         userCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
156     }
157 
ReplaceInputEvent(OnAxisEventFunc && callback)158     void ReplaceInputEvent(OnAxisEventFunc&& callback)
159     {
160         if (userCallback_) {
161             userCallback_.Reset();
162         }
163         userCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
164     }
165 
ReplaceInputEvent(OnAccessibilityHoverFunc && callback)166     void ReplaceInputEvent(OnAccessibilityHoverFunc&& callback)
167     {
168         if (userCallback_) {
169             userCallback_.Reset();
170         }
171         userCallback_ = MakeRefPtr<InputEvent>(std::move(callback));
172     }
173 
AddInputEvent(const RefPtr<InputEvent> & inputEvent)174     void AddInputEvent(const RefPtr<InputEvent>& inputEvent)
175     {
176         if (inputEvents_.empty()) {
177             inputEvents_.emplace_back(inputEvent);
178             return;
179         }
180         if (std::find(inputEvents_.begin(), inputEvents_.end(), inputEvent) == inputEvents_.end()) {
181             inputEvents_.emplace_back(inputEvent);
182         }
183     }
184 
RemoveInputEvent(const RefPtr<InputEvent> & inputEvent)185     void RemoveInputEvent(const RefPtr<InputEvent>& inputEvent)
186     {
187         inputEvents_.remove(inputEvent);
188     }
189 
190     void OnCollectMouseEvent(const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl,
191         TouchTestResult& result);
192 
193     void OnCollectHoverEvent(
194         const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl, TouchTestResult& result);
195 
196     void OnCollectHoverEffect(const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl,
197         TouchTestResult& result);
198 
199     void OnCollectAccessibilityHoverEvent(const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl,
200         TouchTestResult& result, const RefPtr<FrameNode>& host);
201 
202     void OnCollectPenHoverEvent(
203         const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl, TouchTestResult& result);
204 
205     void OnCollectAxisEvent(
206         const OffsetF& coordinateOffset, const GetEventTargetImpl& getEventTargetImpl, AxisTestResult& onAxisResult);
207 
208 private:
209     WeakPtr<InputEventHub> inputEventHub_;
210     RefPtr<MouseEventTarget> mouseEventTarget_;
211     RefPtr<HoverEventTarget> hoverEventTarget_;
212     RefPtr<HoverEffectTarget> hoverEffectTarget_;
213     RefPtr<HoverEventTarget> accessibilityHoverEventTarget_;
214     RefPtr<HoverEventTarget> penHoverEventTarget_;
215     RefPtr<AxisEventTarget> axisEventTarget_;
216     std::list<RefPtr<InputEvent>> inputEvents_;
217     RefPtr<InputEvent> userCallback_;
218     RefPtr<InputEvent> userJSFrameNodeCallback_;
219 };
220 
221 } // namespace OHOS::Ace::NG
222 
223 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_EVENT_INPUT_EVENT_H
224