widget/windows/nsNativeDragTarget.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include <stdio.h>
   7 #include "nsIDragService.h"
   8 #include "nsWidgetsCID.h"
   9 #include "nsNativeDragTarget.h"
  10 #include "nsDragService.h"
  11 #include "nsIServiceManager.h"
  12 #include "nsIDOMNode.h"
  13 #include "nsCOMPtr.h"
  14
  15 #include "nsIWidget.h"
  16 #include "nsWindow.h"
  17 #include "nsClipboard.h"
  18 #include "KeyboardLayout.h"
  19
  20 using namespace mozilla::widget;
  21
  22 /* Define Class IDs */
  23 static NS_DEFINE_IID(kCDragServiceCID,  NS_DRAGSERVICE_CID);
  24
  25 /* Define Interface IDs */
  26 static NS_DEFINE_IID(kIDragServiceIID, NS_IDRAGSERVICE_IID);
  27
  28 // This is cached for Leave notification
  29 static POINTL gDragLastPoint;
  30
  31 /*
  32  * class nsNativeDragTarget
  33  */
  34 nsNativeDragTarget::nsNativeDragTarget(nsIWidget * aWidget)
  35   : m_cRef(0),
  36     mEffectsAllowed(DROPEFFECT_MOVE | DROPEFFECT_COPY | DROPEFFECT_LINK),
  37     mEffectsPreferred(DROPEFFECT_NONE),
  38     mTookOwnRef(false), mWidget(aWidget), mDropTargetHelper(nullptr)
  39 {
  40   mHWnd = (HWND)mWidget->GetNativeData(NS_NATIVE_WINDOW);
  41
  42   /*
  43    * Create/Get the DragService that we have implemented
  44    */
  45   CallGetService(kCDragServiceCID, &mDragService);
  46 }
  47
  48 nsNativeDragTarget::~nsNativeDragTarget()
  49 {
  50   NS_RELEASE(mDragService);
  51
  52   if (mDropTargetHelper) {
  53     mDropTargetHelper->Release();
  54     mDropTargetHelper = nullptr;
  55   }
  56 }
  57
  58 // IUnknown methods - see iunknown.h for documentation
  59 STDMETHODIMP
  60 nsNativeDragTarget::QueryInterface(REFIID riid, void** ppv)
  61 {
  62   *ppv=NULL;
  63
  64   if (IID_IUnknown == riid || IID_IDropTarget == riid)
  65     *ppv=this;
  66
  67   if (NULL!=*ppv) {
  68     ((LPUNKNOWN)*ppv)->AddRef();
  69     return S_OK;
  70   }
  71
  72   return E_NOINTERFACE;
  73 }
  74
  75 STDMETHODIMP_(ULONG)
  76 nsNativeDragTarget::AddRef(void)
  77 {
  78   ++m_cRef;
  79   NS_LOG_ADDREF(this, m_cRef, "nsNativeDragTarget", sizeof(*this));
  80   return m_cRef;
  81 }
  82
  83 STDMETHODIMP_(ULONG) nsNativeDragTarget::Release(void)
  84 {
  85   --m_cRef;
  86   NS_LOG_RELEASE(this, m_cRef, "nsNativeDragTarget");
  87   if (0 != m_cRef)
  88     return m_cRef;
  89
  90   delete this;
  91   return 0;
  92 }
  93
  94 void
  95 nsNativeDragTarget::GetGeckoDragAction(DWORD grfKeyState, LPDWORD pdwEffect,
  96                                        uint32_t * aGeckoAction)
  97 {
  98   // If a window is disabled or a modal window is on top of it
  99   // (which implies it is disabled), then we should not allow dropping.
 100   if (!mWidget->IsEnabled()) {
 101     *pdwEffect = DROPEFFECT_NONE;
 102     *aGeckoAction = nsIDragService::DRAGDROP_ACTION_NONE;
 103     return;
 104   }
 105
 106   // If the user explicitly uses a modifier key, they want the associated action
 107   // Shift + Control -> LINK, Shift -> MOVE, Ctrl -> COPY
 108   DWORD desiredEffect = DROPEFFECT_NONE;
 109   if ((grfKeyState & MK_CONTROL) && (grfKeyState & MK_SHIFT)) {
 110     desiredEffect = DROPEFFECT_LINK;
 111   } else if (grfKeyState & MK_SHIFT) {
 112     desiredEffect = DROPEFFECT_MOVE;
 113   } else if (grfKeyState & MK_CONTROL) {
 114     desiredEffect = DROPEFFECT_COPY;
 115   }
 116
 117   // Determine the desired effect from what is allowed and preferred.
 118   if (!(desiredEffect &= mEffectsAllowed)) {
 119     // No modifier key effect is set which is also allowed, check
 120     // the preference of the data.
 121     desiredEffect = mEffectsPreferred & mEffectsAllowed;
 122     if (!desiredEffect) {
 123       // No preference is set, so just fall back to the allowed effect itself
 124       desiredEffect = mEffectsAllowed;
 125     }
 126   }
 127
 128   // Otherwise we should specify the first available effect
 129   // from MOVE, COPY, or LINK.
 130   if (desiredEffect & DROPEFFECT_MOVE) {
 131     *pdwEffect = DROPEFFECT_MOVE;
 132     *aGeckoAction = nsIDragService::DRAGDROP_ACTION_MOVE;
 133   } else if (desiredEffect & DROPEFFECT_COPY) {
 134     *pdwEffect = DROPEFFECT_COPY;
 135     *aGeckoAction = nsIDragService::DRAGDROP_ACTION_COPY;
 136   } else if (desiredEffect & DROPEFFECT_LINK) {
 137     *pdwEffect = DROPEFFECT_LINK;
 138     *aGeckoAction = nsIDragService::DRAGDROP_ACTION_LINK;
 139   } else {
 140     *pdwEffect = DROPEFFECT_NONE;
 141     *aGeckoAction = nsIDragService::DRAGDROP_ACTION_NONE;
 142   }
 143 }
 144
 145 inline
 146 bool
 147 IsKeyDown(char key)
 148 {
 149   return GetKeyState(key) < 0;
 150 }
 151
 152 void
 153 nsNativeDragTarget::DispatchDragDropEvent(uint32_t aEventType, POINTL aPT)
 154 {
 155   nsEventStatus status;
 156   nsDragEvent event(true, aEventType, mWidget);
 157
 158   nsWindow * win = static_cast<nsWindow *>(mWidget);
 159   win->InitEvent(event);
 160   POINT cpos;
 161
 162   cpos.x = aPT.x;
 163   cpos.y = aPT.y;
 164
 165   if (mHWnd != NULL) {
 166     ::ScreenToClient(mHWnd, &cpos);
 167     event.refPoint.x = cpos.x;
 168     event.refPoint.y = cpos.y;
 169   } else {
 170     event.refPoint.x = 0;
 171     event.refPoint.y = 0;
 172   }
 173
 174   ModifierKeyState modifierKeyState;
 175   modifierKeyState.InitInputEvent(event);
 176
 177   event.inputSource = static_cast<nsBaseDragService*>(mDragService)->GetInputSource();
 178
 179   mWidget->DispatchEvent(&event, status);
 180 }
 181
 182 void
 183 nsNativeDragTarget::ProcessDrag(uint32_t     aEventType,
 184                                 DWORD        grfKeyState,
 185                                 POINTL       ptl,
 186                                 DWORD*       pdwEffect)
 187 {
 188   // Before dispatching the event make sure we have the correct drop action set
 189   uint32_t geckoAction;
 190   GetGeckoDragAction(grfKeyState, pdwEffect, &geckoAction);
 191
 192   // Set the current action into the Gecko specific type
 193   nsCOMPtr<nsIDragSession> currSession;
 194   mDragService->GetCurrentSession(getter_AddRefs(currSession));
 195   if (!currSession) {
 196     return;
 197   }
 198
 199   currSession->SetDragAction(geckoAction);
 200
 201   // Dispatch the event into Gecko
 202   DispatchDragDropEvent(aEventType, ptl);
 203
 204   if (aEventType != NS_DRAGDROP_DROP) {
 205     // Get the cached drag effect from the drag service, the data member should
 206     // have been set by whoever handled the nsGUIEvent or nsIDOMEvent on drags.
 207     bool canDrop;
 208     currSession->GetCanDrop(&canDrop);
 209     if (!canDrop) {
 210       *pdwEffect = DROPEFFECT_NONE;
 211     }
 212   }
 213
 214   // Clear the cached value
 215   currSession->SetCanDrop(false);
 216 }
 217
 218 // IDropTarget methods
 219 STDMETHODIMP
 220 nsNativeDragTarget::DragEnter(LPDATAOBJECT pIDataSource,
 221                               DWORD        grfKeyState,
 222                               POINTL       ptl,
 223                               DWORD*       pdwEffect)
 224 {
 225   if (!mDragService) {
 226     return E_FAIL;
 227   }
 228
 229   mEffectsAllowed = *pdwEffect;
 230   AddLinkSupportIfCanBeGenerated(pIDataSource);
 231
 232   // Drag and drop image helper
 233   if (GetDropTargetHelper()) {
 234     POINT pt = { ptl.x, ptl.y };
 235     GetDropTargetHelper()->DragEnter(mHWnd, pIDataSource, &pt, *pdwEffect);
 236   }
 237
 238   // save a ref to this, in case the window is destroyed underneath us
 239   NS_ASSERTION(!mTookOwnRef, "own ref already taken!");
 240   this->AddRef();
 241   mTookOwnRef = true;
 242
 243   // tell the drag service about this drag (it may have come from an
 244   // outside app).
 245   mDragService->StartDragSession();
 246
 247   void* tempOutData = nullptr;
 248   uint32_t tempDataLen = 0;
 249   nsresult loadResult = nsClipboard::GetNativeDataOffClipboard(
 250       pIDataSource, 0, ::RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT), nullptr, &tempOutData, &tempDataLen);
 251   if (NS_SUCCEEDED(loadResult) && tempOutData) {
 252     mEffectsPreferred = *((DWORD*)tempOutData);
 253     nsMemory::Free(tempOutData);
 254   } else {
 255     // We have no preference if we can't obtain it
 256     mEffectsPreferred = DROPEFFECT_NONE;
 257   }
 258
 259   // Set the native data object into drag service
 260   //
 261   // This cast is ok because in the constructor we created a
 262   // the actual implementation we wanted, so we know this is
 263   // a nsDragService. It should be a private interface, though.
 264   nsDragService * winDragService =
 265     static_cast<nsDragService *>(mDragService);
 266   winDragService->SetIDataObject(pIDataSource);
 267
 268   // Now process the native drag state and then dispatch the event
 269   ProcessDrag(NS_DRAGDROP_ENTER, grfKeyState, ptl, pdwEffect);
 270
 271   return S_OK;
 272 }
 273
 274 void
 275 nsNativeDragTarget::AddLinkSupportIfCanBeGenerated(LPDATAOBJECT aIDataSource)
 276 {
 277   // If we don't have a link effect, but we can generate one, fix the
 278   // drop effect to include it.
 279   if (!(mEffectsAllowed & DROPEFFECT_LINK) && aIDataSource) {
 280     if (S_OK == ::OleQueryLinkFromData(aIDataSource)) {
 281       mEffectsAllowed |= DROPEFFECT_LINK;
 282     }
 283   }
 284 }
 285
 286 STDMETHODIMP
 287 nsNativeDragTarget::DragOver(DWORD   grfKeyState,
 288                              POINTL  ptl,
 289                              LPDWORD pdwEffect)
 290 {
 291   if (!mDragService) {
 292     return E_FAIL;
 293   }
 294
 295   // If a LINK effect could be generated previously from a DragEnter(),
 296   // then we should include it as an allowed effect.
 297   mEffectsAllowed = (*pdwEffect) | (mEffectsAllowed & DROPEFFECT_LINK);
 298
 299   nsCOMPtr<nsIDragSession> currentDragSession;
 300   mDragService->GetCurrentSession(getter_AddRefs(currentDragSession));
 301   if (!currentDragSession) {
 302     return S_OK;  // Drag was canceled.
 303   }
 304
 305   // without the AddRef() |this| can get destroyed in an event handler
 306   this->AddRef();
 307
 308   // Drag and drop image helper
 309   if (GetDropTargetHelper()) {
 310     POINT pt = { ptl.x, ptl.y };
 311     GetDropTargetHelper()->DragOver(&pt, *pdwEffect);
 312   }
 313
 314   mDragService->FireDragEventAtSource(NS_DRAGDROP_DRAG);
 315   // Now process the native drag state and then dispatch the event
 316   ProcessDrag(NS_DRAGDROP_OVER, grfKeyState, ptl, pdwEffect);
 317
 318   this->Release();
 319
 320   return S_OK;
 321 }
 322
 323 STDMETHODIMP
 324 nsNativeDragTarget::DragLeave()
 325 {
 326   if (!mDragService) {
 327     return E_FAIL;
 328   }
 329
 330   // Drag and drop image helper
 331   if (GetDropTargetHelper()) {
 332     GetDropTargetHelper()->DragLeave();
 333   }
 334
 335   // dispatch the event into Gecko
 336   DispatchDragDropEvent(NS_DRAGDROP_EXIT, gDragLastPoint);
 337
 338   nsCOMPtr<nsIDragSession> currentDragSession;
 339   mDragService->GetCurrentSession(getter_AddRefs(currentDragSession));
 340
 341   if (currentDragSession) {
 342     nsCOMPtr<nsIDOMNode> sourceNode;
 343     currentDragSession->GetSourceNode(getter_AddRefs(sourceNode));
 344
 345     if (!sourceNode) {
 346       // We're leaving a window while doing a drag that was
 347       // initiated in a different app. End the drag session, since
 348       // we're done with it for now (until the user drags back into
 349       // mozilla).
 350       mDragService->EndDragSession(false);
 351     }
 352   }
 353
 354   // release the ref that was taken in DragEnter
 355   NS_ASSERTION(mTookOwnRef, "want to release own ref, but not taken!");
 356   if (mTookOwnRef) {
 357     this->Release();
 358     mTookOwnRef = false;
 359   }
 360
 361   return S_OK;
 362 }
 363
 364 void
 365 nsNativeDragTarget::DragCancel()
 366 {
 367   // Cancel the drag session if we did DragEnter.
 368   if (mTookOwnRef) {
 369     if (GetDropTargetHelper()) {
 370       GetDropTargetHelper()->DragLeave();
 371     }
 372     if (mDragService) {
 373       mDragService->EndDragSession(false);
 374     }
 375     this->Release(); // matching the AddRef in DragEnter
 376     mTookOwnRef = false;
 377   }
 378 }
 379
 380 STDMETHODIMP
 381 nsNativeDragTarget::Drop(LPDATAOBJECT pData,
 382                          DWORD        grfKeyState,
 383                          POINTL       aPT,
 384                          LPDWORD      pdwEffect)
 385 {
 386   if (!mDragService) {
 387     return E_FAIL;
 388   }
 389
 390   mEffectsAllowed = *pdwEffect;
 391   AddLinkSupportIfCanBeGenerated(pData);
 392
 393   // Drag and drop image helper
 394   if (GetDropTargetHelper()) {
 395     POINT pt = { aPT.x, aPT.y };
 396     GetDropTargetHelper()->Drop(pData, &pt, *pdwEffect);
 397   }
 398
 399   // Set the native data object into the drag service
 400   //
 401   // This cast is ok because in the constructor we created a
 402   // the actual implementation we wanted, so we know this is
 403   // a nsDragService (but it should still be a private interface)
 404   nsDragService* winDragService = static_cast<nsDragService*>(mDragService);
 405   winDragService->SetIDataObject(pData);
 406
 407   // NOTE: ProcessDrag spins the event loop which may destroy arbitrary objects.
 408   // We use strong refs to prevent it from destroying these:
 409   nsRefPtr<nsNativeDragTarget> kungFuDeathGrip = this;
 410   nsCOMPtr<nsIDragService> serv = mDragService;
 411
 412   // Now process the native drag state and then dispatch the event
 413   ProcessDrag(NS_DRAGDROP_DROP, grfKeyState, aPT, pdwEffect);
 414
 415   nsCOMPtr<nsIDragSession> currentDragSession;
 416   serv->GetCurrentSession(getter_AddRefs(currentDragSession));
 417   if (!currentDragSession) {
 418     return S_OK;  // DragCancel() was called.
 419   }
 420
 421   // Let the win drag service know whether this session experienced
 422   // a drop event within the application. Drop will not oocur if the
 423   // drop landed outside the app. (used in tab tear off, bug 455884)
 424   winDragService->SetDroppedLocal();
 425
 426   // tell the drag service we're done with the session
 427   // Use GetMessagePos to get the position of the mouse at the last message
 428   // seen by the event loop. (Bug 489729)
 429   DWORD pos = ::GetMessagePos();
 430   POINT cpos;
 431   cpos.x = GET_X_LPARAM(pos);
 432   cpos.y = GET_Y_LPARAM(pos);
 433   winDragService->SetDragEndPoint(nsIntPoint(cpos.x, cpos.y));
 434   serv->EndDragSession(true);
 435
 436   // release the ref that was taken in DragEnter
 437   NS_ASSERTION(mTookOwnRef, "want to release own ref, but not taken!");
 438   if (mTookOwnRef) {
 439     this->Release();
 440     mTookOwnRef = false;
 441   }
 442
 443   return S_OK;
 444 }
 445
 446 /**
 447  * By lazy loading mDropTargetHelper we save 50-70ms of startup time
 448  * which is ~5% of startup time.
 449 */
 450 IDropTargetHelper*
 451 nsNativeDragTarget::GetDropTargetHelper()
 452 {
 453   if (!mDropTargetHelper) {
 454     CoCreateInstance(CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER,
 455                      IID_IDropTargetHelper, (LPVOID*)&mDropTargetHelper);
 456   }
 457
 458   return mDropTargetHelper;
 459 }