src/Utils/DragDropImpl.cpp

   1 /**************************************************************************
   2    THIS CODE AND INFORMATION IS PROVIDED 'AS IS' WITHOUT WARRANTY OF
   3    ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
   4    THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
   5    PARTICULAR PURPOSE.
   6    Author: Leon Finker  1/2001
   7 **************************************************************************/
   8 // IDataObjectImpl.cpp: implementation of the CIDataObjectImpl class.
   9 //////////////////////////////////////////////////////////////////////
  10 #include "stdafx.h"
  11 #include <shlobj.h>
  12 #include <atlbase.h>
  13 #include "DragDropImpl.h"
  14 #include <new>
  15 #include <Strsafe.h>
  16
  17 //////////////////////////////////////////////////////////////////////
  18 // CIDataObject Class
  19 //////////////////////////////////////////////////////////////////////
  20
  21 CIDataObject::CIDataObject(CIDropSource* pDropSource):
  22 m_cRefCount(0), m_pDropSource(pDropSource)
  23 {
  24 }
  25
  26 CIDataObject::~CIDataObject()
  27 {
  28         for(int i = 0; i < m_StgMedium.GetSize(); ++i)
  29         {
  30                 ReleaseStgMedium(m_StgMedium[i]);
  31                 delete m_StgMedium[i];
  32         }
  33         for(int j = 0; j < m_ArrFormatEtc.GetSize(); ++j)
  34                 delete m_ArrFormatEtc[j];
  35 }
  36
  37 STDMETHODIMP CIDataObject::QueryInterface(/* [in] */ REFIID riid,
  38 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
  39 {
  40         if (!ppvObject)
  41                 return E_POINTER;
  42         *ppvObject = nullptr;
  43         if (IsEqualIID(IID_IUnknown, riid) || IsEqualIID(IID_IDataObject, riid))
  44                 *ppvObject=static_cast<IDataObject*>(this);
  45         /*else if(riid == IID_IAsyncOperation)
  46                 *ppvObject=(IAsyncOperation*)this;*/
  47         else
  48                 return E_NOINTERFACE;
  49         AddRef();
  50         return S_OK;
  51 }
  52
  53 STDMETHODIMP_(ULONG) CIDataObject::AddRef( void)
  54 {
  55         return ++m_cRefCount;
  56 }
  57
  58 STDMETHODIMP_(ULONG) CIDataObject::Release( void)
  59 {
  60    long nTemp = --m_cRefCount;
  61    if(nTemp==0)
  62           delete this;
  63    return nTemp;
  64 }
  65
  66 STDMETHODIMP CIDataObject::GetData(
  67         /* [unique][in] */ FORMATETC __RPC_FAR *pformatetcIn,
  68         /* [out] */ STGMEDIUM __RPC_FAR *pmedium)
  69 {
  70         if (!pformatetcIn)
  71                 return E_INVALIDARG;
  72         if (!pmedium)
  73                 return E_POINTER;
  74         pmedium->hGlobal = nullptr;
  75
  76         ATLASSERT(m_StgMedium.GetSize() == m_ArrFormatEtc.GetSize());
  77         for(int i=0; i < m_ArrFormatEtc.GetSize(); ++i)
  78         {
  79                 if(pformatetcIn->tymed & m_ArrFormatEtc[i]->tymed &&
  80                         pformatetcIn->dwAspect == m_ArrFormatEtc[i]->dwAspect &&
  81                         pformatetcIn->cfFormat == m_ArrFormatEtc[i]->cfFormat)
  82                 {
  83                         CopyMedium(pmedium, m_StgMedium[i], m_ArrFormatEtc[i]);
  84                         return S_OK;
  85                 }
  86         }
  87         return DV_E_FORMATETC;
  88 }
  89
  90 STDMETHODIMP CIDataObject::GetDataHere(
  91         /* [unique][in] */ FORMATETC __RPC_FAR * /*pformatetc*/,
  92         /* [out][in] */ STGMEDIUM __RPC_FAR * /*pmedium*/)
  93 {
  94         return E_NOTIMPL;
  95 }
  96
  97 STDMETHODIMP CIDataObject::QueryGetData(
  98         /* [unique][in] */ FORMATETC __RPC_FAR *pformatetc)
  99 {
 100         if (!pformatetc)
 101                 return E_INVALIDARG;
 102
 103         //support others if needed DVASPECT_THUMBNAIL  //DVASPECT_ICON   //DVASPECT_DOCPRINT
 104         if (!(DVASPECT_CONTENT & pformatetc->dwAspect))
 105                 return (DV_E_DVASPECT);
 106         HRESULT  hr = DV_E_TYMED;
 107         for(int i = 0; i < m_ArrFormatEtc.GetSize(); ++i)
 108         {
 109                 if(pformatetc->tymed & m_ArrFormatEtc[i]->tymed)
 110                 {
 111                         if(pformatetc->cfFormat == m_ArrFormatEtc[i]->cfFormat)
 112                                 return S_OK;
 113                         else
 114                                 hr = DV_E_CLIPFORMAT;
 115                 }
 116                 else
 117                         hr = DV_E_TYMED;
 118         }
 119         return hr;
 120 }
 121
 122 STDMETHODIMP CIDataObject::GetCanonicalFormatEtc(
 123         /* [unique][in] */ FORMATETC __RPC_FAR * /*pformatectIn*/,
 124         /* [out] */ FORMATETC __RPC_FAR *pformatetcOut)
 125 {
 126         if (!pformatetcOut)
 127                 return E_INVALIDARG;
 128         return DATA_S_SAMEFORMATETC;
 129 }
 130
 131 STDMETHODIMP CIDataObject::SetData(
 132         /* [unique][in] */ FORMATETC __RPC_FAR *pformatetc,
 133         /* [unique][in] */ STGMEDIUM __RPC_FAR *pmedium,
 134         /* [in] */ BOOL fRelease)
 135 {
 136         if (!pformatetc || !pmedium)
 137                 return E_INVALIDARG;
 138
 139         ATLASSERT(pformatetc->tymed == pmedium->tymed);
 140         FORMATETC* fetc = new (std::nothrow) FORMATETC;
 141         STGMEDIUM* pStgMed = new (std::nothrow) STGMEDIUM;
 142
 143         if (!fetc || !pStgMed)
 144         {
 145                 delete fetc;
 146                 delete pStgMed;
 147                 return E_OUTOFMEMORY;
 148         }
 149
 150         SecureZeroMemory(fetc,sizeof(FORMATETC));
 151         SecureZeroMemory(pStgMed,sizeof(STGMEDIUM));
 152
 153         // do we already store this format?
 154         for (int i=0; i<m_ArrFormatEtc.GetSize(); ++i)
 155         {
 156                 if ((pformatetc->tymed == m_ArrFormatEtc[i]->tymed) &&
 157                         (pformatetc->dwAspect == m_ArrFormatEtc[i]->dwAspect) &&
 158                         (pformatetc->cfFormat == m_ArrFormatEtc[i]->cfFormat))
 159                 {
 160                         // yes, this format is already in our object:
 161                         // we have to replace the existing format. To do that, we
 162                         // remove the format we already have
 163                         delete m_ArrFormatEtc[i];
 164                         m_ArrFormatEtc.RemoveAt(i);
 165                         ReleaseStgMedium(m_StgMedium[i]);
 166                         delete m_StgMedium[i];
 167                         m_StgMedium.RemoveAt(i);
 168                         break;
 169                 }
 170         }
 171
 172         *fetc = *pformatetc;
 173         m_ArrFormatEtc.Add(fetc);
 174
 175         if(fRelease)
 176                 *pStgMed = *pmedium;
 177         else
 178         {
 179                 CopyMedium(pStgMed, pmedium, pformatetc);
 180         }
 181         m_StgMedium.Add(pStgMed);
 182
 183         return S_OK;
 184 }
 185
 186 void CIDataObject::CopyMedium(STGMEDIUM* pMedDest, STGMEDIUM* pMedSrc, FORMATETC* pFmtSrc)
 187 {
 188         switch(pMedSrc->tymed)
 189         {
 190                 case TYMED_HGLOBAL:
 191                         pMedDest->hGlobal = (HGLOBAL)OleDuplicateData(pMedSrc->hGlobal,pFmtSrc->cfFormat, NULL);
 192                         break;
 193                 case TYMED_GDI:
 194                         pMedDest->hBitmap = (HBITMAP)OleDuplicateData(pMedSrc->hBitmap,pFmtSrc->cfFormat, NULL);
 195                         break;
 196                 case TYMED_MFPICT:
 197                         pMedDest->hMetaFilePict = (HMETAFILEPICT)OleDuplicateData(pMedSrc->hMetaFilePict,pFmtSrc->cfFormat, NULL);
 198                         break;
 199                 case TYMED_ENHMF:
 200                         pMedDest->hEnhMetaFile = (HENHMETAFILE)OleDuplicateData(pMedSrc->hEnhMetaFile,pFmtSrc->cfFormat, NULL);
 201                         break;
 202                 case TYMED_FILE:
 203                         pMedSrc->lpszFileName = (LPOLESTR)OleDuplicateData(pMedSrc->lpszFileName,pFmtSrc->cfFormat, NULL);
 204                         break;
 205                 case TYMED_ISTREAM:
 206                         pMedDest->pstm = pMedSrc->pstm;
 207                         pMedSrc->pstm->AddRef();
 208                         break;
 209                 case TYMED_ISTORAGE:
 210                         pMedDest->pstg = pMedSrc->pstg;
 211                         pMedSrc->pstg->AddRef();
 212                         break;
 213                 case TYMED_NULL:
 214                 default:
 215                         break;
 216         }
 217         pMedDest->tymed = pMedSrc->tymed;
 218         pMedDest->pUnkForRelease = nullptr;
 219         if (pMedSrc->pUnkForRelease)
 220         {
 221                 pMedDest->pUnkForRelease = pMedSrc->pUnkForRelease;
 222                 pMedSrc->pUnkForRelease->AddRef();
 223         }
 224 }
 225
 226 STDMETHODIMP CIDataObject::EnumFormatEtc(
 227         /* [in] */ DWORD dwDirection,
 228         /* [out] */ IEnumFORMATETC __RPC_FAR *__RPC_FAR *ppenumFormatEtc)
 229 {
 230         if (!ppenumFormatEtc)
 231                 return E_POINTER;
 232
 233         *ppenumFormatEtc = nullptr;
 234         switch (dwDirection)
 235         {
 236                 case DATADIR_GET:
 237                         *ppenumFormatEtc = new (std::nothrow) CEnumFormatEtc(m_ArrFormatEtc);
 238                         if (!*ppenumFormatEtc)
 239                                 return E_OUTOFMEMORY;
 240                         (*ppenumFormatEtc)->AddRef();
 241                         break;
 242                 case DATADIR_SET:
 243                 default:
 244                         return E_NOTIMPL;
 245                         break;
 246         }
 247         return S_OK;
 248 }
 249
 250 STDMETHODIMP CIDataObject::DAdvise(
 251         /* [in] */ FORMATETC __RPC_FAR * /*pformatetc*/,
 252         /* [in] */ DWORD /*advf*/,
 253         /* [unique][in] */ IAdviseSink __RPC_FAR * /*pAdvSink*/,
 254         /* [out] */ DWORD __RPC_FAR * /*pdwConnection*/)
 255 {
 256         return OLE_E_ADVISENOTSUPPORTED;
 257 }
 258
 259 STDMETHODIMP CIDataObject::DUnadvise(
 260         /* [in] */ DWORD /*dwConnection*/)
 261 {
 262         return E_NOTIMPL;
 263 }
 264
 265 HRESULT STDMETHODCALLTYPE CIDataObject::EnumDAdvise(
 266         /* [out] */ IEnumSTATDATA __RPC_FAR *__RPC_FAR * /*ppenumAdvise*/)
 267 {
 268         return OLE_E_ADVISENOTSUPPORTED;
 269 }
 270
 271
 272 HRESULT CIDataObject::SetDropDescription(DROPIMAGETYPE image, LPCTSTR format, LPCTSTR insert)
 273 {
 274         if (!format || !insert)
 275                 return E_INVALIDARG;
 276
 277         FORMATETC fetc = {0};
 278         fetc.cfFormat = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_DROPDESCRIPTION);
 279         fetc.dwAspect = DVASPECT_CONTENT;
 280         fetc.lindex = -1;
 281         fetc.tymed = TYMED_HGLOBAL;
 282
 283         STGMEDIUM medium = {0};
 284         medium.hGlobal = GlobalAlloc(GHND, sizeof(DROPDESCRIPTION));
 285         if (!medium.hGlobal)
 286                 return E_OUTOFMEMORY;
 287
 288         DROPDESCRIPTION* pDropDescription = (DROPDESCRIPTION*)GlobalLock(medium.hGlobal);
 289         if (pDropDescription == nullptr)
 290                 return E_OUTOFMEMORY;
 291         StringCchCopy(pDropDescription->szInsert, _countof(pDropDescription->szInsert), insert);
 292         StringCchCopy(pDropDescription->szMessage, _countof(pDropDescription->szMessage), format);
 293         pDropDescription->type = image;
 294         GlobalUnlock(medium.hGlobal);
 295         return SetData(&fetc, &medium, TRUE);
 296 }
 297
 298 //////////////////////////////////////////////////////////////////////
 299 // CIDropSource Class
 300 //////////////////////////////////////////////////////////////////////
 301
 302 STDMETHODIMP CIDropSource::QueryInterface(/* [in] */ REFIID riid,
 303                                                                                  /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 304 {
 305         if (!ppvObject)
 306         {
 307                 return E_POINTER;
 308         }
 309
 310         if (IsEqualIID(riid, IID_IUnknown))
 311         {
 312                 *ppvObject = static_cast<IDropSource*>(this);
 313         }
 314         else if (IsEqualIID(riid, IID_IDropSource))
 315         {
 316                 *ppvObject = static_cast<IDropSource*>(this);
 317         }
 318         else if (IsEqualIID(riid, IID_IDropSourceNotify) && pDragSourceNotify)
 319         {
 320                 return pDragSourceNotify->QueryInterface(riid, ppvObject);
 321         }
 322         else
 323         {
 324                 *ppvObject = nullptr;
 325                 return E_NOINTERFACE;
 326         }
 327
 328         AddRef();
 329         return S_OK;
 330 }
 331
 332 STDMETHODIMP_(ULONG) CIDropSource::AddRef( void)
 333 {
 334         return ++m_cRefCount;
 335 }
 336
 337 STDMETHODIMP_(ULONG) CIDropSource::Release( void)
 338 {
 339         long nTemp;
 340         nTemp = --m_cRefCount;
 341         ATLASSERT(nTemp >= 0);
 342         if(nTemp==0)
 343                 delete this;
 344         return nTemp;
 345 }
 346
 347 STDMETHODIMP CIDropSource::QueryContinueDrag(
 348         /* [in] */ BOOL fEscapePressed,
 349         /* [in] */ DWORD grfKeyState)
 350 {
 351         if(fEscapePressed)
 352                 return DRAGDROP_S_CANCEL;
 353         if(!(grfKeyState & (MK_LBUTTON|MK_RBUTTON)))
 354         {
 355                 m_bDropped = true;
 356                 return DRAGDROP_S_DROP;
 357         }
 358
 359         return S_OK;
 360 }
 361
 362 STDMETHODIMP CIDropSource::GiveFeedback(
 363         /* [in] */ DWORD /*dwEffect*/)
 364 {
 365         if (m_pIDataObj)
 366         {
 367                 FORMATETC fetc = {0};
 368                 fetc.cfFormat = (CLIPFORMAT)RegisterClipboardFormat(L"DragWindow");
 369                 fetc.dwAspect = DVASPECT_CONTENT;
 370                 fetc.lindex = -1;
 371                 fetc.tymed = TYMED_HGLOBAL;
 372                 if (m_pIDataObj->QueryGetData(&fetc) == S_OK)
 373                 {
 374                         STGMEDIUM medium;
 375                         if (m_pIDataObj->GetData(&fetc, &medium) == S_OK)
 376                         {
 377                                 HWND hWndDragWindow = *((HWND*) GlobalLock(medium.hGlobal));
 378                                 GlobalUnlock(medium.hGlobal);
 379 #define WM_INVALIDATEDRAGIMAGE (WM_USER + 3)
 380                                 SendMessage(hWndDragWindow, WM_INVALIDATEDRAGIMAGE, NULL, NULL);
 381                                 ReleaseStgMedium(&medium);
 382                         }
 383                 }
 384         }
 385         return DRAGDROP_S_USEDEFAULTCURSORS;
 386 }
 387
 388 //////////////////////////////////////////////////////////////////////
 389 // CEnumFormatEtc Class
 390 //////////////////////////////////////////////////////////////////////
 391
 392 CEnumFormatEtc::CEnumFormatEtc(const CSimpleArray<FORMATETC>& ArrFE):
 393 m_cRefCount(0),m_iCur(0)
 394 {
 395         ATLTRACE("CEnumFormatEtc::CEnumFormatEtc()\n");
 396         for(int i = 0; i < ArrFE.GetSize(); ++i)
 397                 m_pFmtEtc.Add(ArrFE[i]);
 398 }
 399
 400 CEnumFormatEtc::CEnumFormatEtc(const CSimpleArray<FORMATETC*>& ArrFE):
 401 m_cRefCount(0),m_iCur(0)
 402 {
 403         for(int i = 0; i < ArrFE.GetSize(); ++i)
 404                 m_pFmtEtc.Add(*ArrFE[i]);
 405 }
 406
 407 STDMETHODIMP CEnumFormatEtc::QueryInterface(REFIID refiid, void FAR* FAR* ppv)
 408 {
 409         if (!ppv)
 410                 return E_POINTER;
 411         *ppv = nullptr;
 412         if (IID_IUnknown == refiid || IID_IEnumFORMATETC == refiid)
 413                 *ppv = static_cast<IEnumFORMATETC*>(this);
 414         else
 415                 return E_NOINTERFACE;
 416
 417         AddRef();
 418         return S_OK;
 419 }
 420
 421 STDMETHODIMP_(ULONG) CEnumFormatEtc::AddRef(void)
 422 {
 423         return ++m_cRefCount;
 424 }
 425
 426 STDMETHODIMP_(ULONG) CEnumFormatEtc::Release(void)
 427 {
 428         long nTemp = --m_cRefCount;
 429         ATLASSERT(nTemp >= 0);
 430         if(nTemp == 0)
 431          delete this;
 432
 433         return nTemp;
 434 }
 435
 436 STDMETHODIMP CEnumFormatEtc::Next( ULONG celt,LPFORMATETC lpFormatEtc, ULONG FAR *pceltFetched)
 437 {
 438         if(celt <= 0)
 439                 return E_INVALIDARG;
 440         if (!pceltFetched && celt != 1) // pceltFetched can be nullptr only for 1 item request
 441                 return E_POINTER;
 442         if (!lpFormatEtc)
 443                 return E_POINTER;
 444
 445         if (pceltFetched)
 446                 *pceltFetched = 0;
 447         if (m_iCur >= m_pFmtEtc.GetSize())
 448                 return S_FALSE;
 449
 450         ULONG cReturn = celt;
 451         while (m_iCur < m_pFmtEtc.GetSize() && cReturn > 0)
 452         {
 453                 *lpFormatEtc++ = m_pFmtEtc[m_iCur++];
 454                 --cReturn;
 455         }
 456         if (pceltFetched)
 457                 *pceltFetched = celt - cReturn;
 458
 459         return (cReturn == 0) ? S_OK : S_FALSE;
 460 }
 461
 462 STDMETHODIMP CEnumFormatEtc::Skip(ULONG celt)
 463 {
 464         if((m_iCur + int(celt)) >= m_pFmtEtc.GetSize())
 465                 return S_FALSE;
 466         m_iCur += celt;
 467         return S_OK;
 468 }
 469
 470 STDMETHODIMP CEnumFormatEtc::Reset(void)
 471 {
 472         m_iCur = 0;
 473         return S_OK;
 474 }
 475
 476 STDMETHODIMP CEnumFormatEtc::Clone(IEnumFORMATETC FAR * FAR*ppCloneEnumFormatEtc)
 477 {
 478         if (!ppCloneEnumFormatEtc)
 479                 return E_POINTER;
 480
 481         CEnumFormatEtc *newEnum = new (std::nothrow) CEnumFormatEtc(m_pFmtEtc);
 482         if (!newEnum)
 483                 return E_OUTOFMEMORY;
 484   newEnum->AddRef();
 485         newEnum->m_iCur = m_iCur;
 486         *ppCloneEnumFormatEtc = newEnum;
 487         return S_OK;
 488 }
 489
 490 //////////////////////////////////////////////////////////////////////
 491 // CIDropTarget Class
 492 //////////////////////////////////////////////////////////////////////
 493 CIDropTarget::CIDropTarget(HWND hTargetWnd):
 494         m_hTargetWnd(hTargetWnd),
 495         m_cRefCount(0), m_bAllowDrop(false),
 496         m_pDropTargetHelper(nullptr),
 497         m_pSupportedFrmt(nullptr),
 498         m_pIDataObject(nullptr)
 499 {
 500         if (FAILED(CoCreateInstance(CLSID_DragDropHelper, nullptr, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper, (LPVOID*)&m_pDropTargetHelper)))
 501                 m_pDropTargetHelper = nullptr;
 502 }
 503
 504 CIDropTarget::~CIDropTarget()
 505 {
 506         if (m_pDropTargetHelper)
 507         {
 508                 m_pDropTargetHelper->Release();
 509                 m_pDropTargetHelper = nullptr;
 510         }
 511 }
 512
 513 HRESULT STDMETHODCALLTYPE CIDropTarget::QueryInterface( /* [in] */ REFIID riid,
 514                                                 /* [iid_is][out] */ void __RPC_FAR *__RPC_FAR *ppvObject)
 515 {
 516         if (!ppvObject)
 517                 return E_POINTER;
 518         *ppvObject = nullptr;
 519         if (IID_IUnknown == riid || IID_IDropTarget == riid)
 520                 *ppvObject = static_cast<IDropTarget*>(this);
 521         else
 522                 return E_NOINTERFACE;
 523
 524         AddRef();
 525         return S_OK;
 526 }
 527
 528 ULONG STDMETHODCALLTYPE CIDropTarget::Release( void)
 529 {
 530         long nTemp;
 531         nTemp = --m_cRefCount;
 532         ATLASSERT(nTemp >= 0);
 533         if(nTemp==0)
 534                 delete this;
 535         return nTemp;
 536 }
 537
 538 bool CIDropTarget::QueryDrop(DWORD grfKeyState, LPDWORD pdwEffect)
 539 {
 540         DWORD dwOKEffects = *pdwEffect;
 541
 542         if(!m_bAllowDrop)
 543         {
 544                 *pdwEffect = DROPEFFECT_NONE;
 545                 return false;
 546         }
 547         //CTRL+SHIFT  -- DROPEFFECT_LINK
 548         //CTRL        -- DROPEFFECT_COPY
 549         //SHIFT       -- DROPEFFECT_MOVE
 550         //no modifier -- DROPEFFECT_MOVE or whatever is allowed by src
 551         *pdwEffect = (grfKeyState & MK_CONTROL) ?
 552                                 ( (grfKeyState & MK_SHIFT) ? DROPEFFECT_LINK : DROPEFFECT_COPY ):
 553                                 ( (grfKeyState & MK_SHIFT) ? DROPEFFECT_MOVE : 0 );
 554         if(*pdwEffect == 0)
 555         {
 556                 // No modifier keys used by user while dragging.
 557                 if (DROPEFFECT_MOVE & dwOKEffects)
 558                         *pdwEffect = DROPEFFECT_MOVE;
 559                 else if (DROPEFFECT_COPY & dwOKEffects)
 560                         *pdwEffect = DROPEFFECT_COPY;
 561                 else if (DROPEFFECT_LINK & dwOKEffects)
 562                         *pdwEffect = DROPEFFECT_LINK;
 563                 else
 564                 {
 565                         *pdwEffect = DROPEFFECT_NONE;
 566                 }
 567         }
 568         else
 569         {
 570                 // Check if the drag source application allows the drop effect desired by user.
 571                 // The drag source specifies this in DoDragDrop
 572                 if(!(*pdwEffect & dwOKEffects))
 573                         *pdwEffect = DROPEFFECT_NONE;
 574         }
 575
 576         return (DROPEFFECT_NONE == *pdwEffect)?false:true;
 577 }
 578
 579 HRESULT STDMETHODCALLTYPE CIDropTarget::DragEnter(
 580         /* [unique][in] */ IDataObject __RPC_FAR *pDataObj,
 581         /* [in] */ DWORD grfKeyState,
 582         /* [in] */ POINTL pt,
 583         /* [out][in] */ DWORD __RPC_FAR *pdwEffect)
 584 {
 585         if (!pDataObj)
 586                 return E_INVALIDARG;
 587         if (!pdwEffect)
 588                 return E_POINTER;
 589
 590         pDataObj->AddRef();
 591         m_pIDataObject = pDataObj;
 592
 593         if(m_pDropTargetHelper)
 594                 m_pDropTargetHelper->DragEnter(m_hTargetWnd, pDataObj, (LPPOINT)&pt, *pdwEffect);
 595
 596         m_pSupportedFrmt = nullptr;
 597         for(int i =0; i<m_formatetc.GetSize(); ++i)
 598         {
 599                 m_bAllowDrop = (pDataObj->QueryGetData(&m_formatetc[i]) == S_OK);
 600                 if(m_bAllowDrop)
 601                 {
 602                         m_pSupportedFrmt = &m_formatetc[i];
 603                         break;
 604                 }
 605         }
 606
 607         QueryDrop(grfKeyState, pdwEffect);
 608         return S_OK;
 609 }
 610
 611 HRESULT STDMETHODCALLTYPE CIDropTarget::DragOver(
 612                 /* [in] */ DWORD grfKeyState,
 613                 /* [in] */ POINTL pt,
 614                 /* [out][in] */ DWORD __RPC_FAR *pdwEffect)
 615 {
 616         if (!pdwEffect)
 617                 return E_POINTER;
 618         if(m_pDropTargetHelper)
 619                 m_pDropTargetHelper->DragOver((LPPOINT)&pt, *pdwEffect);
 620         QueryDrop(grfKeyState, pdwEffect);
 621         return S_OK;
 622 }
 623
 624 HRESULT STDMETHODCALLTYPE CIDropTarget::DragLeave( void)
 625 {
 626         if(m_pDropTargetHelper)
 627                 m_pDropTargetHelper->DragLeave();
 628
 629         m_bAllowDrop = false;
 630         m_pSupportedFrmt = nullptr;
 631         m_pIDataObject->Release();
 632         m_pIDataObject = nullptr;
 633         return S_OK;
 634 }
 635
 636 HRESULT STDMETHODCALLTYPE CIDropTarget::Drop(
 637         /* [unique][in] */ IDataObject __RPC_FAR *pDataObj,
 638         /* [in] */ DWORD grfKeyState, /* [in] */ POINTL pt,
 639         /* [out][in] */ DWORD __RPC_FAR *pdwEffect)
 640 {
 641         if (!pDataObj)
 642                 return E_INVALIDARG;
 643         if (!pdwEffect)
 644                 return E_POINTER;
 645
 646         if(m_pDropTargetHelper)
 647                 m_pDropTargetHelper->Drop(pDataObj, (LPPOINT)&pt, *pdwEffect);
 648
 649         if(QueryDrop(grfKeyState, pdwEffect))
 650         {
 651                 if (m_bAllowDrop && m_pSupportedFrmt)
 652                 {
 653                         STGMEDIUM medium;
 654                         if(pDataObj->GetData(m_pSupportedFrmt, &medium) == S_OK)
 655                         {
 656                                 if(OnDrop(m_pSupportedFrmt, medium, pdwEffect, pt)) //does derive class wants us to free medium?
 657                                         ReleaseStgMedium(&medium);
 658                         }
 659                 }
 660         }
 661         m_bAllowDrop=false;
 662         *pdwEffect = DROPEFFECT_NONE;
 663         m_pSupportedFrmt = nullptr;
 664         if (m_pIDataObject) // just in case we get a drop without first receiving DragEnter()
 665                 m_pIDataObject->Release();
 666         m_pIDataObject = nullptr;
 667         return S_OK;
 668 }
 669
 670 HRESULT CIDropTarget::SetDropDescription(DROPIMAGETYPE image, LPCTSTR format, LPCTSTR insert)
 671 {
 672         HRESULT hr = E_OUTOFMEMORY;
 673
 674         FORMATETC fetc = {0};
 675         fetc.cfFormat = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_DROPDESCRIPTION);
 676         fetc.dwAspect = DVASPECT_CONTENT;
 677         fetc.lindex = -1;
 678         fetc.tymed = TYMED_HGLOBAL;
 679
 680         STGMEDIUM medium = {0};
 681         medium.tymed = TYMED_HGLOBAL;
 682         medium.hGlobal = GlobalAlloc(GHND, sizeof(DROPDESCRIPTION));
 683         if(medium.hGlobal)
 684         {
 685                 DROPDESCRIPTION* pDropDescription = (DROPDESCRIPTION*)GlobalLock(medium.hGlobal);
 686                 if (pDropDescription == nullptr)
 687                         return hr;
 688
 689                 if (insert)
 690                         StringCchCopy(pDropDescription->szInsert, _countof(pDropDescription->szInsert), insert);
 691                 else
 692                         pDropDescription->szInsert[0] = 0;
 693                 if (format)
 694                         StringCchCopy(pDropDescription->szMessage, _countof(pDropDescription->szMessage), format);
 695                 else
 696                         pDropDescription->szMessage[0] = 0;
 697                 pDropDescription->type = image;
 698                 GlobalUnlock(medium.hGlobal);
 699
 700                 hr = m_pIDataObject->SetData(&fetc, &medium, TRUE);
 701                 if (FAILED(hr))
 702                 {
 703                         GlobalFree(medium.hGlobal);
 704                 }
 705         }
 706
 707         return hr;
 708 }
 709
 710
 711 //////////////////////////////////////////////////////////////////////
 712 // CIDragSourceHelper Class
 713 //////////////////////////////////////////////////////////////////////