• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2022-2024 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 "core/common/interaction/interaction_data.h"
25 #include "core/components_ng/base/frame_node.h"
26 #include "core/components_ng/manager/drag_drop/drag_drop_proxy.h"
27 #include "core/components_ng/manager/drag_drop/utils/internal_drag_action.h"
28 #include "core/gestures/velocity_tracker.h"
29 
30 namespace OHOS::Ace {
31 class UnifiedData;
32 class GridColumnInfo;
33 }
34 namespace OHOS::Ace::NG {
35 enum class DragDropMgrState : int32_t {
36     IDLE,
37     ABOUT_TO_PREVIEW,
38     DRAGGING
39 };
40 
41 struct GatherAnimationInfo {
42     float scale = 0.0f;
43     float width = 0.0f;
44     float height = 0.0f;
45     OffsetF gatherNodeCenter;
46     std::optional<BorderRadiusProperty> borderRadius;
47 };
48 
49 class ACE_EXPORT DragDropManager : public virtual AceType {
50     DECLARE_ACE_TYPE(DragDropManager, AceType);
51 
52 public:
53     DragDropManager() = default;
54     ~DragDropManager() override = default;
55 
56     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
57         const RefPtr<PixelMap>& pixelMap, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
58     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
59         const RefPtr<UINode>& customNode, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
60     RefPtr<DragDropProxy> CreateTextDragDropProxy();
61 
AddDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)62     void AddDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
63     {
64         dragFrameNodes_.try_emplace(id, dragFrameNode);
65     }
66 
67     void RemoveDragFrameNode(int32_t id);
68 
AddGridDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)69     void AddGridDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
70     {
71         gridDragFrameNodes_.try_emplace(id, dragFrameNode);
72     }
73 
AddListDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)74     void AddListDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
75     {
76         listDragFrameNodes_.try_emplace(id, dragFrameNode);
77     }
78 
AddTextFieldDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)79     void AddTextFieldDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
80     {
81         textFieldDragFrameNodes_.try_emplace(id, dragFrameNode);
82     }
83 
SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)84     void SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)
85     {
86         eventStrictReportingEnabled_ = dragEventStrictReportingEnabled;
87     }
88 
IsEventStrictReportingEnabled()89     bool IsEventStrictReportingEnabled()
90     {
91         return eventStrictReportingEnabled_;
92     }
93 
94     void UpdateItemDragPosition(int32_t globalX, int32_t globalY);
95     void OnDragStart(const Point& point);
96     void OnDragStart(const Point& point, const RefPtr<FrameNode>& frameNode);
97     void OnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
98         const RefPtr<FrameNode>& node = nullptr);
99     void OnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
100         const RefPtr<FrameNode>& node = nullptr);
101     void HandleOnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
102         const RefPtr<FrameNode>& dragFrameNode);
103     void HandleOnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
104         const RefPtr<FrameNode>& dragFrameNode);
105     void DoDragReset();
106     void DoDropAction(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
107         const RefPtr<UnifiedData>& unifiedData, const std::string& udKey);
108     void RequestDragSummaryInfoAndPrivilege();
109     RefPtr<UnifiedData> RequestUDMFDataWithUDKey(const std::string& udKey);
110     void TryGetDataBackGround(
111         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
112         const std::string& udKey, int32_t count = 0);
113     void OnDragDrop(RefPtr<OHOS::Ace::DragEvent>& event, const RefPtr<FrameNode>& dragFrameNode,
114         const OHOS::Ace::DragPointerEvent& pointerEvent);
115     void ResetDragDropStatus(const Point& point, const DragDropRet& dragDropRet, int32_t windowId);
116     bool CheckRemoteData(
117         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent, const std::string& udKey);
118     void OnDragMoveOut(const DragPointerEvent& pointerEvent);
119     void OnTextDragEnd(float globalX, float globalY, const std::string& extraInfo);
120     void onDragCancel();
121     void OnItemDragStart(float globalX, float globalY, const RefPtr<FrameNode>& frameNode);
122     void OnItemDragMove(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
123     void OnItemDragEnd(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
124     void onItemDragCancel();
125     void AddDataToClipboard(const std::string& extraInfo);
126     void GetExtraInfoFromClipboard(std::string& extraInfo);
127     void RestoreClipboardData();
128     void DestroyDragWindow();
129     void CancelItemDrag();
130     std::string GetExtraInfo();
131     void SetExtraInfo(const std::string& extraInfo);
132     void ClearExtraInfo();
133     float GetWindowScale() const;
134     void UpdateDragStyle(
135         const DragCursorStyleCore& dragCursorStyleCore = DragCursorStyleCore::DEFAULT, const int32_t eventId = -1);
136     void UpdateDragAllowDrop(const RefPtr<FrameNode>& dragFrameNode, const DragBehavior dragBehavior,
137         const int32_t eventId = -1, bool isCapi = false);
138     bool CheckExtraSituation(const RefPtr<FrameNode>& dragFrameNode) const;
139     bool CheckInRichEditor(const RefPtr<FrameNode>& dragFrameNode) const;
140     void RequireSummary();
141     void ClearSummary();
SetSummaryMap(const std::map<std::string,int64_t> & summaryMap)142     void SetSummaryMap(const std::map<std::string, int64_t>& summaryMap)
143     {
144         summaryMap_ = summaryMap;
145     }
146     void ResetRecordSize(uint32_t recordSize = 0);
147     uint32_t GetRecordSize() const;
148     Rect GetDragWindowRect(const Point& point);
149     RefPtr<DragDropProxy> CreateFrameworkDragDropProxy();
150     void HideDragPreviewOverlay();
151     void HideDragPreviewWindow(int32_t containerId);
152     bool IsMSDPDragging() const;
153     void UpdateDragEvent(RefPtr<OHOS::Ace::DragEvent>& event, const OHOS::Ace::DragPointerEvent& pointerEvent);
154     void UpdateNotifyDragEvent(
155         RefPtr<NotifyDragEvent>& notifyEvent, const Point& point, const DragEventType dragEventType);
156     bool CheckDragDropProxy(int64_t id) const;
157     void NotifyEnterTextEditorArea();
158     void FireOnEditableTextComponent(const RefPtr<FrameNode>& frameNode, DragEventType type);
159     void FireOnDragLeave(const RefPtr<FrameNode>& preTargetFrameNode_, const DragPointerEvent& pointerEvent,
160         const std::string& extraInfo);
161 
IsWindowConsumed()162     bool IsWindowConsumed() const
163     {
164         return isWindowConsumed_;
165     }
166 
SetIsWindowConsumed(bool consumed)167     void SetIsWindowConsumed(bool consumed)
168     {
169         isWindowConsumed_ = consumed;
170     }
171 
IsDragged()172     bool IsDragged() const
173     {
174         return isDragged_;
175     }
176 
177     void SetIsDragged(bool isDragged);
178 
SetDragDampStartPoint(const Point & point)179     void SetDragDampStartPoint(const Point& point)
180     {
181         dragDampStartPoint_ = point;
182     }
183 
GetDragDampStartPoint()184     const Point& GetDragDampStartPoint() const
185     {
186         return dragDampStartPoint_;
187     }
188 
SetIsDragCancel(bool isDragCancel)189     void SetIsDragCancel(bool isDragCancel)
190     {
191         isDragCancel_ = isDragCancel;
192     }
193 
SetIsMouseDrag(bool isMouseDragged)194     void SetIsMouseDrag(bool isMouseDragged)
195     {
196         isMouseDragged_ = isMouseDragged;
197     }
198 
SetIsDragWindowShow(bool isDragWindowShow)199     void SetIsDragWindowShow(bool isDragWindowShow)
200     {
201         isDragWindowShow_ = isDragWindowShow;
202     }
203 
IsDragWindowShow()204     bool IsDragWindowShow() const
205     {
206         return isDragWindowShow_;
207     }
208 
SetPreviewRect(const Rect & rect)209     void SetPreviewRect(const Rect& rect)
210     {
211         previewRect_ = rect;
212     }
213 
GetPreviewRect()214     Rect GetPreviewRect() const
215     {
216         return previewRect_;
217     }
218 
SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)219     void SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)
220     {
221         dragCursorStyleCore_ = dragCursorStyleCore;
222     }
223 
GetDragAction()224     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> GetDragAction()
225     {
226         return dragAction_;
227     }
228 
229     RefPtr<FrameNode> FindTargetInChildNodes(const RefPtr<UINode> parentNode,
230         std::vector<RefPtr<FrameNode>> hitFrameNodes, bool findDrop);
231 
232     bool CheckFrameNodeCanDrop(const RefPtr<FrameNode>& node);
233 
234     RefPtr<FrameNode> FindTargetDropNode(const RefPtr<UINode> parentNode, PointF localPoint);
235 
236     std::unordered_set<int32_t> FindHitFrameNodes(const Point& point);
237 
238     void UpdateDragListener(const Point& point);
239 
240     void NotifyDragRegisterFrameNode(std::unordered_map<int32_t, WeakPtr<FrameNode>> nodes, DragEventType dragEventType,
241         RefPtr<NotifyDragEvent>& notifyEvent);
242 
243     void RegisterDragStatusListener(int32_t nodeId, const WeakPtr<FrameNode>& node);
244 
UnRegisterDragStatusListener(int32_t nodeId)245     void UnRegisterDragStatusListener(int32_t nodeId)
246     {
247         nodesForDragNotify_.erase(nodeId);
248     }
249 
SetNotifyInDraggedCallback(const std::function<void (void)> & callback)250     void SetNotifyInDraggedCallback(const std::function<void(void)>& callback)
251     {
252         notifyInDraggedCallback_ = callback;
253     }
254 
IsDragging()255     bool IsDragging() const
256     {
257         return dragDropState_ == DragDropMgrState::DRAGGING;
258     }
259 
IsItemDragging()260     bool IsItemDragging() const
261     {
262         return dragDropState_ == DragDropMgrState::DRAGGING && draggedGridFrameNode_ != nullptr;
263     }
264 
IsAboutToPreview()265     bool IsAboutToPreview() const
266     {
267         return dragDropState_ == DragDropMgrState::ABOUT_TO_PREVIEW;
268     }
269 
270     void ResetDragging(DragDropMgrState dragDropMgrState = DragDropMgrState::IDLE)
271     {
272         dragDropState_ = dragDropMgrState;
273     }
274 
275     void ResetPreTargetFrameNode(int32_t instanceId);
276 
SetDraggingPressedState(bool pointerPressed)277     void SetDraggingPressedState(bool pointerPressed)
278     {
279         draggingPressedState_ = pointerPressed;
280     }
281 
282     bool IsDraggingPressed(int32_t currentPointerId) const;
283 
IsSameDraggingPointer(int32_t currentPointerId)284     bool IsSameDraggingPointer(int32_t currentPointerId) const
285     {
286         return currentPointerId_ == currentPointerId;
287     }
288 
SetDraggingPointer(int32_t currentPointerId)289     void SetDraggingPointer(int32_t currentPointerId)
290     {
291         currentPointerId_ = currentPointerId;
292     }
293 
IsEditableTextComponent(const std::string & frameTag)294     static inline bool IsEditableTextComponent(const std::string& frameTag)
295     {
296         if (frameTag != V2::TEXTINPUT_ETS_TAG && frameTag != V2::TEXTAREA_ETS_TAG &&
297             frameTag != V2::RICH_EDITOR_ETS_TAG && frameTag != V2::SEARCH_Field_ETS_TAG) {
298             return false;
299         }
300         return true;
301     }
302 
303     typedef struct DragPreviewInfo {
304         double width { 0.0 };
305         double height { 0.0 };
306         double maxWidth { 0.0 };
307         double scale { -1.0 };
308         VectorF originScale { 1.0f, 1.0f };
309         OffsetF originOffset;
310         RefPtr<FrameNode> imageNode { nullptr };
311         RefPtr<FrameNode> textNode { nullptr };
312     } DragPreviewInfo;
313     bool IsNeedScaleDragPreview();
314     void DoDragMoveAnimate(const DragPointerEvent& pointerEvent);
315     void DragMoveAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager, Point point);
316     void DoDragStartAnimation(const RefPtr<OverlayManager>& overlayManager,
317         const GestureEvent& event, const RefPtr<GestureEventHub>& gestureHub, bool isSubwindowOverlay = false);
318     void DragStartAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager,
319         const OffsetF& gatherNodeCenter, Point point = { 1, 1 });
320     void SetDragResult(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
321     void SetDragBehavior(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
ResetDragPreviewInfo()322     void ResetDragPreviewInfo()
323     {
324         info_ = DragPreviewInfo();
325     }
326 
327     void ResetPullMoveReceivedForCurrentDrag(bool isPullMoveReceivedForCurrentDrag = false)
328     {
329         isPullMoveReceivedForCurrentDrag_ = isPullMoveReceivedForCurrentDrag;
330     }
331 
IsPullMoveReceivedForCurrentDrag()332     bool IsPullMoveReceivedForCurrentDrag() const
333     {
334         return isPullMoveReceivedForCurrentDrag_;
335     }
336 
SetPrepareDragFrameNode(const WeakPtr<FrameNode> & prepareDragFrameNode)337     void SetPrepareDragFrameNode(const WeakPtr<FrameNode>& prepareDragFrameNode)
338     {
339         prepareDragFrameNode_ = prepareDragFrameNode;
340     }
341 
GetPrepareDragFrameNode()342     const WeakPtr<FrameNode> GetPrepareDragFrameNode() const
343     {
344         return prepareDragFrameNode_;
345     }
346 
SetPreDragStatus(PreDragStatus preDragStatus)347     void SetPreDragStatus(PreDragStatus preDragStatus)
348     {
349         preDragStatus_ = preDragStatus;
350     }
351 
GetPreDragStatus()352     PreDragStatus GetPreDragStatus() const
353     {
354         return preDragStatus_;
355     }
356 
357     static RectF GetMenuPreviewRect();
358     static void UpdateGatherNodeAttr(const RefPtr<OverlayManager>& overlayManager, const GatherAnimationInfo& info);
359     static void UpdateGatherNodePosition(const RefPtr<OverlayManager>& overlayManager,
360         const RefPtr<FrameNode>& imageNode);
361     static void UpdateTextNodePosition(const RefPtr<FrameNode>& textNode, const Offset& localPoint);
362     double CalcGatherNodeMaxDistanceWithPoint(const RefPtr<OverlayManager>& overlayManager, int32_t x, int32_t y);
363 
SetPixelMapOffset(OffsetF pixelMapOffset)364     void SetPixelMapOffset(OffsetF pixelMapOffset)
365     {
366         pixelMapOffset_ = pixelMapOffset;
367     }
368 
369     bool IsNeedDisplayInSubwindow();
ClearGatherPixelMap()370     void ClearGatherPixelMap()
371     {
372         gatherPixelMaps_.clear();
373     }
374 
375     void PushGatherPixelMap(const RefPtr<PixelMap>& pixelMap);
376     void GetGatherPixelMap(DragDataCore& dragData, float scale, float previewWidth = 0.0f, float previewHeight = 0.0f);
HasGatherNode()377     bool HasGatherNode() const
378     {
379         return hasGatherNode_;
380     }
381 
SetHasGatherNode(bool hasGatherNode)382     void SetHasGatherNode(bool hasGatherNode)
383     {
384         hasGatherNode_ = hasGatherNode;
385     }
386 
GetDragDropPointerEvent()387     const DragPointerEvent& GetDragDropPointerEvent() const
388     {
389         return dragDropPointerEvent_;
390     }
391 
SetDragDropPointerEvent(const DragPointerEvent & dragDropPointerEvent)392     void SetDragDropPointerEvent(const DragPointerEvent& dragDropPointerEvent)
393     {
394         dragDropPointerEvent_ = dragDropPointerEvent;
395     }
396 
SetIsShowBadgeAnimation(bool isShowBadgeAnimation)397     void SetIsShowBadgeAnimation(bool isShowBadgeAnimation)
398     {
399         isShowBadgeAnimation_ = isShowBadgeAnimation;
400     }
401 
IsShowBadgeAnimation()402     bool IsShowBadgeAnimation()
403     {
404         return isShowBadgeAnimation_;
405     }
406 
IsDragWithContextMenu()407     bool IsDragWithContextMenu() const
408     {
409         return isDragWithContextMenu_;
410     }
411 
SetIsDragWithContextMenu(bool isDragWithContextMenu)412     void SetIsDragWithContextMenu(bool isDragWithContextMenu)
413     {
414         isDragWithContextMenu_ = isDragWithContextMenu;
415     }
416 
417     void SetIsDragNodeNeedClean(bool isDragNodeNeedClean = false)
418     {
419         isDragNodeNeedClean_ = isDragNodeNeedClean;
420     }
421 
IsDragNodeNeedClean()422     bool IsDragNodeNeedClean() const
423     {
424         return isDragNodeNeedClean_;
425     }
426 
427     void UpdateDragMovePosition(const NG::OffsetF& offset, bool isRedragStart = false);
428 
429     void ResetContextMenuDragPosition();
430 
431     void ResetContextMenuRedragPosition();
432 
GetUpdateDragMovePosition()433     OffsetF GetUpdateDragMovePosition() const
434     {
435         return dragTotalMovePosition_;
436     }
437 
438     bool IsDropAllowed(const RefPtr<FrameNode>& dragFrameNode);
439 
SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> & dragAction)440     void SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction>& dragAction)
441     {
442         dragAction_ = dragAction;
443     }
444 
445     void AddNewDragAnimation();
446 
447     bool IsAllAnimationFinished();
448 
449     float GetCurrentDistance(float x, float y);
450 
451     static double GetMaxWidthBaseOnGridSystem(const RefPtr<PipelineBase>& pipeline);
452 
GetDampingOverflowCount()453     uint32_t GetDampingOverflowCount() const
454     {
455         return dampingOverflowCount_ ;
456     }
457 
SetDampingOverflowCount()458     void SetDampingOverflowCount()
459     {
460         dampingOverflowCount_++;
461     }
462 
GetMenuWrapperNode()463     RefPtr<FrameNode> GetMenuWrapperNode()
464     {
465         return menuWrapperNode_.Upgrade();
466     }
467 
SetMenuWrapperNode(const RefPtr<FrameNode> & frameNode)468     void SetMenuWrapperNode(const RefPtr<FrameNode>& frameNode)
469     {
470         menuWrapperNode_ = frameNode;
471     }
472 
473     bool CheckIsNewDrag(const DragPointerEvent& pointerEvent) const;
474 
475     void RequireSummaryIfNecessary(const DragPointerEvent& pointerEvent);
476 
ResetPullId()477     inline void ResetPullId()
478     {
479         summaryMap_.clear();
480         parentHitNodes_.clear();
481         currentPullId_ = -1;
482     }
483 
484     void ResetDraggingStatus(const TouchEvent& touchPoint);
485 
486     int32_t CancelUDMFDataLoading(const std::string& key);
487 
488 private:
489     double CalcDragPreviewDistanceWithPoint(
490         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
491     Offset CalcDragMoveOffset(
492         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
493     bool UpdateDragMovePositionFinished(
494         bool needDoDragMoveAnimate, bool isMenuShow, const Offset& newOffset, int32_t containerId);
495     void UpdateDragPreviewScale();
496     bool GetDragPreviewInfo(const OHOS::Ace::RefPtr<OHOS::Ace::NG::OverlayManager>& overlayManager,
497         DragPreviewInfo& dragPreviewInfo, const RefPtr<GestureEventHub>& gestureHub);
498     bool IsNeedDoDragMoveAnimate(const DragPointerEvent& pointerEvent);
499     const RefPtr<NG::OverlayManager> GetDragAnimationOverlayManager(int32_t containerId);
500     RefPtr<FrameNode> FindDragFrameNodeByPosition(float globalX, float globalY,
501         const RefPtr<FrameNode>& node = nullptr);
502     void FireOnDragEvent(
503         const RefPtr<FrameNode>& frameNode, const DragPointerEvent& pointerEvent,
504         DragEventType type, const std::string& extraInfo);
505     void FireOnItemDragEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
506         const ItemDragInfo& itemDragInfo, DragEventType type, int32_t draggedIndex, int32_t insertIndex = 0);
507     bool FireOnItemDropEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
508         const ItemDragInfo& itemDragInfo, int32_t draggedIndex, int32_t insertIndex, bool isSuccess);
509     int32_t GetItemIndex(const RefPtr<FrameNode>& frameNode, DragType dragType, float globalX, float globalY);
510     void CreateDragWindow(const GestureEvent& info, uint32_t width, uint32_t height);
511     RefPtr<FrameNode> CreateDragRootNode(const RefPtr<UINode>& customNode);
512     void ClearVelocityInfo();
513     void UpdateVelocityTrackerPoint(const Point& point, bool isEnd = false);
514     void PrintDragFrameNode(const OHOS::Ace::DragPointerEvent& pointerEvent, const RefPtr<FrameNode>& dragFrameNode);
515     void PrintGridDragFrameNode(const float globalX, const float globalY, const RefPtr<FrameNode>& dragFrameNode);
516     void FireOnDragEventWithDragType(const RefPtr<EventHub>& eventHub, DragEventType type,
517         RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
518     void NotifyDragFrameNode(
519         const Point& point, const DragEventType& dragEventType, const DragRet& dragRet = DragRet::DRAG_DEFAULT);
520     void TransDragWindowToDragFwk(int32_t windowContainerId);
521     void ResetDragDrop(int32_t windowId, const Point& point);
522     bool isDistanceLimited(const Point& point);
523     bool isTimeLimited(const DragPointerEvent& pointerEvent, const Point& point);
524     bool ReachMoveLimit(const DragPointerEvent& pointerEvent, const Point& point);
525     bool IsUIExtensionShowPlaceholder(const RefPtr<NG::UINode>& node);
526     bool IsUIExtensionComponent(const RefPtr<NG::UINode>& node);
527     int32_t GetWindowId();
528     void AddItemDrag(const RefPtr<FrameNode>& frameNode, const RefPtr<EventHub>& eventHub);
529     void RemoveItemDrag();
530 
531     std::map<int32_t, WeakPtr<FrameNode>> dragFrameNodes_;
532     std::map<int32_t, WeakPtr<FrameNode>> gridDragFrameNodes_;
533     std::map<int32_t, WeakPtr<FrameNode>> listDragFrameNodes_;
534     std::map<int32_t, WeakPtr<FrameNode>> textFieldDragFrameNodes_;
535     RefPtr<FrameNode> draggedFrameNode_;
536     RefPtr<FrameNode> preTargetFrameNode_;
537     RefPtr<FrameNode> draggedGridFrameNode_;
538     RefPtr<FrameNode> preGridTargetFrameNode_;
539     RefPtr<FrameNode> itemDragOverlayNode_;
540     RefPtr<Clipboard> clipboard_;
541     Point preMovePoint_ = Point(0, 0);
542     uint64_t preTimeStamp_ = 0L;
543     WeakPtr<FrameNode> prepareDragFrameNode_;
544     std::function<void(const std::string&)> addDataCallback_ = nullptr;
545     std::function<void(const std::string&)> getDataCallback_ = nullptr;
546     std::function<void(const std::string&)> deleteDataCallback_ = nullptr;
547     std::string extraInfo_;
548     std::unique_ptr<JsonValue> newData_ = nullptr;
549     bool isDragCancel_ = false;
550     std::unordered_map<int32_t, WeakPtr<FrameNode>> nodesForDragNotify_;
551     std::unordered_set<int32_t> parentHitNodes_;
552     DragCursorStyleCore dragCursorStyleCore_ = DragCursorStyleCore::DEFAULT;
553     std::map<std::string, int64_t> summaryMap_;
554     uint32_t recordSize_ = 0;
555     int64_t currentId_ = -1;
556     int32_t currentPointerId_ = -1;
557     int32_t currentPullId_ = -1;
558     bool draggingPressedState_ = false;
559 
560     std::function<void(void)> notifyInDraggedCallback_ = nullptr;
561     bool isDragged_ = false;
562     bool isMouseDragged_ = false;
563     bool isWindowConsumed_ = false;
564     bool isDragWindowShow_ = false;
565     bool hasNotifiedTransformation_ = false;
566     bool isPullMoveReceivedForCurrentDrag_ = false;
567     bool isDragWindowSubWindow_ = false;
568     bool isDragNodeNeedClean_ = false;
569     VelocityTracker velocityTracker_;
570     PreDragStatus preDragStatus_ = PreDragStatus::ACTION_DETECTING_STATUS;
571     Rect previewRect_ { -1, -1, -1, -1 };
572     DragDropMgrState dragDropState_ = DragDropMgrState::IDLE;
573     DragPreviewInfo info_;
574     DragPointerEvent dragDropPointerEvent_;
575     bool isDragFwkShow_ = true;
576     OffsetF pixelMapOffset_;
577     OffsetF curPointerOffset_;
578     std::vector<RefPtr<PixelMap>> gatherPixelMaps_;
579     bool hasGatherNode_ = false;
580     bool isShowBadgeAnimation_ = true;
581     bool eventStrictReportingEnabled_ = false;
582     int32_t badgeNumber_ = -1;
583     int32_t currentAnimationCnt_ = 0;
584     int32_t allAnimationCnt_ = 0;
585     bool isDragWithContextMenu_ = false;
586     Point dragDampStartPoint_ { 1, 1 };
587     OffsetF dragMovePosition_ = OffsetF(0.0f, 0.0f);
588     OffsetF lastDragMovePosition_ = OffsetF(0.0f, 0.0f);
589     OffsetF dragTotalMovePosition_ = OffsetF(0.0f, 0.0f);
590     RefPtr<GridColumnInfo> columnInfo_;
591     uint32_t dampingOverflowCount_ = 0;
592     WeakPtr<FrameNode> menuWrapperNode_;
593     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> dragAction_;
594 
595     ACE_DISALLOW_COPY_AND_MOVE(DragDropManager);
596 };
597 } // namespace OHOS::Ace::NG
598 
599 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
600