src/Tizen.NUI/src/public/DragAndDrop/DragAndDrop.cs

   1 /*
   2  * Copyright(c) 2022 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.ComponentModel;
  19 using System.Runtime.InteropServices;
  20 using System.Collections.Generic;
  21 using System.Diagnostics.CodeAnalysis;
  22 using Tizen.NUI.BaseComponents;
  23
  24 namespace Tizen.NUI
  25 {
  26     /// <summary>
  27     /// DragAndDrop controls the drag objet and data.
  28     /// </summary>
  29     [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000: Dispose objects before losing scope", Justification = "It does not have ownership.")]
  30     [EditorBrowsable(EditorBrowsableState.Never)]
  31     public class DragAndDrop : BaseHandle
  32     {
  33         [EditorBrowsable(EditorBrowsableState.Never)]
  34         public delegate void SourceEventHandler(SourceEventType sourceEventType);
  35         private delegate void InternalSourceEventHandler(int sourceEventType);
  36         public delegate void DragAndDropEventHandler(View targetView, DragEvent dragEvent);
  37         private delegate void InternalDragAndDropEventHandler(global::System.IntPtr dragEvent);
  38         private InternalSourceEventHandler sourceEventCb;
  39         private Dictionary<View, InternalDragAndDropEventHandler> targetEventDictionary = new Dictionary<View, InternalDragAndDropEventHandler>();
  40         private Window mDragWindow;
  41         private const int shadowWidth = 150;
  42         private const int shadowHeight = 150;
  43
  44         [EditorBrowsable(EditorBrowsableState.Never)]
  45         private DragAndDrop() : this(Interop.DragAndDrop.New(), true)
  46         {
  47             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  48         }
  49
  50         private DragAndDrop(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  51         {
  52
  53         }
  54
  55         [EditorBrowsable(EditorBrowsableState.Never)]
  56         public static DragAndDrop Instance { get; } = new DragAndDrop();
  57
  58         /// <summary>
  59         /// Starts drag and drop.
  60         /// </summary>
  61         /// <param name="sourceView">The soruce view</param>
  62         /// <param name="shadowView">The shadow view for drag object</param>
  63         /// <param name="dragData">The data to send</param>
  64         /// <param name="callback">The source event callback</param>
  65         [EditorBrowsable(EditorBrowsableState.Never)]
  66         public void StartDragAndDrop(View sourceView, View shadowView, DragData dragData, SourceEventHandler callback)
  67         {
  68             if (null == shadowView)
  69             {
  70                 throw new ArgumentNullException(nameof(shadowView));
  71             }
  72
  73             if (mDragWindow)
  74             {
  75                 mDragWindow.Hide();
  76                 mDragWindow.Dispose();
  77                 mDragWindow = null;
  78             }
  79
  80             //FIXME: Drag window cannot be reused because the current window server does not allow reuse.
  81             //       When window server allows the drag window to be reused, makes the mDragWindow created once.
  82             mDragWindow = new Window("DragWindow", new Rectangle(-shadowWidth, -shadowHeight, shadowWidth, shadowHeight), true)
  83             {
  84               BackgroundColor = Color.Transparent,
  85             };
  86
  87             if (mDragWindow)
  88             {
  89                 shadowView.SetSize(shadowWidth, shadowHeight);
  90                 shadowView.SetOpacity(0.9f);
  91
  92                 mDragWindow.Add(shadowView);
  93                 mDragWindow.Show();
  94
  95                 sourceEventCb = (sourceEventType) =>
  96                 {
  97                     callback((SourceEventType)sourceEventType);
  98                 };
  99
 100                 if (!Interop.DragAndDrop.StartDragAndDrop(SwigCPtr, View.getCPtr(sourceView), Window.getCPtr(mDragWindow), dragData.MimeType, dragData.Data,
 101                                                         new global::System.Runtime.InteropServices.HandleRef(this, Marshal.GetFunctionPointerForDelegate<Delegate>(sourceEventCb))))
 102                 {
 103                     throw new InvalidOperationException("Fail to StartDragAndDrop");
 104                 }
 105             }
 106         }
 107
 108         /// <summary>
 109         /// Adds listener for drop targets
 110         /// </summary>
 111         /// <param name="targetView">The target view</param>
 112         /// <param name="callback">The callback function to get drag event</param>
 113         [EditorBrowsable(EditorBrowsableState.Never)]
 114         public void AddListener(View targetView, DragAndDropEventHandler callback)
 115         {
 116             InternalDragAndDropEventHandler cb = (dragEvent) =>
 117             {
 118                 DragType type = (DragType)Interop.DragAndDrop.GetAction(dragEvent);
 119                 DragEvent ev = new DragEvent();
 120                 global::System.IntPtr cPtr = Interop.DragAndDrop.GetPosition(dragEvent);
 121                 ev.Position = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 122
 123                 if (type == DragType.Enter)
 124                 {
 125                     ev.DragType = type;
 126                     callback(targetView, ev);
 127                 }
 128                 else if (type == DragType.Leave)
 129                 {
 130                     ev.DragType = type;
 131                     callback(targetView, ev);
 132                 }
 133                 else if (type == DragType.Move)
 134                 {
 135                     ev.DragType = type;
 136                     callback(targetView, ev);
 137                 }
 138                 else if (type == DragType.Drop)
 139                 {
 140                     ev.DragType = type;
 141                     ev.MimeType = Interop.DragAndDrop.GetMimeType(dragEvent);
 142                     ev.Data = Interop.DragAndDrop.GetData(dragEvent);
 143                     callback(targetView, ev);
 144                 }
 145             };
 146
 147             targetEventDictionary.Add(targetView, cb);
 148
 149             if (!Interop.DragAndDrop.AddListener(SwigCPtr, View.getCPtr(targetView),
 150                                                  new global::System.Runtime.InteropServices.HandleRef(this, Marshal.GetFunctionPointerForDelegate<Delegate>(cb))))
 151             {
 152                  throw new InvalidOperationException("Fail to AddListener");
 153             }
 154         }
 155
 156         /// <summary>
 157         /// Removes listener for drop targets
 158         /// </summary>
 159         /// <param name="targetView">The target view</param>
 160         /// <param name="callback">The callback function to remove</param>
 161         [EditorBrowsable(EditorBrowsableState.Never)]
 162         public void RemoveListener(View targetView, DragAndDropEventHandler callback)
 163         {
 164             if (!targetEventDictionary.ContainsKey(targetView))
 165             {
 166                  throw new InvalidOperationException("Fail to RemoveListener");
 167             }
 168
 169             InternalDragAndDropEventHandler cb = targetEventDictionary[targetView];
 170             targetEventDictionary.Remove(targetView);
 171             if (!Interop.DragAndDrop.RemoveListener(SwigCPtr, View.getCPtr(targetView),
 172                                                     new global::System.Runtime.InteropServices.HandleRef(this, Marshal.GetFunctionPointerForDelegate<Delegate>(cb))))
 173             {
 174                  throw new InvalidOperationException("Fail to RemoveListener");
 175             }
 176         }
 177     }
 178 }