开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > ListView/ListBox > 查看源码
DragDrop.h
资源名称：vistaListCtrlDemo.zip　[点击查看]
上传用户：sztopon
上传日期：2014-01-21
资源大小：55k
文件大小：20k
源码类别：

ListView/ListBox

开发平台：

Visual C++

DragDrop.h：源码内容
  2. #pragma once
  4. #include <vector>
  5. #include <shlobj.h>
  7. using namespace std;
  9. class CEnumFormatEtc : public IEnumFORMATETC
  10. {
  11. public:
  12. CEnumFormatEtc( const vector < FORMATETC >& vFormatEtc )
  13. {
  14. m_nRefCount = 0;
  15. m_nIndex = 0;
  16. m_vFormatEtc = vFormatEtc;
  17. }
  19. protected:
  20. vector < FORMATETC > m_vFormatEtc;
  21. int m_nRefCount;
  22. int m_nIndex;
  24. public:
  25. // IUnknown members
  26. STDMETHOD(QueryInterface)( REFIID refiid, void FAR* FAR* ppvObject )
  27. {
  28. *ppvObject = ( refiid == IID_IUnknown || refiid == IID_IEnumFORMATETC ) ? this : NULL;
  30. if ( *ppvObject != NULL )
  31. ( (LPUNKNOWN)*ppvObject )->AddRef();
  33. return *ppvObject == NULL ? E_NOINTERFACE : S_OK;
  34. }
  36. STDMETHOD_(ULONG, AddRef)( void )
  37. {
  38. return ++m_nRefCount;
  39. }
  41. STDMETHOD_(ULONG, Release)( void )
  42. {
  43. int nRefCount = --m_nRefCount;
  44. if ( nRefCount == 0 )
  45. delete this;
  46. return nRefCount;
  47. }
  49. // IEnumFORMATETC members
  50. STDMETHOD(Next)( ULONG celt, LPFORMATETC lpFormatEtc, ULONG FAR *pceltFetched )
  51. {
  52. if ( pceltFetched != NULL )
  53. *pceltFetched=0;
  55. ULONG cReturn = celt;
  57. if ( celt <= 0 || lpFormatEtc == NULL || m_nIndex >= (int)m_vFormatEtc.size() )
  58. return S_FALSE;
  60. if ( pceltFetched == NULL && celt != 1 ) // pceltFetched can be NULL only for 1 item request
  61. return S_FALSE;
  63. while ( m_nIndex < (int)m_vFormatEtc.size() && cReturn > 0 )
  64. {
  65. *lpFormatEtc++ = m_vFormatEtc[ m_nIndex++ ];
  66. cReturn--;
  67. }
  69. if ( pceltFetched != NULL )
  70. *pceltFetched = celt - cReturn;
  72. return cReturn == 0 ? S_OK : S_FALSE;
  73. }
  75. STDMETHOD(Skip)( ULONG celt )
  76. {
  77. if ( ( m_nIndex + (int)celt ) >= (int)m_vFormatEtc.size() )
  78. return S_FALSE;
  79. m_nIndex += celt;
  80. return S_OK;
  81. }
  83. STDMETHOD(Reset)( void )
  84. {
  85. m_nIndex = 0;
  86. return S_OK;
  87. }
  89. STDMETHOD(Clone)( IEnumFORMATETC FAR * FAR* ppCloneEnumFormatEtc )
  90. {
  91. if ( ppCloneEnumFormatEtc == NULL )
  92. return E_POINTER;
  94. *ppCloneEnumFormatEtc = new CEnumFormatEtc( m_vFormatEtc );
  95. ( (CEnumFormatEtc*)*ppCloneEnumFormatEtc )->AddRef();
  96. ( (CEnumFormatEtc*)*ppCloneEnumFormatEtc )->m_nIndex = m_nIndex;
  98. return S_OK;
  99. }
  100. };
  102. class CDropSource : public IDropSource
  103. {
  104. public:
  105. CDropSource()
  106. {
  107. m_nRefCount = 0;
  108. }
  110. protected:
  111. int m_nRefCount;
  113. public:
  114. // IUnknown members
  115. STDMETHOD(QueryInterface)( REFIID refiid, void FAR* FAR* ppvObject )
  116. {
  117. *ppvObject = ( refiid == IID_IUnknown || refiid == IID_IDropSource ) ? this : NULL;
  119. if ( *ppvObject != NULL )
  120. ( (LPUNKNOWN)*ppvObject )->AddRef();
  122. return *ppvObject == NULL ? E_NOINTERFACE : S_OK;
  123. }
  125. STDMETHOD_(ULONG, AddRef)( void )
  126. {
  127. return ++m_nRefCount;
  128. }
  130. STDMETHOD_(ULONG, Release)( void )
  131. {
  132. int nRefCount = --m_nRefCount;
  133. if ( nRefCount == 0 )
  134. delete this;
  135. return nRefCount;
  136. }
  138. // IDropSource members
  139. STDMETHOD(QueryContinueDrag)( BOOL bEscapePressed, DWORD dwKeyState )
  140. {
  141. if ( bEscapePressed )
  142. return DRAGDROP_S_CANCEL;
  144. if ( !( dwKeyState & ( MK_LBUTTON | MK_RBUTTON ) ) )
  145. return DRAGDROP_S_DROP;
  147. return S_OK;
  148. }
  150.     STDMETHOD(GiveFeedback)( DWORD dwEffect )
  151.     {
  152. return DRAGDROP_S_USEDEFAULTCURSORS;
  153.     }
  154. };
  156. class CDataObject : public IDataObject
  157. {
  158. public:
  159. CDataObject( CDropSource *pDropSource )
  160. {
  161. m_nRefCount = 0;
  162. m_pDropSource = pDropSource;
  163. m_bSwappedButtons = GetSystemMetrics( SM_SWAPBUTTON );
  164. }
  166. virtual ~CDataObject()
  167. {
  168. for ( vector < STGMEDIUM >::iterator posStgMedium = m_vStgMedium.begin(); posStgMedium != m_vStgMedium.end(); posStgMedium++ )
  169. ReleaseStgMedium( &( *posStgMedium ) );
  170. }
  172. protected:
  173. CDropSource *m_pDropSource;
  174. int m_nRefCount;
  175. BOOL m_bSwappedButtons;
  177. vector < FORMATETC > m_vFormatEtc;
  178. vector < STGMEDIUM > m_vStgMedium;
  180. public:
  181. // IUnknown members
  182. STDMETHOD(QueryInterface)( REFIID refiid, void FAR* FAR* ppvObject )
  183. {
  184. *ppvObject = ( refiid == IID_IUnknown || refiid == IID_IDataObject ) ? this : NULL;
  186. if ( *ppvObject != NULL )
  187. ( (LPUNKNOWN)*ppvObject )->AddRef();
  189. return *ppvObject == NULL ? E_NOINTERFACE : S_OK;
  190. }
  192. STDMETHOD_(ULONG, AddRef)( void )
  193. {
  194. return ++m_nRefCount;
  195. }
  197. STDMETHOD_(ULONG, Release)( void )
  198. {
  199. int nRefCount = --m_nRefCount;
  200. if ( nRefCount == 0 )
  201. delete this;
  202. return nRefCount;
  203. }
  205. // IDataObject members
  206. STDMETHOD(GetData)( FORMATETC __RPC_FAR *pformatetcIn, STGMEDIUM __RPC_FAR *pmedium )
  207. {
  208. if ( pformatetcIn == NULL || pmedium == NULL )
  209. return E_INVALIDARG;
  211. ZeroMemory( pmedium, sizeof( STGMEDIUM ) );
  213. for ( int nFormatEtc = 0; nFormatEtc < (int)m_vFormatEtc.size(); nFormatEtc++ )
  214. {
  215. if ( pformatetcIn->tymed & m_vFormatEtc[ nFormatEtc ].tymed &&
  216.  pformatetcIn->dwAspect == m_vFormatEtc[ nFormatEtc ].dwAspect &&
  217.  pformatetcIn->cfFormat == m_vFormatEtc[ nFormatEtc ].cfFormat )
  218. {
  219. if ( m_vStgMedium[ nFormatEtc ].tymed == TYMED_NULL )
  220. return OnRenderData( m_vFormatEtc[ nFormatEtc ], pmedium, ( GetAsyncKeyState( m_bSwappedButtons ? VK_RBUTTON : VK_LBUTTON ) >= 0 ) ) ? S_OK : DV_E_FORMATETC;
  222. CopyMedium( pmedium, m_vStgMedium[ nFormatEtc ], m_vFormatEtc[ nFormatEtc ] );
  223. return S_OK;
  224. }
  225. }
  227. return DV_E_FORMATETC;
  228. }
  230. STDMETHOD(GetDataHere)( FORMATETC __RPC_FAR *pformatetc, STGMEDIUM __RPC_FAR *pmedium )
  231. {
  232. return E_NOTIMPL;
  233. }
  235. STDMETHOD(QueryGetData)( FORMATETC __RPC_FAR *pformatetc )
  236. {
  237. if ( pformatetc == NULL )
  238. return E_INVALIDARG;
  240. if ( !( pformatetc->dwAspect & DVASPECT_CONTENT ) )
  241. return DV_E_DVASPECT;
  243. HRESULT hResult = DV_E_TYMED;
  244. for ( int nFormatEtc = 0; nFormatEtc < (int)m_vFormatEtc.size(); nFormatEtc++ )
  245. {
  246. if ( !( pformatetc->tymed & m_vFormatEtc[ nFormatEtc ].tymed ) )
  247. {
  248. hResult = DV_E_TYMED;
  249. continue;
  250. }
  252. if ( pformatetc->cfFormat == m_vFormatEtc[ nFormatEtc ].cfFormat )
  253. return S_OK;
  255. hResult = DV_E_CLIPFORMAT;
  256. }
  258. return hResult;
  259. }
  261. STDMETHOD(GetCanonicalFormatEtc)( FORMATETC __RPC_FAR *pformatectIn, FORMATETC __RPC_FAR *pformatetcOut )
  262. {
  263. return pformatetcOut == NULL ? E_INVALIDARG : DATA_S_SAMEFORMATETC;
  264. }
  265.     
  266.     STDMETHOD(SetData)( FORMATETC __RPC_FAR *pformatetc, STGMEDIUM __RPC_FAR *pmedium, BOOL bRelease )
  267.     {
  268. if ( pformatetc == NULL || pmedium == NULL )
  269. return E_INVALIDARG;
  271. m_vFormatEtc.push_back( *pformatetc );
  273. STGMEDIUM StgMedium = *pmedium;
  274.  
  275. if ( !bRelease )
  276. CopyMedium( &StgMedium, *pmedium, *pformatetc );
  278. m_vStgMedium.push_back( StgMedium );
  280. return S_OK;
  281.     }
  282.     
  283.     STDMETHOD(EnumFormatEtc)( DWORD dwDirection, IEnumFORMATETC __RPC_FAR *__RPC_FAR *ppenumFormatEtc )
  284.     {
  285. if ( ppenumFormatEtc == NULL )
  286. return E_POINTER;
  288. switch ( dwDirection )
  289. {
  290. case DATADIR_GET: *ppenumFormatEtc = new CEnumFormatEtc( m_vFormatEtc );
  291. ( (CEnumFormatEtc*)*ppenumFormatEtc )->AddRef();
  292. return S_OK;
  293. default: *ppenumFormatEtc = NULL;
  294. return E_NOTIMPL;
  295. }
  296.     }
  297.     
  298.     STDMETHOD(DAdvise)( FORMATETC __RPC_FAR *pformatetc, DWORD advf, IAdviseSink __RPC_FAR *pAdvSink, DWORD __RPC_FAR *pdwConnection )
  299.     {
  300. return OLE_E_ADVISENOTSUPPORTED;
  301.     }
  302.     
  303.     STDMETHOD(DUnadvise)( DWORD dwConnection )
  304.     {
  305. return E_NOTIMPL;
  306.     }
  307.     
  308.     STDMETHOD(EnumDAdvise)( IEnumSTATDATA __RPC_FAR *__RPC_FAR *ppenumAdvise )
  309.     {
  310. return OLE_E_ADVISENOTSUPPORTED;
  311.     }
  312.        
  313. void CopyMedium( STGMEDIUM *pMedDest, STGMEDIUM& MedSrc, FORMATETC& FmtSrc )
  314. {
  315. switch( MedSrc.tymed )
  316. {
  317. case TYMED_HGLOBAL: pMedDest->hGlobal = (HGLOBAL)OleDuplicateData( MedSrc.hGlobal, FmtSrc.cfFormat, NULL );
  318. break;
  319. case TYMED_GDI: pMedDest->hBitmap = (HBITMAP)OleDuplicateData( MedSrc.hBitmap, FmtSrc.cfFormat, NULL );
  320. break;
  321. case TYMED_MFPICT: pMedDest->hMetaFilePict = (HMETAFILEPICT)OleDuplicateData( MedSrc.hMetaFilePict, FmtSrc.cfFormat, NULL );
  322. break;
  323. case TYMED_ENHMF: pMedDest->hEnhMetaFile = (HENHMETAFILE)OleDuplicateData( MedSrc.hEnhMetaFile, FmtSrc.cfFormat, NULL );
  324. break;
  325. case TYMED_FILE: pMedDest->lpszFileName = (LPOLESTR)OleDuplicateData( MedSrc.lpszFileName, FmtSrc.cfFormat, NULL );
  326. break;
  327. case TYMED_ISTREAM: pMedDest->pstm = MedSrc.pstm;
  328. MedSrc.pstm->AddRef();
  329. break;
  330. case TYMED_ISTORAGE: pMedDest->pstg = MedSrc.pstg;
  331. MedSrc.pstg->AddRef();
  332. break;
  333. }
  335. pMedDest->tymed = MedSrc.tymed;
  336. pMedDest->pUnkForRelease = NULL;
  338. if ( MedSrc.pUnkForRelease != NULL )
  339. {
  340. pMedDest->pUnkForRelease = MedSrc.pUnkForRelease;
  341. MedSrc.pUnkForRelease->AddRef();
  342. }
  343. }
  345. virtual BOOL OnRenderData( FORMATETC& FormatEtc, STGMEDIUM *pStgMedium, BOOL bDropComplete )
  346. {
  347. return FALSE;
  348. }
  349. };
  351. class CDropTarget : public IDropTarget
  352. {
  353. public:
  354. CDropTarget( HWND hTargetWnd )
  355. {
  356. m_hTargetWnd = hTargetWnd;
  357. m_nRefCount = 0;
  358. m_bAllowDrop = FALSE;
  359. m_pDropTargetHelper = NULL;
  360. ZeroMemory( &m_FormatEtc, sizeof( FORMATETC ) );
  361. ZeroMemory( &m_StgMedium, sizeof( STGMEDIUM ) );
  363. if ( FAILED( CoCreateInstance( CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER, IID_IDropTargetHelper, (LPVOID*)&m_pDropTargetHelper ) ) )
  364. m_pDropTargetHelper = NULL;
  365. }
  367. virtual ~CDropTarget()
  368. {
  369. if ( m_pDropTargetHelper != NULL )
  370. {
  371. m_pDropTargetHelper->Release();
  372. m_pDropTargetHelper = NULL;
  373. }
  374. }
  376. protected:
  377. HWND m_hTargetWnd;
  378. int m_nRefCount;
  379. struct IDropTargetHelper *m_pDropTargetHelper;
  380. vector < FORMATETC > m_vFormatEtc;
  381. BOOL m_bAllowDrop;
  382. FORMATETC m_FormatEtc;
  383. STGMEDIUM m_StgMedium;
  385. public:
  386. // IUnknown members
  387. STDMETHOD(QueryInterface)( REFIID refiid, void FAR* FAR* ppvObject )
  388. {
  389. *ppvObject = ( refiid == IID_IUnknown || refiid == IID_IDropTarget ) ? this : NULL;
  391. if ( *ppvObject != NULL )
  392. ( (LPUNKNOWN)*ppvObject )->AddRef();
  394. return *ppvObject == NULL ? E_NOINTERFACE : S_OK;
  395. }
  397. STDMETHOD_(ULONG, AddRef)( void )
  398. {
  399. return ++m_nRefCount;
  400. }
  402. STDMETHOD_(ULONG, Release)( void )
  403. {
  404. int nRefCount = --m_nRefCount;
  405. if ( nRefCount == 0 )
  406. delete this;
  407. return nRefCount;
  408. }
  410. STDMETHOD(DragEnter)( IDataObject __RPC_FAR *pDataObject, DWORD dwKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect )
  411. {
  412. if ( pDataObject == NULL )
  413. return E_INVALIDARG;
  415. if ( m_pDropTargetHelper != NULL )
  416. m_pDropTargetHelper->DragEnter( m_hTargetWnd, pDataObject, (LPPOINT)&pt, *pdwEffect );
  418. ZeroMemory( &m_FormatEtc, sizeof( FORMATETC ) );
  419. if ( m_StgMedium.tymed != TYMED_NULL )
  420. ReleaseStgMedium( &m_StgMedium );
  421. ZeroMemory( &m_StgMedium, sizeof( STGMEDIUM ) );
  423. for ( int nFormatEtc = 0; nFormatEtc < (int)m_vFormatEtc.size(); nFormatEtc++ )
  424. {
  425. STGMEDIUM StgMedium;
  426. m_bAllowDrop = ( pDataObject->GetData( &m_vFormatEtc[ nFormatEtc ], &StgMedium ) == S_OK );
  428. if ( m_bAllowDrop )
  429. {
  430. // store drag data for later use in DragOver
  431. m_FormatEtc = m_vFormatEtc[ nFormatEtc ];
  432. m_StgMedium = StgMedium;
  434. // get client cursor position
  435. CWindow hWnd( m_hTargetWnd );
  436. CPoint point( pt.x, pt.y );
  437. hWnd.ScreenToClient( &point );
  439. *pdwEffect = OnDragEnter( m_FormatEtc, m_StgMedium, dwKeyState, point );
  441. break;
  442. }
  443. }
  445. QueryDrop( dwKeyState, pdwEffect );
  447. return S_OK;
  448. }
  450. STDMETHOD(DragOver)( DWORD dwKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect )
  451. {
  452. if ( m_pDropTargetHelper )
  453. m_pDropTargetHelper->DragOver( (LPPOINT)&pt, *pdwEffect );
  455. if ( m_bAllowDrop && m_FormatEtc.cfFormat != CF_NULL && m_StgMedium.tymed != TYMED_NULL )
  456. {
  457. // get client cursor position
  458. CWindow hWnd( m_hTargetWnd );
  459. CPoint point( pt.x, pt.y );
  460. hWnd.ScreenToClient( &point );
  462. *pdwEffect = OnDragOver( m_FormatEtc, m_StgMedium, dwKeyState, point );
  463. }
  465. QueryDrop( dwKeyState, pdwEffect );
  467. return S_OK;
  468. }
  470. STDMETHOD(DragLeave)( void )
  471. {
  472. if ( m_pDropTargetHelper )
  473. m_pDropTargetHelper->DragLeave();
  475. OnDragLeave();
  477. m_bAllowDrop = FALSE;
  479. ZeroMemory( &m_FormatEtc, sizeof( FORMATETC ) );
  480. if ( m_StgMedium.tymed != TYMED_NULL )
  481. ReleaseStgMedium( &m_StgMedium );
  482. ZeroMemory( &m_StgMedium, sizeof( STGMEDIUM ) );
  484. return S_OK;
  485. }
  487. STDMETHOD(Drop)( IDataObject __RPC_FAR *pDataObject, DWORD dwKeyState, POINTL pt, DWORD __RPC_FAR *pdwEffect )
  488.     {
  489. if ( pDataObject == NULL )
  490. return E_INVALIDARG;
  492. if ( m_pDropTargetHelper )
  493. m_pDropTargetHelper->Drop( pDataObject, (LPPOINT)&pt, *pdwEffect );
  495. if ( m_bAllowDrop && m_FormatEtc.cfFormat != CF_NULL && QueryDrop( dwKeyState, pdwEffect ) )
  496. {
  497. STGMEDIUM StgMedium;
  498. if ( pDataObject->GetData( &m_FormatEtc, &StgMedium ) == S_OK )
  499. {
  500. // get client cursor position
  501. CWindow hWnd( m_hTargetWnd );
  502. CPoint point( pt.x, pt.y );
  503. hWnd.ScreenToClient( &point );
  505. if ( !OnDrop( m_FormatEtc, StgMedium, *pdwEffect, point ) )
  506. *pdwEffect = DROPEFFECT_NONE;
  508. ReleaseStgMedium( &StgMedium );
  509. }
  510. }
  512. m_bAllowDrop = FALSE;
  514. ZeroMemory( &m_FormatEtc, sizeof( FORMATETC ) );
  515. if ( m_StgMedium.tymed != TYMED_NULL )
  516. ReleaseStgMedium( &m_StgMedium );
  517. ZeroMemory( &m_StgMedium, sizeof( STGMEDIUM ) );
  519. return S_OK;
  520.     }    
  521.     
  522.     void AddSupportedFormat( FORMATETC& FormatEtc )
  523. {
  524. m_vFormatEtc.push_back( FormatEtc );
  525. }
  527. void AddSupportedFormat( CLIPFORMAT cfFormat )
  528. {
  529. FORMATETC FormatEtc;
  530. ZeroMemory( &FormatEtc, sizeof( FORMATETC ) );
  532. FormatEtc.cfFormat = cfFormat;
  533. FormatEtc.dwAspect = DVASPECT_CONTENT;
  534. FormatEtc.lindex = -1;
  535. FormatEtc.tymed = TYMED_HGLOBAL;
  537. AddSupportedFormat( FormatEtc );
  538. }
  540. BOOL QueryDrop( DWORD dwKeyState, LPDWORD pdwEffect )
  541. {
  542. DWORD dwEffects = *pdwEffect; 
  544. if ( !m_bAllowDrop )
  545. {
  546. *pdwEffect = DROPEFFECT_NONE;
  547. return FALSE;
  548. }
  550. *pdwEffect = ( dwKeyState & MK_CONTROL ) ? ( ( dwKeyState & MK_SHIFT ) ? DROPEFFECT_LINK : DROPEFFECT_COPY ) : ( ( dwKeyState & MK_SHIFT ) ? DROPEFFECT_MOVE : 0 );
  551. if ( *pdwEffect == 0 ) 
  552. {
  553. if ( dwEffects & DROPEFFECT_COPY )
  554. *pdwEffect = DROPEFFECT_COPY;
  555. else if ( dwEffects & DROPEFFECT_MOVE )
  556. *pdwEffect = DROPEFFECT_MOVE; 
  557. else if (dwEffects & DROPEFFECT_LINK )
  558. *pdwEffect = DROPEFFECT_LINK; 
  559. else 
  560. *pdwEffect = DROPEFFECT_NONE;
  561. } 
  562. else if ( !( *pdwEffect & dwEffects ) )
  563. *pdwEffect = DROPEFFECT_NONE;
  565. return ( *pdwEffect != DROPEFFECT_NONE );
  566. }
  568. virtual DWORD OnDragEnter( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  569. {
  570. return FALSE;
  571. }
  573. virtual DWORD OnDragOver( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  574. {
  575. return FALSE;
  576. }
  578. virtual BOOL OnDrop( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwEffect, CPoint point )
  579. {
  580. return FALSE;
  581. }
  583. virtual void OnDragLeave()
  584. {
  585. }
  586. };
  588. template < class T >
  589. class CDropTargetT : public CDropTarget
  590. {
  591. public:
  592. CDropTargetT( HWND hTargetWnd ) : CDropTarget( hTargetWnd )
  593. {
  594. m_pDelegate = NULL;
  595. }
  597. protected:
  598. T *m_pDelegate;
  600. public:
  601. BOOL Register( T *pDelegate )
  602. {
  603. m_pDelegate = pDelegate;
  604. return TRUE;
  605. }
  607. virtual DWORD OnDragEnter( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  608. {
  609. return m_pDelegate == NULL ? DROPEFFECT_NONE : m_pDelegate->OnDragEnter( FormatEtc, StgMedium, dwKeyState, point );
  610. }
  612. virtual DWORD OnDragOver( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwKeyState, CPoint point )
  613. {
  614. return m_pDelegate == NULL ? DROPEFFECT_NONE : m_pDelegate->OnDragOver( FormatEtc, StgMedium, dwKeyState, point );
  615. }
  617. virtual BOOL OnDrop( FORMATETC& FormatEtc, STGMEDIUM& StgMedium, DWORD dwEffect, CPoint point )
  618. {
  619. return m_pDelegate == NULL ? FALSE : m_pDelegate->OnDrop( FormatEtc, StgMedium, dwEffect, point );
  620. }
  622. virtual void OnDragLeave()
  623. {
  624. if ( m_pDelegate != NULL )
  625. m_pDelegate->OnDragLeave();
  626. }
  627. };
  629. template < class T >
  630. class CDataObjectT : public CDataObject
  631. {
  632. public:
  633. CDataObjectT( CDropSource *pDropSource ) : CDataObject( pDropSource )
  634. {
  635. m_pDelegate = FALSE;
  636. }
  638. protected:
  639. T *m_pDelegate;
  641. public:
  642. BOOL Register( T *pDelegate )
  643. {
  644. m_pDelegate = pDelegate;
  645. return TRUE;
  646. }
  648. virtual BOOL OnRenderData( FORMATETC& FormatEtc, STGMEDIUM *pStgMedium, BOOL bDropComplete )
  649. {
  650. return m_pDelegate == NULL ? FALSE : m_pDelegate->OnRenderData( FormatEtc, pStgMedium, bDropComplete );
  651. }
  652. };
  654. template < class T >
  655. class CDragDrop
  656. {
  657. public:
  658. CDragDrop()
  659. {
  660. m_pDropSource = NULL;
  661. m_pDataObject = NULL;
  662. m_pDropTarget = NULL;
  663. m_hTargetWnd = NULL;
  664. }
  666. virtual ~CDragDrop()
  667. {
  668. if ( m_pDropSource != NULL )
  669. m_pDropSource->Release();
  670. if ( m_pDataObject != NULL )
  671. m_pDataObject->Release();
  672. }
  674. protected:
  675. CDropSource *m_pDropSource;
  676. CDataObjectT< T > *m_pDataObject;
  677. CDropTargetT< T > *m_pDropTarget;
  678. HWND m_hTargetWnd;
  680. public:
  681. BOOL Register( T *pDelegate, BOOL bDropSource = TRUE )
  682. {
  683. m_hTargetWnd = pDelegate->m_hWnd;
  685. // instantiate new drop target object
  686. m_pDropTarget = new CDropTargetT< T >( m_hTargetWnd );
  687. m_pDropTarget->Register( pDelegate );
  689. // register drop target
  690. if ( FAILED( RegisterDragDrop( m_hTargetWnd, m_pDropTarget ) ) )
  691. {
  692. m_pDropTarget = NULL;
  693. return FALSE;
  694. }
  696. // is this a drop target only?
  697. if ( !bDropSource )
  698. return TRUE;
  700. // instantiate new drop source object
  701. m_pDropSource = new CDropSource;
  702. m_pDropSource->AddRef();
  704. m_pDataObject = new CDataObjectT< T >( m_pDropSource );
  705. m_pDataObject->AddRef();
  707. // register drop source delegate for data render
  708. return m_pDataObject->Register( pDelegate );
  709. }
  711. BOOL Revoke()
  712. {
  713. m_pDropTarget = NULL;
  714. return ( RevokeDragDrop( m_hTargetWnd ) == S_OK );
  715. }
  717. BOOL AddTargetFormat( CLIPFORMAT cfFormat )
  718. {
  719. if ( m_pDropTarget == NULL )
  720. return FALSE;
  721. m_pDropTarget->AddSupportedFormat( cfFormat );
  722. return TRUE;
  723. }
  725. BOOL AddSourceFormat( CLIPFORMAT cfFormat )
  726. {
  727. if ( m_pDataObject == NULL )
  728. return FALSE;
  730. FORMATETC FormatEtc;
  731. ZeroMemory( &FormatEtc, sizeof( FORMATETC ) );
  733. FormatEtc.cfFormat = cfFormat;
  734. FormatEtc.dwAspect = DVASPECT_CONTENT;
  735. FormatEtc.lindex = -1;
  736. FormatEtc.tymed = TYMED_HGLOBAL;
  738. STGMEDIUM StgMedium;
  739. ZeroMemory( &StgMedium, sizeof( STGMEDIUM ) );
  741. return SUCCEEDED( m_pDataObject->SetData( &FormatEtc, &StgMedium, TRUE ) );
  742. }
  744. BOOL SetClipboard( FORMATETC& FormatEtc, STGMEDIUM& StgMedium )
  745. {
  746. if ( m_pDataObject == NULL )
  747. return DROPEFFECT_NONE;
  749. if ( FAILED( m_pDataObject->SetData( &FormatEtc, &StgMedium, TRUE ) ) )
  750. return DROPEFFECT_NONE;
  752. return ( OleSetClipboard( m_pDataObject ) == S_OK );
  753. }
  755. BOOL FlushClipboard()
  756. {
  757. return ( OleFlushClipboard() == S_OK );
  758. }
  760. DWORD DoDragDrop( SHDRAGIMAGE *pDragImage = NULL, DWORD dwValidEffects = DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK )
  761. {
  762. if ( m_pDataObject == NULL )
  763. return DROPEFFECT_NONE;
  765. IDragSourceHelper *pDragSourceHelper = NULL;
  767. // instantiate drag source helper object
  768. if ( pDragImage != NULL )
  769. {
  770. if ( FAILED( CoCreateInstance( CLSID_DragDropHelper, NULL, CLSCTX_INPROC_SERVER, IID_IDragSourceHelper, (LPVOID*)&pDragSourceHelper ) ) )
  771. pDragSourceHelper = NULL;
  773. if ( pDragSourceHelper != NULL )
  774. pDragSourceHelper->InitializeFromBitmap( pDragImage, m_pDataObject );
  775. }
  777. DWORD dwEffects = DROPEFFECT_NONE;
  778. dwEffects = ::DoDragDrop( m_pDataObject, m_pDropSource, dwValidEffects, &dwEffects ) == DRAGDROP_S_DROP ? DROPEFFECT_NONE : dwEffects;
  780. // destroy drag source helper object
  781. if ( pDragSourceHelper != NULL )
  782. pDragSourceHelper->Release();
  784. return dwEffects;
  785. }
  786. };