• 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/clipboard/clipboard.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/components_ng/manager/drag_drop/utils/internal_drag_action.h"
29 #include "core/event/pointer_event.h"
30 #include "core/gestures/velocity_tracker.h"
31 
32 namespace OHOS::Ace {
33 class UnifiedData;
34 class GridColumnInfo;
35 }
36 namespace OHOS::Ace::NG {
37 enum class DragDropMgrState : int32_t {
38     IDLE,
39     ABOUT_TO_PREVIEW,
40     DRAGGING
41 };
42 
43 struct GatherAnimationInfo {
44     float scale = 0.0f;
45     float width = 0.0f;
46     float height = 0.0f;
47     OffsetF gatherNodeCenter;
48     std::optional<BorderRadiusProperty> borderRadius;
49 };
50 
51 struct ScaleDataInfo {
52     bool isNeedScale = false;
53     double scale = 1.0f;
54     float shortSide = 0.0f;
55 };
56 
57 class ACE_EXPORT DragDropManager : public virtual AceType {
58     DECLARE_ACE_TYPE(DragDropManager, AceType);
59 
60 public:
61     DragDropManager();
62     ~DragDropManager() override = default;
63 
64     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
65         const RefPtr<PixelMap>& pixelMap, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
66     RefPtr<DragDropProxy> CreateAndShowItemDragOverlay(
67         const RefPtr<UINode>& customNode, const GestureEvent& info, const RefPtr<EventHub>& eventHub);
68     RefPtr<DragDropProxy> CreateTextDragDropProxy();
69 
AddDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)70     void AddDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
71     {
72         dragFrameNodes_.try_emplace(id, dragFrameNode);
73     }
74 
75     void RemoveDragFrameNode(int32_t id);
76 
AddGridDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)77     void AddGridDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
78     {
79         gridDragFrameNodes_.try_emplace(id, dragFrameNode);
80     }
81 
AddListDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)82     void AddListDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
83     {
84         listDragFrameNodes_.try_emplace(id, dragFrameNode);
85     }
86 
AddTextFieldDragFrameNode(int32_t id,const WeakPtr<FrameNode> & dragFrameNode)87     void AddTextFieldDragFrameNode(int32_t id, const WeakPtr<FrameNode>& dragFrameNode)
88     {
89         textFieldDragFrameNodes_.try_emplace(id, dragFrameNode);
90     }
91 
SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)92     void SetEventStrictReportingEnabled(bool dragEventStrictReportingEnabled)
93     {
94         eventStrictReportingEnabled_ = dragEventStrictReportingEnabled;
95     }
96 
IsEventStrictReportingEnabled()97     bool IsEventStrictReportingEnabled()
98     {
99         return eventStrictReportingEnabled_;
100     }
101 
GetCurrentAnimationCnt()102     int32_t GetCurrentAnimationCnt() const
103     {
104         return currentAnimationCnt_;
105     }
106 
SetCurrentAnimationCnt(int32_t value)107     void SetCurrentAnimationCnt(int32_t value)
108     {
109         currentAnimationCnt_ = value;
110     }
111 
GetAllAnimationCnt()112     int32_t GetAllAnimationCnt() const
113     {
114         return allAnimationCnt_;
115     }
116 
SetAllAnimationCnt(int32_t value)117     void SetAllAnimationCnt(int32_t value)
118     {
119         allAnimationCnt_ = value;
120     }
121 
122     void UpdateItemDragPosition(int32_t globalX, int32_t globalY);
123     void OnDragStart(const Point& point);
124     void OnDragStart(const Point& point, const RefPtr<FrameNode>& frameNode);
125     void OnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
126         const RefPtr<FrameNode>& node = nullptr);
127     void OnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
128         const RefPtr<FrameNode>& node = nullptr, const bool keyEscape = false);
129     bool HandleUIExtensionComponentDragCancel(const RefPtr<FrameNode>& preTargetFrameNode,
130         const RefPtr<FrameNode>& dragFrameNode, const bool keyEscape, const DragPointerEvent& pointerEvent,
131         const Point& point);
132     void OnDragPullCancel(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
133         const RefPtr<FrameNode>& node = nullptr);
134     void HandleOnDragMove(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
135         const RefPtr<FrameNode>& dragFrameNode);
136     void HandleOnDragEnd(const DragPointerEvent& pointerEvent, const std::string& extraInfo,
137         const RefPtr<FrameNode>& dragFrameNode);
138     void ResetDragEndOption(
139         const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent, int32_t currentId);
140     void DoDragReset();
141     void DoDropAction(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
142         const RefPtr<UnifiedData>& unifiedData, const std::string& udKey);
143     void RequestDragSummaryInfoAndPrivilege();
144     RefPtr<UnifiedData> RequestUDMFDataWithUDKey(const std::string& udKey);
145     void TryGetDataBackGround(
146         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
147         const std::string& udKey, int32_t count = 0);
148     void OnDragDrop(RefPtr<OHOS::Ace::DragEvent>& event, const RefPtr<FrameNode>& dragFrameNode,
149         const OHOS::Ace::DragPointerEvent& pointerEvent);
150     std::function<void(const DragRet&)> GetStopDragCallBack(const RefPtr<FrameNode>& dragFrameNode,
151         const DragPointerEvent& pointerEvent, const RefPtr<OHOS::Ace::DragEvent>& event,
152         const std::string& extraParams);
153     bool PostStopDrag(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
154         const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
155     void HandleStopDrag(const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent,
156         const RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
157     void ExecuteStopDrag(const RefPtr<OHOS::Ace::DragEvent>& event, DragRet dragResult, bool useCustomAnimation,
158         int32_t windowId, DragBehavior dragBehavior, const OHOS::Ace::DragPointerEvent& pointerEvent);
159     void ExecuteCustomDropAnimation(const RefPtr<OHOS::Ace::DragEvent>& dragEvent, DragDropRet dragDropRet);
160     void ResetDragDropStatus(const Point& point, const DragDropRet& dragDropRet, int32_t windowId);
161     bool CheckRemoteData(
162         const RefPtr<FrameNode>& dragFrameNode, const DragPointerEvent& pointerEvent, const std::string& udKey);
163     void OnDragMoveOut(const DragPointerEvent& pointerEvent);
164     void OnTextDragEnd(float globalX, float globalY, const std::string& extraInfo);
165     void onDragCancel();
166     void OnItemDragStart(float globalX, float globalY, const RefPtr<FrameNode>& frameNode);
167     void OnItemDragMove(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
168     void OnItemDragEnd(float globalX, float globalY, int32_t draggedIndex, DragType dragType);
169     void onItemDragCancel();
170     void AddDataToClipboard(const std::string& extraInfo);
171     void GetExtraInfoFromClipboard(std::string& extraInfo);
172     void RestoreClipboardData();
173     void DestroyDragWindow();
174     void CancelItemDrag();
175     std::string GetExtraInfo();
176     void SetExtraInfo(const std::string& extraInfo);
177     void ClearExtraInfo();
178     float GetWindowScale() const;
179     void UpdateDragCursorStyle(const RefPtr<FrameNode>& frameNode, const RefPtr<OHOS::Ace::DragEvent>& event,
180         const int32_t eventId = -1);
181     void UpdateDragStyle(
182         const DragCursorStyleCore& dragCursorStyleCore = DragCursorStyleCore::DEFAULT, const int32_t eventId = -1);
183     void UpdateDragAllowDrop(const RefPtr<FrameNode>& dragFrameNode, const DragBehavior dragBehavior,
184         const int32_t eventId = -1, bool isCapi = false);
185     bool CheckExtraSituation(const RefPtr<FrameNode>& dragFrameNode) const;
186     bool CheckInRichEditor(const RefPtr<FrameNode>& dragFrameNode) const;
187     void RequireSummary();
188     void ClearSummary();
SetSummaryMap(const std::map<std::string,int64_t> & summaryMap)189     void SetSummaryMap(const std::map<std::string, int64_t>& summaryMap)
190     {
191         summaryMap_ = summaryMap;
192     }
193     void ResetRecordSize(uint32_t recordSize = 0);
194     uint32_t GetRecordSize() const;
195     Rect GetDragWindowRect(const Point& point);
196     RefPtr<DragDropProxy> CreateFrameworkDragDropProxy();
197     void HideDragPreviewOverlay();
198     void HideDragPreviewWindow(int32_t containerId);
199     bool IsMSDPDragging() const;
200     void UpdateDragEvent(RefPtr<OHOS::Ace::DragEvent>& event, const OHOS::Ace::DragPointerEvent& pointerEvent);
201     void UpdateNotifyDragEvent(
202         RefPtr<NotifyDragEvent>& notifyEvent, const Point& point, const DragEventType dragEventType);
203     bool CheckDragDropProxy(int64_t id) const;
204     void NotifyEnterTextEditorArea();
205     void FireOnEditableTextComponent(const RefPtr<FrameNode>& frameNode, DragEventType type);
206     void FireOnDragLeave(const RefPtr<FrameNode>& preTargetFrameNode_, const DragPointerEvent& pointerEven,
207         const std::string& extraInfo);
208 
IsWindowConsumed()209     bool IsWindowConsumed() const
210     {
211         return isWindowConsumed_;
212     }
213 
SetIsWindowConsumed(bool consumed)214     void SetIsWindowConsumed(bool consumed)
215     {
216         isWindowConsumed_ = consumed;
217     }
218 
IsDragged()219     bool IsDragged() const
220     {
221         return isDragged_;
222     }
223 
224     void SetIsDragged(bool isDragged);
225 
SetDragDampStartPoint(const Point & point)226     void SetDragDampStartPoint(const Point& point)
227     {
228         dragDampStartPoint_ = point;
229     }
230 
GetDragDampStartPoint()231     const Point& GetDragDampStartPoint() const
232     {
233         return dragDampStartPoint_;
234     }
235 
SetIsDragCancel(bool isDragCancel)236     void SetIsDragCancel(bool isDragCancel)
237     {
238         isDragCancel_ = isDragCancel;
239     }
240 
IsMouseDrag()241     bool IsMouseDrag() const
242     {
243         return isMouseDragged_;
244     }
245 
SetIsMouseDrag(bool isMouseDragged)246     void SetIsMouseDrag(bool isMouseDragged)
247     {
248         isMouseDragged_ = isMouseDragged;
249     }
250 
SetIsDragWindowShow(bool isDragWindowShow)251     void SetIsDragWindowShow(bool isDragWindowShow)
252     {
253         isDragWindowShow_ = isDragWindowShow;
254     }
255 
IsDragWindowShow()256     bool IsDragWindowShow() const
257     {
258         return isDragWindowShow_;
259     }
260 
SetPreviewRect(const Rect & rect)261     void SetPreviewRect(const Rect& rect)
262     {
263         previewRect_ = rect;
264     }
265 
GetPreviewRect()266     Rect GetPreviewRect() const
267     {
268         return previewRect_;
269     }
270 
SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)271     void SetDragCursorStyleCore(DragCursorStyleCore dragCursorStyleCore)
272     {
273         dragCursorStyleCore_ = dragCursorStyleCore;
274     }
275 
GetDragAction()276     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> GetDragAction()
277     {
278         return dragAction_;
279     }
280 
281     RefPtr<FrameNode> FindTargetInChildNodes(const RefPtr<UINode> parentNode,
282         std::vector<RefPtr<FrameNode>> hitFrameNodes, bool findDrop);
283 
284     bool CheckFrameNodeCanDrop(const RefPtr<FrameNode>& node);
285 
286     RefPtr<FrameNode> FindTargetDropNode(const RefPtr<UINode> parentNode, PointF localPoint);
287 
288     std::unordered_set<int32_t> FindHitFrameNodes(const Point& point);
289 
290     void UpdateDragListener(const Point& point);
291 
292     void NotifyDragRegisterFrameNode(std::unordered_map<int32_t, WeakPtr<FrameNode>> nodes, DragEventType dragEventType,
293         RefPtr<NotifyDragEvent>& notifyEvent);
294 
295     void RegisterDragStatusListener(int32_t nodeId, const WeakPtr<FrameNode>& node);
296 
UnRegisterDragStatusListener(int32_t nodeId)297     void UnRegisterDragStatusListener(int32_t nodeId)
298     {
299         nodesForDragNotify_.erase(nodeId);
300     }
301 
302     void RegisterPullEventListener(int32_t uniqueIdentify, std::function<void(const DragPointerEvent&)> callback);
303 
304     void UnRegisterPullEventListener(int32_t uniqueIdentify);
305 
306     void NotifyPullEventListener(const DragPointerEvent& dragPointerEvent);
307 
SetNotifyInDraggedCallback(const std::function<void (void)> & callback)308     void SetNotifyInDraggedCallback(const std::function<void(void)>& callback)
309     {
310         notifyInDraggedCallback_ = callback;
311     }
312 
IsDragging()313     bool IsDragging() const
314     {
315         return dragDropState_ == DragDropMgrState::DRAGGING;
316     }
317 
IsItemDragging()318     bool IsItemDragging() const
319     {
320         return dragDropState_ == DragDropMgrState::DRAGGING && draggedGridFrameNode_ != nullptr;
321     }
322 
IsAboutToPreview()323     bool IsAboutToPreview() const
324     {
325         return dragDropState_ == DragDropMgrState::ABOUT_TO_PREVIEW;
326     }
327 
328     void ResetDragging(DragDropMgrState dragDropMgrState = DragDropMgrState::IDLE)
329     {
330         dragDropState_ = dragDropMgrState;
331     }
332 
333     void ResetPreTargetFrameNode(int32_t instanceId);
334 
SetDraggingPressedState(bool pointerPressed)335     void SetDraggingPressedState(bool pointerPressed)
336     {
337         draggingPressedState_ = pointerPressed;
338     }
339 
340     bool IsDraggingPressed(int32_t currentPointerId) const;
341 
IsSameDraggingPointer(int32_t currentPointerId)342     bool IsSameDraggingPointer(int32_t currentPointerId) const
343     {
344         return currentPointerId_ == currentPointerId;
345     }
346 
SetDraggingPointer(int32_t currentPointerId)347     void SetDraggingPointer(int32_t currentPointerId)
348     {
349         currentPointerId_ = currentPointerId;
350     }
351 
IsEditableTextComponent(const std::string & frameTag)352     static inline bool IsEditableTextComponent(const std::string& frameTag)
353     {
354         if (frameTag != V2::TEXTINPUT_ETS_TAG && frameTag != V2::TEXTAREA_ETS_TAG &&
355             frameTag != V2::RICH_EDITOR_ETS_TAG && frameTag != V2::SEARCH_Field_ETS_TAG) {
356             return false;
357         }
358         return true;
359     }
360 
361     typedef struct DragPreviewInfo {
362         double width { 0.0 };
363         double height { 0.0 };
364         double maxWidth { 0.0 };
365         double scale { -1.0 };
366         VectorF originScale { 1.0f, 1.0f };
367         OffsetF originOffset;
368         RefPtr<FrameNode> imageNode { nullptr };
369         RefPtr<FrameNode> textNode { nullptr };
370         double finalDistanceX;
371         double finalDistanceY;
372         RefPtr<FrameNode> menuPreviewNode { nullptr };
373         RefPtr<FrameNode> relativeContainerNode { nullptr };
374         RectF dragPreviewRect;
375         RectF menuPreviewRect;
376         bool isMenuShow = false;
377     } DragPreviewInfo;
378     bool IsNeedScaleDragPreview();
379     void DoDragMoveAnimate(const DragPointerEvent& pointerEvent);
380     void DragMoveAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager, Point point);
381     void DragMoveTransitionAnimation(const RefPtr<OverlayManager>& overlayManager,
382         const DragPreviewInfo& info, AnimationOption option, const Offset& newOffset);
383     void DoDragStartAnimation(const RefPtr<OverlayManager>& overlayManager,
384         const GestureEvent& event, const RefPtr<GestureEventHub>& gestureHub, PreparedInfoForDrag& data);
385     void DragStartAnimation(const Offset& newOffset, const RefPtr<OverlayManager>& overlayManager,
386         const OffsetF& gatherNodeCenter, PreparedInfoForDrag& data, Point point = { 1, 1 });
387     void SetDragStartAnimationOption(AnimationOption& option, int32_t containerId);
388     void HandleStartDragAnimationFinish(int32_t containerId);
389     void DragAnimationCurve(RefPtr<Curve> curve);
390     void DragStartTransitionAnimation(
391         PreparedInfoForDrag& data, const Offset& newOffset, const DragPreviewInfo& info, AnimationOption option);
392     void SetDragResult(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
393     void SetDragBehavior(const DragNotifyMsgCore& notifyMessage, const RefPtr<OHOS::Ace::DragEvent>& dragEvent);
ResetDragPreviewInfo()394     void ResetDragPreviewInfo()
395     {
396         info_ = DragPreviewInfo();
397     }
398 
SetDragPreviewInfo(const DragPreviewInfo & newInfo)399     void SetDragPreviewInfo(const DragPreviewInfo& newInfo)
400     {
401         info_ = newInfo;
402     }
403 
GetDragPreviewInfo()404     DragPreviewInfo GetDragPreviewInfo() const
405     {
406         return info_;
407     }
408 
409     void ResetPullMoveReceivedForCurrentDrag(bool isPullMoveReceivedForCurrentDrag = false)
410     {
411         isPullMoveReceivedForCurrentDrag_ = isPullMoveReceivedForCurrentDrag;
412     }
413 
IsPullMoveReceivedForCurrentDrag()414     bool IsPullMoveReceivedForCurrentDrag() const
415     {
416         return isPullMoveReceivedForCurrentDrag_;
417     }
418 
419     void RemoveDeadlineTimer();
420 
421     void ExecuteDeadlineTimer();
422 
423     void HandleSyncOnDragStart(DragStartRequestStatus dragStartRequestStatus);
424 
425     const Point GetDragMoveLastPointByCurrentPointer(int32_t pointerId);
426 
427     void SetDelayDragCallBack(const std::function<void()>& cb) noexcept;
428 
IsStartAnimationFInished()429     bool IsStartAnimationFInished() const
430     {
431         return isStartAnimationFinished_;
432     }
433 
SetStartAnimation(bool flag)434     void SetStartAnimation(bool flag)
435     {
436         isStartAnimationFinished_ = flag;
437     }
438 
GetStartAnimationStates()439     bool GetStartAnimationStates()
440     {
441         animationStates_ = !animationStates_;
442         return animationStates_;
443     }
444 
445     static OffsetF GetTouchOffsetRelativeToSubwindow(int32_t containerId, int32_t x = 0, int32_t y = 0);
446     static RectF GetMenuPreviewRect();
447     static void UpdateGatherNodeAttr(const RefPtr<OverlayManager>& overlayManager, const GatherAnimationInfo& info);
448     static void UpdateGatherNodePosition(const RefPtr<OverlayManager>& overlayManager,
449         const RefPtr<FrameNode>& imageNode);
450     static void UpdateTextNodePosition(const RefPtr<FrameNode>& textNode, const Offset& localPoint);
451     double CalcGatherNodeMaxDistanceWithPoint(const RefPtr<OverlayManager>& overlayManager, int32_t x, int32_t y);
452 
SetPixelMapOffset(OffsetF pixelMapOffset)453     void SetPixelMapOffset(OffsetF pixelMapOffset)
454     {
455         pixelMapOffset_ = pixelMapOffset;
456     }
457 
GetPixelMapOffset()458     OffsetF GetPixelMapOffset()
459     {
460         return pixelMapOffset_;
461     }
462 
SetCurPointerOffset(OffsetF curPointerOffset)463     void SetCurPointerOffset(OffsetF curPointerOffset)
464     {
465         curPointerOffset_ = curPointerOffset;
466     }
467 
468     bool IsNeedDisplayInSubwindow();
ClearGatherPixelMap()469     void ClearGatherPixelMap()
470     {
471         gatherPixelMaps_.clear();
472     }
473 
474     void PushGatherPixelMap(const RefPtr<PixelMap>& pixelMap);
475     void GetGatherPixelMap(DragDataCore& dragData, float scale, float previewWidth = 0.0f,
476         float previewHeight = 0.0f);
477 
GetDragDropPointerEvent()478     const DragPointerEvent& GetDragDropPointerEvent() const
479     {
480         return dragDropPointerEvent_;
481     }
482 
SetDragDropPointerEvent(const DragPointerEvent & dragDropPointerEvent)483     void SetDragDropPointerEvent(const DragPointerEvent& dragDropPointerEvent)
484     {
485         dragDropPointerEvent_ = dragDropPointerEvent;
486     }
487 
GetDragAnimationPointerEvent()488     const DragPointerEvent& GetDragAnimationPointerEvent() const
489     {
490         return dragAnimationPointerEvent_;
491     }
492 
SetDragAnimationPointerEvent(const DragPointerEvent & pointerEvent)493     void SetDragAnimationPointerEvent(const DragPointerEvent& pointerEvent)
494     {
495         dragAnimationPointerEvent_ = pointerEvent;
496     }
497 
IsDragFwkShow()498     bool IsDragFwkShow() const
499     {
500         return isDragFwkShow_;
501     }
502 
SetDragFwkShow(bool value)503     void SetDragFwkShow(bool value)
504     {
505         isDragFwkShow_ = value;
506     }
507 
SetIsShowBadgeAnimation(bool isShowBadgeAnimation)508     void SetIsShowBadgeAnimation(bool isShowBadgeAnimation)
509     {
510         isShowBadgeAnimation_ = isShowBadgeAnimation;
511     }
512 
IsShowBadgeAnimation()513     bool IsShowBadgeAnimation()
514     {
515         return isShowBadgeAnimation_;
516     }
517 
IsDragWithContextMenu()518     bool IsDragWithContextMenu() const
519     {
520         return isDragWithContextMenu_;
521     }
522 
SetIsDragWithContextMenu(bool isDragWithContextMenu)523     void SetIsDragWithContextMenu(bool isDragWithContextMenu)
524     {
525         isDragWithContextMenu_ = isDragWithContextMenu;
526     }
527 
528     void SetIsDragNodeNeedClean(bool isDragNodeNeedClean = false)
529     {
530         isDragNodeNeedClean_ = isDragNodeNeedClean;
531     }
532 
IsDragNodeNeedClean()533     bool IsDragNodeNeedClean() const
534     {
535         return isDragNodeNeedClean_;
536     }
537 
538     void UpdateDragMovePosition(const NG::OffsetF& offset, bool isRedragStart = false);
539 
540     void ResetContextMenuDragPosition();
541 
542     void ResetContextMenuRedragPosition();
543 
GetUpdateDragMovePosition()544     OffsetF GetUpdateDragMovePosition() const
545     {
546         return dragTotalMovePosition_;
547     }
548 
549     bool IsDropAllowed(const RefPtr<FrameNode>& dragFrameNode);
550 
SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> & dragAction)551     void SetDragAction(const std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction>& dragAction)
552     {
553         dragAction_ = dragAction;
554     }
555 
556     void AddNewDragAnimation();
557 
558     void AddNewDragStartAnimation();
559 
560     bool IsAllAnimationFinished();
561 
562     bool IsAllStartAnimationFinished();
563 
564     float GetCurrentDistance(float x, float y);
565 
GetDampingOverflowCount()566     uint32_t GetDampingOverflowCount() const
567     {
568         return dampingOverflowCount_;
569     }
570 
SetDampingOverflowCount(uint32_t count)571     void SetDampingOverflowCount(uint32_t count)
572     {
573         dampingOverflowCount_ = count;
574     }
575 
SetDampingOverflowCount()576     void SetDampingOverflowCount()
577     {
578         dampingOverflowCount_++;
579     }
580     static double GetMaxWidthBaseOnGridSystem(const RefPtr<PipelineBase>& pipeline);
581 
582     static std::shared_ptr<ScaleDataInfo> GetScaleInfo(float width, float height, bool textDraggable);
583 
584     static std::shared_ptr<ScaleDataInfo> CalculateScale(
585         float width, float height, float widthLimit, float heightLimit);
586 
GetMenuWrapperNode()587     RefPtr<FrameNode> GetMenuWrapperNode()
588     {
589         return menuWrapperNode_.Upgrade();
590     }
591 
SetMenuWrapperNode(const RefPtr<FrameNode> & frameNode)592     void SetMenuWrapperNode(const RefPtr<FrameNode>& frameNode)
593     {
594         menuWrapperNode_ = frameNode;
595     }
596 
597     bool CheckIsNewDrag(const DragPointerEvent& pointerEvent) const;
598 
599     void RequireSummaryIfNecessary(const DragPointerEvent& pointerEvent);
600 
ResetPullId()601     inline void ResetPullId()
602     {
603         summaryMap_.clear();
604         parentHitNodes_.clear();
605         currentPullId_ = -1;
606     }
607 
608     void SetIsDisableDefaultDropAnimation(bool disableDefaultDropAnimation = false)
609     {
610         disableDefaultDropAnimation_ = disableDefaultDropAnimation;
611     }
612 
IsDisableDefaultDropAnimation()613     bool IsDisableDefaultDropAnimation() const
614     {
615         return disableDefaultDropAnimation_;
616     }
617 
618     void ResetDraggingStatus(const TouchEvent& touchPoint);
619 
SetGrayedState(bool state)620     void SetGrayedState(bool state)
621     {
622         grayedState_ = state;
623     }
624 
GetGrayedState()625     bool GetGrayedState() const
626     {
627         return grayedState_;
628     }
629 
630     void SetIsAnyDraggableHit(bool isAnyDraggableHit = false)
631     {
632         isAnyDraggableHit_ = isAnyDraggableHit;
633     }
634 
635     bool IsAnyDraggableHit(const RefPtr<PipelineBase>& pipeline, int32_t pointId);
636 
637     RefPtr<FrameNode> GetRootNode();
638 
639     int32_t CancelUDMFDataLoading(const std::string& key);
640 
GetPreDragPointerEvent()641     const DragPointerEvent& GetPreDragPointerEvent() const
642     {
643         return preDragPointerEvent_;
644     }
645 
SetIsReDragStart(bool isReDragStart)646     void SetIsReDragStart(bool isReDragStart)
647     {
648         isReDragStart_ = isReDragStart;
649     }
650 
SetDragStartAnimationRate(float rate)651     void SetDragStartAnimationRate(float rate)
652     {
653         dragStartAnimationRate_ = rate;
654     }
655 
656     bool CheckIsFolderSubwindowBoundary(float x, float y, int32_t instanceId);
657 
658     bool CheckIsUIExtensionBoundary(float x, float y, int32_t instanceId);
659 
660     void UpdatePointInfoForFinger(int32_t pointerId, Point point);
661 
662 private:
663     double CalcDragPreviewDistanceWithPoint(
664         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
665     Offset CalcDragMoveOffset(
666         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
667     Offset CalcContentTrationOffset(
668         const OHOS::Ace::Dimension& preserverHeight, int32_t x, int32_t y, const DragPreviewInfo& info);
669     Offset CalculateNewOffset(
670         const RefPtr<FrameNode>& frameNode, const GestureEvent& event, bool isDragStartPending);
671     bool UpdateDragMovePositionFinished(
672         bool needDoDragMoveAnimate, bool isMenuShow, const Offset& newOffset, int32_t containerId);
673     void InitDragAnimationPointerEvent(const GestureEvent& event, bool isDragStartPending);
674     void UpdateDragPreviewScale();
675     bool GetDragPreviewInfo(const OHOS::Ace::RefPtr<OHOS::Ace::NG::OverlayManager>& overlayManager,
676         DragPreviewInfo& dragPreviewInfo, const RefPtr<GestureEventHub>& gestureHub, PreparedInfoForDrag& data);
677     bool IsNeedDoDragMoveAnimate(const DragPointerEvent& pointerEvent);
678     const RefPtr<NG::OverlayManager> GetDragAnimationOverlayManager(int32_t containerId);
679     RefPtr<FrameNode> FindDragFrameNodeByPosition(float globalX, float globalY,
680         const RefPtr<FrameNode>& node = nullptr);
681     RefPtr<FrameNode> FilterSubwindowDragRootNode(const RefPtr<FrameNode>& node);
682     void FireOnDragEvent(
683         const RefPtr<FrameNode>& frameNode, const DragPointerEvent& pointerEvent,
684         DragEventType type, const std::string& extraInfo);
685     void FireOnItemDragEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
686         const ItemDragInfo& itemDragInfo, DragEventType type, int32_t draggedIndex, int32_t insertIndex = 0);
687     bool FireOnItemDropEvent(const RefPtr<FrameNode>& frameNode, DragType dragType,
688         const ItemDragInfo& itemDragInfo, int32_t draggedIndex, int32_t insertIndex, bool isSuccess);
689     int32_t GetItemIndex(const RefPtr<FrameNode>& frameNode, DragType dragType, float globalX, float globalY);
690     void CreateDragWindow(const GestureEvent& info, uint32_t width, uint32_t height);
691     RefPtr<FrameNode> CreateDragRootNode(const RefPtr<UINode>& customNode);
692     void ClearVelocityInfo();
693     void UpdateVelocityTrackerPoint(const Point& point, bool isEnd = false);
694     void PrintDragFrameNode(const OHOS::Ace::DragPointerEvent& pointerEvent, const RefPtr<FrameNode>& dragFrameNode);
695     void PrintGridDragFrameNode(const float globalX, const float globalY, const RefPtr<FrameNode>& dragFrameNode);
696     void FireOnDragEventWithDragType(const RefPtr<EventHub>& eventHub, DragEventType type,
697         RefPtr<OHOS::Ace::DragEvent>& event, const std::string& extraParams);
698     void NotifyDragFrameNode(
699         const Point& point, const DragEventType& dragEventType, const DragRet& dragRet = DragRet::DRAG_DEFAULT);
700     void TransDragWindowToDragFwk(int32_t windowContainerId);
701     void ResetDragDrop(int32_t windowId, const Point& point);
702     bool isDistanceLimited(const Point& point);
703     bool isTimeLimited(const DragPointerEvent& pointerEvent, const Point& point);
704     bool ReachMoveLimit(const DragPointerEvent& pointerEvent, const Point& point);
705     bool IsUIExtensionShowPlaceholder(const RefPtr<NG::UINode>& node);
706     bool IsUIExtensionComponent(const RefPtr<NG::UINode>& node);
707     void HandleUIExtensionDragEvent(
708         const RefPtr<FrameNode>& frameNode, const DragPointerEvent& pointerEvent, DragEventType type);
709     int32_t GetWindowId();
710     void AddItemDrag(const RefPtr<FrameNode>& frameNode, const RefPtr<EventHub>& eventHub);
711     void RemoveItemDrag();
712     RectF GetFinalDragPreviewRect(const RefPtr<FrameNode>& imageNode, DragPreviewInfo& dragPreviewInfo,
713         const RefPtr<OverlayManager>& overlayManager);
714 
715     std::map<int32_t, WeakPtr<FrameNode>> dragFrameNodes_;
716     std::map<int32_t, WeakPtr<FrameNode>> gridDragFrameNodes_;
717     std::map<int32_t, WeakPtr<FrameNode>> listDragFrameNodes_;
718     std::map<int32_t, WeakPtr<FrameNode>> textFieldDragFrameNodes_;
719     RefPtr<FrameNode> draggedFrameNode_;
720     RefPtr<FrameNode> preTargetFrameNode_;
721     RefPtr<FrameNode> draggedGridFrameNode_;
722     RefPtr<FrameNode> preGridTargetFrameNode_;
723     RefPtr<FrameNode> itemDragOverlayNode_;
724     RefPtr<Clipboard> clipboard_;
725     Point preMovePoint_ = Point(0, 0);
726     DragPointerEvent preDragPointerEvent_;
727     uint64_t preTimeStamp_ = 0L;
728     std::function<void(const std::string&)> addDataCallback_ = nullptr;
729     std::function<void(const std::string&)> getDataCallback_ = nullptr;
730     std::function<void(const std::string&)> deleteDataCallback_ = nullptr;
731     std::string extraInfo_;
732     std::unique_ptr<JsonValue> newData_ = nullptr;
733     bool isDragCancel_ = false;
734     std::unordered_map<int32_t, WeakPtr<FrameNode>> nodesForDragNotify_;
735     std::unordered_set<int32_t> parentHitNodes_;
736     std::unordered_map<int32_t, std::function<void(const DragPointerEvent&)>> pullEventListener_;
737     DragCursorStyleCore dragCursorStyleCore_ = DragCursorStyleCore::DEFAULT;
738     std::map<std::string, int64_t> summaryMap_;
739     uint32_t recordSize_ = 0;
740     int64_t currentId_ = -1;
741     int32_t currentPointerId_ = -1;
742     int32_t currentPullId_ = -1;
743     bool draggingPressedState_ = false;
744 
745     std::function<void(void)> notifyInDraggedCallback_ = nullptr;
746     bool isDragged_ = false;
747     bool isMouseDragged_ = false;
748     bool isWindowConsumed_ = false;
749     bool isDragWindowShow_ = false;
750     bool hasNotifiedTransformation_ = false;
751     bool isPullMoveReceivedForCurrentDrag_ = false;
752     bool isDragWindowSubWindow_ = false;
753     bool isDragNodeNeedClean_ = false;
754     bool isAnyDraggableHit_ = false;
755     bool isReDragStart_ = false;
756     VelocityTracker velocityTracker_;
757     DragDropMgrState dragDropState_ = DragDropMgrState::IDLE;
758     Rect previewRect_ { -1, -1, -1, -1 };
759     DragPreviewInfo info_;
760     DragPointerEvent dragDropPointerEvent_;
761     DragPointerEvent dragAnimationPointerEvent_;
762     bool isDragFwkShow_ = true;
763     OffsetF pixelMapOffset_;
764     OffsetF curPointerOffset_;
765     std::vector<RefPtr<PixelMap>> gatherPixelMaps_;
766     bool isShowBadgeAnimation_ = true;
767     bool eventStrictReportingEnabled_ = false;
768     float dragStartAnimationRate_ = 0.0f;
769     int32_t badgeNumber_ = -1;
770     int32_t currentAnimationCnt_ = 0;
771     int32_t allAnimationCnt_ = 0;
772     int32_t currentStartAnimationCnt_ = 0;
773     int32_t allStartAnimationCnt_ = 0;
774     bool isDragWithContextMenu_ = false;
775     bool disableDefaultDropAnimation_ = false;
776     Point dragDampStartPoint_ { 1, 1 };
777     OffsetF dragMovePosition_ = OffsetF(0.0f, 0.0f);
778     OffsetF lastDragMovePosition_ = OffsetF(0.0f, 0.0f);
779     OffsetF dragTotalMovePosition_ = OffsetF(0.0f, 0.0f);
780     uint32_t dampingOverflowCount_ = 0;
781     std::shared_ptr<OHOS::Ace::NG::ArkUIInteralDragAction> dragAction_;
782     RefPtr<GridColumnInfo> columnInfo_;
783     WeakPtr<FrameNode> menuWrapperNode_;
784     ACE_DISALLOW_COPY_AND_MOVE(DragDropManager);
785     bool grayedState_ = false;
786 
787     std::map<int32_t, Point> fingerPointInfo_;
788     bool isStartAnimationFinished_{};
789     bool animationStates_ = true;
790 };
791 } // namespace OHOS::Ace::NG
792 
793 #endif // FOUNDATION_ACE_FRAMEWORKS_CORE_COMPONENTS_NG_MANAGER_DRAG_DROP_DRAG_DROP_MANAGER_H
794