dali/internal/drag-and-drop/tizen-wayland/drag-and-drop-impl-ecore-wl2.cpp

   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
  18 // CLASS HEADER
  19 #include <dali/internal/drag-and-drop/tizen-wayland/drag-and-drop-impl-ecore-wl2.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/devel-api/common/singleton-service.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/internal/adaptor/tizen-wayland/dali-ecore-wl2.h>
  25 #include <unistd.h>
  26
  27 ///////////////////////////////////////////////////////////////////////////////////////////////////
  28 // DragAndDrop
  29 ///////////////////////////////////////////////////////////////////////////////////////////////////
  30
  31 namespace Dali
  32 {
  33 namespace Internal
  34 {
  35 namespace Adaptor
  36 {
  37 namespace
  38 {
  39 static constexpr int32_t DEFAULT_POSITION = -1;
  40 }
  41
  42 static bool IsIntersection(int px, int py, int tx, int ty, int tw, int th)
  43 {
  44   if(px > tx && py > ty && px < (tx + tw) && py < (ty + th))
  45   {
  46     return true;
  47   }
  48   return false;
  49 }
  50
  51 static Eina_Bool EcoreEventDataSend(void* data, int type, void* event)
  52 {
  53   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
  54   dndImpl->SendData(event);
  55
  56   return ECORE_CALLBACK_PASS_ON;
  57 }
  58
  59 static Eina_Bool EcoreEventDataSourceEnd(void* data, int type, void* event)
  60 {
  61   Ecore_Wl2_Event_Data_Source_End *ev = reinterpret_cast<Ecore_Wl2_Event_Data_Source_End*>(event);
  62   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
  63   if(ev->cancelled)
  64   {
  65     dndImpl->CallSourceEvent(Dali::DragAndDrop::SourceEventType::CANCEL);
  66   }
  67   else
  68   {
  69     dndImpl->CallSourceEvent(Dali::DragAndDrop::SourceEventType::ACCEPT);
  70   }
  71
  72   return ECORE_CALLBACK_PASS_ON;
  73 }
  74
  75 static Eina_Bool EcoreEventDataSourceDrop(void* data, int type, void* event)
  76 {
  77   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
  78   dndImpl->CallSourceEvent(Dali::DragAndDrop::SourceEventType::FINISH);
  79   return ECORE_CALLBACK_PASS_ON;
  80 }
  81
  82 static Eina_Bool EcoreEventOfferDataReady(void* data, int type, void* event)
  83 {
  84   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
  85   dndImpl->ReceiveData(event);
  86
  87   return ECORE_CALLBACK_PASS_ON;
  88 }
  89
  90 static Eina_Bool EcoreEventDataMotion(void* data, int type, void* event)
  91 {
  92   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
  93   dndImpl->CalculateDragEvent(event);
  94
  95   return ECORE_CALLBACK_PASS_ON;
  96 }
  97
  98 static Eina_Bool EcoreEventDataDrop(void* data, int type, void* event)
  99 {
 100   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
 101   dndImpl->CalculateViewRegion(event);
 102
 103   return ECORE_CALLBACK_PASS_ON;
 104 }
 105
 106 static Eina_Bool EcoreEventDataEnter(void* data, int type, void* event)
 107 {
 108   Ecore_Wl2_Event_Dnd_Enter* ev = reinterpret_cast<Ecore_Wl2_Event_Dnd_Enter*>(event);
 109
 110   // Set default offer is reject
 111   ecore_wl2_offer_accept(ev->offer, NULL);
 112   return ECORE_CALLBACK_PASS_ON;
 113 }
 114
 115 static Eina_Bool EcoreEventDataLeave(void* data, int type, void* event)
 116 {
 117   DragAndDropEcoreWl* dndImpl = reinterpret_cast<DragAndDropEcoreWl*>(data);
 118   dndImpl->ResetDropTargets();
 119
 120   return ECORE_CALLBACK_PASS_ON;
 121 }
 122
 123 Dali::DragAndDrop GetDragAndDrop()
 124 {
 125   Dali::DragAndDrop dnd;
 126
 127   Dali::SingletonService service(SingletonService::Get());
 128   if(service)
 129   {
 130     // Check whether the singleton is already created
 131     Dali::BaseHandle handle = service.GetSingleton(typeid(Dali::DragAndDrop));
 132     if(handle)
 133     {
 134       // If so, downcast the handle
 135       dnd = Dali::DragAndDrop(dynamic_cast<DragAndDrop*>(handle.GetObjectPtr()));
 136     }
 137     else
 138     {
 139       // Create a singleon instance
 140       DragAndDropEcoreWl* dndImpl = new DragAndDropEcoreWl();
 141
 142       dnd = Dali::DragAndDrop(dndImpl);
 143       service.Register(typeid(Dali::DragAndDrop), dnd);
 144     }
 145   }
 146
 147   return dnd;
 148 }
 149
 150 DragAndDropEcoreWl::DragAndDropEcoreWl()
 151 {
 152   // Source Events
 153   mSendHandler       = ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_SEND, EcoreEventDataSend, this);
 154   mSourceEndHandler  = ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_END, EcoreEventDataSourceEnd, this);
 155   mSourceDropHandler = ecore_event_handler_add(ECORE_WL2_EVENT_DATA_SOURCE_DROP, EcoreEventDataSourceDrop, this);
 156
 157   // Target Events
 158   mReceiveHandler    = ecore_event_handler_add(ECORE_WL2_EVENT_OFFER_DATA_READY, EcoreEventOfferDataReady, this);
 159   mMotionHandler     = ecore_event_handler_add(ECORE_WL2_EVENT_DND_MOTION, EcoreEventDataMotion, this);
 160   mDropHandler       = ecore_event_handler_add(ECORE_WL2_EVENT_DND_DROP, EcoreEventDataDrop, this);
 161   mEnterHandler      = ecore_event_handler_add(ECORE_WL2_EVENT_DND_ENTER, EcoreEventDataEnter, this);
 162   mLeaveHandler      = ecore_event_handler_add(ECORE_WL2_EVENT_DND_LEAVE, EcoreEventDataLeave, this);
 163 }
 164
 165 DragAndDropEcoreWl::~DragAndDropEcoreWl()
 166 {
 167   // Source Events
 168   ecore_event_handler_del(mSendHandler);
 169   ecore_event_handler_del(mSourceEndHandler);
 170   ecore_event_handler_del(mSourceDropHandler);
 171
 172   // Target Events
 173   ecore_event_handler_del(mReceiveHandler);
 174   ecore_event_handler_del(mMotionHandler);
 175   ecore_event_handler_del(mDropHandler);
 176   ecore_event_handler_del(mEnterHandler);
 177 }
 178
 179 bool DragAndDropEcoreWl::StartDragAndDrop(Dali::Actor source, Dali::Window shadowWindow, const Dali::DragAndDrop::DragData& data, Dali::DragAndDrop::SourceFunction callback)
 180 {
 181   // Get Parent Window
 182   auto parent = Dali::DevelWindow::Get(source);
 183
 184   // Set Drag Source Data
 185   mMimeType = data.GetMimeType();
 186   mData     = data.GetData();
 187
 188   // Set Source Event
 189   mSourceCallback = callback;
 190
 191   // Set Drag Window
 192   mDragWindow = shadowWindow;
 193
 194   // Start Drag and Drop
 195   Ecore_Wl2_Window*  parentWindow = AnyCast<Ecore_Wl2_Window*>(parent.GetNativeHandle());
 196   Ecore_Wl2_Window*  dragWindow   = AnyCast<Ecore_Wl2_Window*>(mDragWindow.GetNativeHandle());
 197   Ecore_Wl2_Display* display      = ecore_wl2_connected_display_get(NULL);
 198   Ecore_Wl2_Input*   input        = ecore_wl2_input_default_input_get(display);
 199
 200   // Disable Default Cursor
 201   ecore_wl2_input_pointer_set(input, NULL, 0, 0);
 202
 203   // Set mime type for drag and drop
 204   const char* mimeTypes[2];
 205   mimeTypes[0] = mMimeType.c_str();
 206   mimeTypes[1] = NULL;
 207
 208   // Set mime type
 209   ecore_wl2_dnd_drag_types_set(input, (const char**)mimeTypes);
 210
 211   // Start wayland drag and drop
 212   mSerial = ecore_wl2_dnd_drag_start(input, parentWindow, dragWindow);
 213
 214   // Call Start Event
 215   CallSourceEvent(Dali::DragAndDrop::SourceEventType::START);
 216
 217   return true;
 218 }
 219
 220 bool DragAndDropEcoreWl::AddListener(Dali::Actor target, Dali::DragAndDrop::DragAndDropFunction callback)
 221 {
 222   std::vector<DropTarget>::iterator itr;
 223   for(itr = mDropTargets.begin(); itr < mDropTargets.end(); itr++)
 224   {
 225     if((*itr).target == target)
 226     {
 227       return false;
 228     }
 229   }
 230
 231   DropTarget targetData;
 232   targetData.target   = target;
 233   targetData.callback = callback;
 234   targetData.inside   = false;
 235
 236   mDropTargets.push_back(targetData);
 237
 238   return true;
 239 }
 240
 241 bool DragAndDropEcoreWl::RemoveListener(Dali::Actor target)
 242 {
 243   std::vector<DropTarget>::iterator itr;
 244   for(itr = mDropTargets.begin(); itr < mDropTargets.end(); itr++)
 245   {
 246     if((*itr).target == target)
 247     {
 248       mDropTargets.erase(itr);
 249       break;
 250     }
 251   }
 252
 253   return true;
 254 }
 255
 256 void DragAndDropEcoreWl::CallSourceEvent(Dali::DragAndDrop::SourceEventType type)
 257 {
 258   if(mSourceCallback)
 259   {
 260     mSourceCallback(type);
 261   }
 262 }
 263
 264 void DragAndDropEcoreWl::ResetDropTargets()
 265 {
 266   for(std::size_t i = 0; i < mDropTargets.size(); i++)
 267   {
 268      if(mDropTargets[i].inside)
 269      {
 270        Dali::DragAndDrop::DragEvent dragEvent;
 271        dragEvent.SetAction(Dali::DragAndDrop::DragType::LEAVE);
 272        Dali::Vector2 position(DEFAULT_POSITION, DEFAULT_POSITION);
 273        dragEvent.SetPosition(position);
 274        mDropTargets[i].callback(dragEvent);
 275      }
 276      mDropTargets[i].inside = false;
 277   }
 278 }
 279
 280
 281 void DragAndDropEcoreWl::SendData(void* event)
 282 {
 283   Ecore_Wl2_Event_Data_Source_Send* ev = reinterpret_cast<Ecore_Wl2_Event_Data_Source_Send*>(event);
 284   if(ev->serial != mSerial)
 285   {
 286     return;
 287   }
 288
 289   int dataLength = strlen(mData.c_str());
 290   int bufferSize = dataLength;
 291   if((mMimeType.find("text") != std::string::npos) ||
 292      (mMimeType.find("markup") != std::string::npos) ||
 293      (mMimeType.find("image") != std::string::npos))
 294   {
 295     bufferSize += 1;
 296   }
 297
 298   char* buffer = new char[bufferSize];
 299   if(!buffer)
 300   {
 301     return;
 302   }
 303
 304   memcpy(buffer, mData.c_str(), dataLength);
 305   buffer[dataLength] = '\0';
 306
 307   auto ret = write(ev->fd, buffer, bufferSize);
 308   if(DALI_UNLIKELY(ret != bufferSize))
 309   {
 310     DALI_LOG_ERROR("write(ev->fd) return %d! Pleacse check it\n", static_cast<int>(ret));
 311   }
 312
 313   close(ev->fd);
 314
 315   if(mDragWindow)
 316   {
 317     mDragWindow.Hide();
 318   }
 319
 320   delete[] buffer;
 321 }
 322
 323 void DragAndDropEcoreWl::ReceiveData(void* event)
 324 {
 325   Ecore_Wl2_Event_Offer_Data_Ready* ev = reinterpret_cast<Ecore_Wl2_Event_Offer_Data_Ready*>(event);
 326
 327   if(mTargetIndex != -1)
 328   {
 329     Dali::DragAndDrop::DragEvent dragEvent(Dali::DragAndDrop::DragType::DROP, mPosition, ev->mimetype, ev->data);
 330     mDropTargets[mTargetIndex].callback(dragEvent);
 331     mDropTargets[mTargetIndex].inside = false;
 332     ecore_wl2_offer_finish(ev->offer);
 333   }
 334   mTargetIndex = -1;
 335 }
 336
 337 bool DragAndDropEcoreWl::CalculateDragEvent(void* event)
 338 {
 339   Ecore_Wl2_Event_Dnd_Motion* ev = reinterpret_cast<Ecore_Wl2_Event_Dnd_Motion*>(event);
 340
 341   Dali::DragAndDrop::DragEvent dragEvent;
 342   Dali::Vector2                curPosition(ev->x, ev->y);
 343
 344   for(std::size_t i = 0; i < mDropTargets.size(); i++)
 345   {
 346     Vector2 position      = mDropTargets[i].target.GetProperty<Vector2>(Dali::Actor::Property::POSITION);
 347     Vector2 size          = mDropTargets[i].target.GetProperty<Vector2>(Dali::Actor::Property::SIZE);
 348     bool    currentInside = IsIntersection(ev->x, ev->y, position.x, position.y, size.width, size.height);
 349
 350     // Calculate Drag Enter, Leave, Move Event
 351     if(currentInside && !mDropTargets[i].inside)
 352     {
 353       mDropTargets[i].inside = true;
 354       // Call Enter Event
 355       dragEvent.SetAction(Dali::DragAndDrop::DragType::ENTER);
 356       dragEvent.SetPosition(curPosition);
 357       mDropTargets[i].callback(dragEvent);
 358       // Accept Offer
 359       ecore_wl2_offer_mimes_set(ev->offer, ecore_wl2_offer_mimes_get(ev->offer));
 360     }
 361     else if(!currentInside && mDropTargets[i].inside)
 362     {
 363       mDropTargets[i].inside = false;
 364       // Call Leave Event
 365       dragEvent.SetAction(Dali::DragAndDrop::DragType::LEAVE);
 366       dragEvent.SetPosition(curPosition);
 367       mDropTargets[i].callback(dragEvent);
 368       // Reject Offer
 369       ecore_wl2_offer_accept(ev->offer, NULL);
 370     }
 371     else if(currentInside && mDropTargets[i].inside)
 372     {
 373       // Call Move Event
 374       dragEvent.SetAction(Dali::DragAndDrop::DragType::MOVE);
 375       dragEvent.SetPosition(curPosition);
 376       mDropTargets[i].callback(dragEvent);
 377     }
 378   }
 379
 380   return true;
 381 }
 382
 383 bool DragAndDropEcoreWl::CalculateViewRegion(void* event)
 384 {
 385   Ecore_Wl2_Event_Dnd_Drop* ev = reinterpret_cast<Ecore_Wl2_Event_Dnd_Drop*>(event);
 386
 387   // Check the target object region
 388   mTargetIndex = -1;
 389
 390   for(std::size_t i = 0; i < mDropTargets.size(); i++)
 391   {
 392     Vector2 position = mDropTargets[i].target.GetProperty<Vector2>(Dali::Actor::Property::POSITION);
 393     Vector2 size     = mDropTargets[i].target.GetProperty<Vector2>(Dali::Actor::Property::SIZE);
 394     // If the drop position is in the target object region, request drop data to the source object
 395     if(IsIntersection(ev->x, ev->y, position.x, position.y, size.width, size.height))
 396     {
 397       mTargetIndex        = i;
 398       mPosition           = position;
 399       Dali::Window window = Dali::DevelWindow::Get(mDropTargets[i].target);
 400
 401       char* mimetype = (char*)eina_array_data_get(ecore_wl2_offer_mimes_get(ev->offer), 0);
 402       if(mimetype)
 403       {
 404         ecore_wl2_offer_receive(ev->offer, mimetype);
 405         Ecore_Wl2_Display* display = ecore_wl2_connected_display_get(NULL);
 406         Ecore_Wl2_Input*   input   = ecore_wl2_input_default_input_get(display);
 407         ecore_wl2_display_flush(ecore_wl2_input_display_get(input));
 408       }
 409       return true;
 410     }
 411   }
 412
 413   return false;
 414 }
 415
 416 } // namespace Adaptor
 417
 418 } // namespace Internal
 419
 420 } // namespace Dali