• 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_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
17 #define FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
18 
19 #include <cstdint>
20 #include <string>
21 
22 #include "base/memory/ace_type.h"
23 #include "base/utils/noncopyable.h"
24 #include "base/window/drag_window.h"
25 #include "core/common/interaction/interaction_data.h"
26 #include "core/components_ng/base/frame_node.h"
27 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
28 #include "core/gestures/velocity_tracker.h"
29 
30 namespace OHOS::Ace::NG {
31 enum class DragDropMgrState : int32_t {
32     IDLE,
33     ABOUT_TO_PREVIEW,
34     DRAGGING
35 };
36 
37 class ACE_EXPORT DragDropManager : public virtual AceType {
38     DECLARE_ACE_TYPE(DragDropManager, AceType);
39 
40 public:
41     DragDropManager() = default;
42     ~DragDropManager() override = default;
43 
44     RefPtr<DragDropProxy> CreateAndShowDragWindow(const RefPtr<PixelMap>& pixelMap, const GestureEvent& info);
45     RefPtr<DragDropProxy> CreateAndShowDragWindow(const RefPtr<UINode>& customNode, const GestureEvent& info);
46     RefPtr<DragDropProxy> CreateTextDragDropProxy();
47 
AddDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)48     void AddDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
49     {
50         dragFrameNodes_.try_emplace(id, dragFrameNode);
51     }
52 
RemoveDragFrameNode(int32_t id)53     void RemoveDragFrameNode(int32_t id)
54     {
55         dragFrameNodes_.erase(id);
56         gridDragFrameNodes_.erase(id);
57         listDragFrameNodes_.erase(id);
58         textFieldDragFrameNodes_.erase(id);
59     }
60 
AddGridDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)61     void AddGridDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
62     {
63         gridDragFrameNodes_.try_emplace(id, dragFrameNode);
64     }
65 
AddListDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)66     void AddListDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
67     {
68         listDragFrameNodes_.try_emplace(id, dragFrameNode);
69     }
70 
AddTextFieldDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)71     void AddTextFieldDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
72     {
73         textFieldDragFrameNodes_.try_emplace(id, dragFrameNode);
74     }
75 
76     void UpdateDragWindowPosition(int32_t globalX, int32_t globalY);
77     void OnDragStart(const Point& point);
78     void OnDragStart(const Point& point, const RefPtr<FrameNode>& frameNode);
79     void OnDragMove(const PointerEvent& pointerEvent, const std::string& extraInfo);
80     void OnDragEnd(const PointerEvent& pointerEvent, const std::string& extraInfo);
81     void OnDragMoveOut(const PointerEvent& pointerEvent);
82     void OnTextDragEnd(float globalX, float globalY, const std::string& extraInfo);
83     void onDragCancel();
84     void OnItemDragStart(float globalX, float globalY, const RefPtr<FrameNode>& frameNode);
85     void OnItemDragMove(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
86     void OnItemDragEnd(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
87     void onItemDragCancel();
88     void AddDataToClipboard(const std::string& extraInfo);
89     void GetExtraInfoFromClipboard(std::string& extraInfo);
90     void RestoreClipboardData();
91     void DestroyDragWindow();
92     void CancelItemDrag();
93     std::string GetExtraInfo();
94     void SetExtraInfo(const std::string& extraInfo);
95     void ClearExtraInfo();
96     float GetWindowScale() const;
97     void UpdateDragStyle(const DragCursorStyleCore& dragCursorStyleCore = DragCursorStyleCore::DEFAULT);
98     void UpdateDragAllowDrop(const RefPtr<FrameNode>& dragFrameNode, const bool isCopy);
99     void RequireSummary();
100     void ClearSummary();
SetSummaryMap(const std::map<std::string,int64_t> & summaryMap)101     void SetSummaryMap(const std::map<std::string, int64_t>& summaryMap)
102     {
103         summaryMap_ = summaryMap;
104     }
105     void ResetRecordSize(uint32_t recordSize = 0);
106     uint32_t GetRecordSize() const;
107     Rect GetDragWindowRect(const Point& point);
108     RefPtr<DragDropProxy> CreateFrameworkDragDropProxy();
109     void UpdatePixelMapPosition(int32_t globalX, int32_t globalY);
110     void HideDragPreviewOverlay();
111     bool IsMsdpDragging() const;
112     void UpdateDragEvent(RefPtr<OHOS::Ace::DragEvent>& event, const Point& point);
113     void UpdateNotifyDragEvent(
114         RefPtr<NotifyDragEvent>& notifyEvent, const Point& point, const DragEventType dragEventType);
115     bool CheckDragDropProxy(int64_t id) const;
116     void FireOnEditableTextComponent(const RefPtr<FrameNode>& frameNode, DragEventType type);
117 
IsWindowConsumed()118     bool IsWindowConsumed() const
119     {
120         return isWindowConsumed_;
121     }
122 
SetIsWindowConsumed(bool consumed)123     void SetIsWindowConsumed(bool consumed)
124     {
125         isWindowConsumed_ = consumed;
126     }
127 
IsDragged()128     bool IsDragged() const
129     {
130         return isDragged_;
131     }
132 
SetIsDragged(bool isDragged)133     void SetIsDragged(bool isDragged)
134     {
135         if (isDragged && isDragged_ != isDragged && notifyInDraggedCallback_) {
136             notifyInDraggedCallback_();
137         }
138         isDragged_ = isDragged;
139     }
140 
SetIsDragCancel(bool isDragCancel)141     void SetIsDragCancel(bool isDragCancel)
142     {
143         isDragCancel_ = isDragCancel;
144     }
145 
SetIsMouseDrag(bool isMouseDragged)146     void SetIsMouseDrag(bool isMouseDragged)
147     {
148         isMouseDragged_ = isMouseDragged;
149     }
150 
SetIsDragWindowShow(bool isDragWindowShow)151     void SetIsDragWindowShow(bool isDragWindowShow)
152     {
153         isDragWindowShow_ = isDragWindowShow;
154     }
155 
IsDragWindowShow()156     bool IsDragWindowShow() const
157     {
158         return isDragWindowShow_;
159     }
160 
SetPreviewRect(const Rect & rect)161     void SetPreviewRect(const Rect& rect)
162     {
163         previewRect_ = rect;
164     }
165 
GetPreviewRect()166     Rect GetPreviewRect() const
167     {
168         return previewRect_;
169     }
170 
171     RefPtr<FrameNode> FindTargetInChildNodes(const RefPtr<UINode> parentNode,
172         std::vector<RefPtr<FrameNode>> hitFrameNodes, bool findDrop);
173 
174     std::unordered_set<int32_t> FindHitFrameNodes(const Point& point);
175 
176     void UpdateDragListener(const Point& point);
177 
178     void NotifyDragRegisterFrameNode(std::unordered_map<int32_t, WeakPtr<FrameNode>> nodes, DragEventType dragEventType,
179         RefPtr<NotifyDragEvent>& notifyEvent);
180 
RegisterDragStatusListener(int32_t nodeId,const WeakPtr<FrameNode> & node)181     void RegisterDragStatusListener(int32_t nodeId, const WeakPtr<FrameNode>& node)
182     {
183         auto ret = nodesForDragNotify_.try_emplace(nodeId, node);
184         if (!ret.second) {
185             nodesForDragNotify_[nodeId] = node;
186         }
187     }
188 
UnRegisterDragStatusListener(int32_t nodeId)189     void UnRegisterDragStatusListener(int32_t nodeId)
190     {
191         nodesForDragNotify_.erase(nodeId);
192     }
193 
SetNotifyInDraggedCallback(const std::function<void (void)> & callback)194     void SetNotifyInDraggedCallback(const std::function<void(void)>& callback)
195     {
196         notifyInDraggedCallback_ = callback;
197     }
198 
IsDragging()199     bool IsDragging() const
200     {
201         return dragDropState_ == DragDropMgrState::DRAGGING;
202     }
203 
IsItemDragging()204     bool IsItemDragging() const
205     {
206         return dragDropState_ == DragDropMgrState::DRAGGING && draggedGridFrameNode_ != nullptr;
207     }
208 
IsAboutToPreview()209     bool IsAboutToPreview() const
210     {
211         return dragDropState_ == DragDropMgrState::ABOUT_TO_PREVIEW;
212     }
213 
214     void ResetDragging(DragDropMgrState dragDropMgrState = DragDropMgrState::IDLE)
215     {
216         dragDropState_ = dragDropMgrState;
217     }
218 
SetDraggingPressedState(bool pointerPressed)219     void SetDraggingPressedState(bool pointerPressed)
220     {
221         draggingPressedState_ = pointerPressed;
222     }
223 
IsDraggingPressed(int32_t currentPointerId)224     bool IsDraggingPressed(int32_t currentPointerId) const
225     {
226         if (currentPointerId_ == currentPointerId) {
227             return draggingPressedState_;
228         }
229         return false;
230     }
231 
IsSameDraggingPointer(int32_t currentPointerId)232     bool IsSameDraggingPointer(int32_t currentPointerId) const
233     {
234         return currentPointerId_ == currentPointerId;
235     }
236 
SetDraggingPointer(int32_t currentPointerId)237     void SetDraggingPointer(int32_t currentPointerId)
238     {
239         currentPointerId_ = currentPointerId;
240     }
241 
IsEditableTextComponent(const std::string & frameTag)242     static inline bool IsEditableTextComponent(const std::string& frameTag)
243     {
244         if (frameTag != V2::TEXTINPUT_ETS_TAG && frameTag != V2::TEXTAREA_ETS_TAG &&
245             frameTag != V2::RICH_EDITOR_ETS_TAG && frameTag != V2::SEARCH_Field_ETS_TAG) {
246             return false;
247         }
248         return true;
249     }
250 
251     typedef struct DragPreviewInfo {
252         double width { 0.0 };
253         double height { 0.0 };
254         double maxWidth { 0.0 };
255         double scale { -1.0 };
256         RefPtr<FrameNode> imageNode { nullptr };
257     } DragPreviewInfo;
258     bool IsNeedScaleDragPreview();
259     void DoDragMoveAnimate(const PointerEvent& pointerEvent);
260     void DoDragStartAnimation(const RefPtr<OverlayManager>& overlayManager, const GestureEvent& event);
261     void SetDragResult(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
ResetDragPreviewInfo()262     void ResetDragPreviewInfo()
263     {
264         info_ = DragPreviewInfo();
265     }
266 
267 private:
268     double CalcDragPreviewDistanceWithPoint(
269         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
270     Offset CalcDragMoveOffset(
271         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
272     bool GetDragPreviewInfo(
273         const OHOS::Ace::RefPtr<OHOS::Ace::NG::OverlayManager>& overlayManager, DragPreviewInfo& dragPreviewInfo);
274     RefPtr<FrameNode> FindDragFrameNodeByPosition(float globalX, float globalY, DragType dragType, bool findDrop);
275     void FireOnDragEvent(
276         const RefPtr<FrameNode>& frameNode, const Point& point, DragEventType type, const std::string& extraInfo);
277     void FireOnItemDragEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
278         const ItemDragInfo& itemDragInfo, DragEventType type, int32_t draggedIndex, int32_t insertIndex = 0);
279     bool FireOnItemDropEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
280         const ItemDragInfo& itemDragInfo, int32_t draggedIndex, int32_t insertIndex, bool isSuccess);
281     int32_t GetItemIndex(const RefPtr<FrameNode>& frameNode, DragType dragType, float globalX, float globalY);
282     void CreateDragWindow(const GestureEvent& info, uint32_t width, uint32_t height);
283     RefPtr<FrameNode> CreateDragRootNode(const RefPtr<UINode>& customNode);
284     void ClearVelocityInfo();
285     void UpdateVelocityTrackerPoint(const Point& point, bool isEnd = false);
286     void PrintDragFrameNode(const Point& point, const RefPtr<FrameNode>& dragFrameNode);
287     void FireOnDragEventWithDragType(const RefPtr<EventHub>& eventHub, DragEventType type,
288         RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
289     void NotifyDragFrameNode(
290         const Point& point, const DragEventType& dragEventType, const DragRet& dragRet = DragRet::DRAG_DEFAULT);
291     void TransDragWindowToDragFwk(int32_t windowContainerId);
292 
293     std::map<int32_t, WeakPtr<FrameNode>> dragFrameNodes_;
294     std::map<int32_t, WeakPtr<FrameNode>> gridDragFrameNodes_;
295     std::map<int32_t, WeakPtr<FrameNode>> listDragFrameNodes_;
296     std::map<int32_t, WeakPtr<FrameNode>> textFieldDragFrameNodes_;
297     RefPtr<DragWindow> dragWindow_;
298     RefPtr<FrameNode> draggedFrameNode_;
299     RefPtr<FrameNode> preTargetFrameNode_;
300     RefPtr<FrameNode> draggedGridFrameNode_;
301     RefPtr<FrameNode> preGridTargetFrameNode_;
302     RefPtr<FrameNode> dragWindowRootNode_;
303     RefPtr<Clipboard> clipboard_;
304     std::function<void(const std::string&)> addDataCallback_ = nullptr;
305     std::function<void(const std::string&)> getDataCallback_ = nullptr;
306     std::function<void(const std::string&)> deleteDataCallback_ = nullptr;
307     std::string extraInfo_;
308     std::unique_ptr<JsonValue> newData_ = nullptr;
309     bool isDragCancel_ = false;
310     std::unordered_map<int32_t, WeakPtr<FrameNode>> nodesForDragNotify_;
311     std::unordered_set<int32_t> parentHitNodes_;
312     DragCursorStyleCore dragCursorStyleCore_ = DragCursorStyleCore::DEFAULT;
313     std::map<std::string, int64_t> summaryMap_;
314     uint32_t recordSize_ = 0;
315     int64_t currentId_ = -1;
316     int32_t currentPointerId_ = -1;
317     bool draggingPressedState_ = false;
318 
319     std::function<void(void)> notifyInDraggedCallback_ = nullptr;
320     bool isDragged_ = false;
321     bool isMouseDragged_ = false;
322     bool isWindowConsumed_ = false;
323     bool isDragWindowShow_ = false;
324     bool hasNotifiedTransformation_ = false;
325     VelocityTracker velocityTracker_;
326     DragDropMgrState dragDropState_ = DragDropMgrState::IDLE;
327     Rect previewRect_ { -1, -1, -1, -1 };
328     DragPreviewInfo info_;
329     bool isDragFwkShow_ { false };
330 
331     ACE_DISALLOW_COPY_AND_MOVE(DragDropManager);
332 };
333 } // namespace OHOS::Ace::NG
334 
335 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
336