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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图象 > 查看源码
UIDragDropTree.cpp
资源名称：isee_code01231.zip　[点击查看]
上传用户：yatsl7111
上传日期：2007-01-08
资源大小：1433k
文件大小：18k
源码类别：

图形图象

开发平台：

Visual C++

UIDragDropTree.cpp：源码内容
  1. //*******************************************************************************
  2. // COPYRIGHT NOTES
  3. // ---------------
  4. // You may use this source code, compile or redistribute it as part of your application 
  5. // for free. You cannot redistribute it as a part of a software development 
  6. // library without the agreement of the author. If the sources are 
  7. // distributed along with the application, you should leave the original 
  8. // copyright notes in the source code without any changes.
  9. // This code can be used WITHOUT ANY WARRANTIES at your own risk.
  10. // 
  11. // For the latest updates to this code, check this site:
  12. // http://www.masmex.com 
  13. // after Sept 2000
  14. // 
  15. // Copyright(C) 2000 Philip Oldaker <email: philip@masmex.com>
  16. //*******************************************************************************
  18. //////////////////////////////////////////////////////////////////////////////////////--*/
  19. // UIDragDropTree.cpp : implementation file
  20. //
  22. #include "stdafx.h"
  23. #include "UICtrl.h"
  24. #include "UIDragDropTree.h"
  25. #include "cbformats.h"
  26. #include "UIRes.h"
  28. #ifdef _DEBUG
  29. #define new DEBUG_NEW
  30. #undef THIS_FILE
  31. static char THIS_FILE[] = __FILE__;
  32. #endif
  34. IMPLEMENT_DYNAMIC(CUIDragDropTree,CTreeCtrl)
  35. /////////////////////////////////////////////////
  36. //
  37. // For OLE drag and drop 
  38. //
  39. /////////////////////////////////////////////////
  40. void CUI_TreeDropTarget::OnDragLeave(CWnd* pWnd)
  41. {
  42. CUIDragDropTree *pTree = static_cast<CUIDragDropTree*>(pWnd);
  43. if (pTree == NULL)
  44. return;
  45. pTree->KillDragTimer();
  46. pTree->SelectDropTarget(NULL);
  47. CDD_OleDropTargetInfo Info(pWnd->GetSafeHwnd());
  48. Info.SetItem(pTree->GetDropHilightItem());
  49. BOOL bRet = pTree->SendMessage(WM_APP_OLE_DD_LEAVE,(WPARAM)&Info);
  50. if (bRet == FALSE)
  51. bRet = pTree->GetParent()->SendMessage(WM_APP_OLE_DD_LEAVE,(WPARAM)&Info);
  52. }
  54. DROPEFFECT CUI_TreeDropTarget::OnDragEnter( CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point )
  55. {
  56. // ASSERT_KINDOF(CUIDragDropTree,pWnd);
  57. CUIDragDropTree *pTree = static_cast<CUIDragDropTree*>(pWnd);
  58. if (pTree == NULL)
  59. return DROPEFFECT_NONE;
  60. ((CUIDragDropTree*)pWnd)->SetDragTimer();
  61. CDD_OleDropTargetInfo Info(pWnd->GetSafeHwnd(),point,pDataObject);
  62. m_dwEnterKeyboardState = dwKeyState;
  63. Info.SetKeyboardState(dwKeyState);
  64. Info.SetItem(pTree->GetDropHilightItem());
  65. BOOL bRet = pTree->SendMessage(WM_APP_OLE_DD_ENTER,(WPARAM)&Info);
  66. if (bRet == FALSE)
  67. bRet = pTree->GetParent()->SendMessage(WM_APP_OLE_DD_ENTER,(WPARAM)&Info);
  68. return Info.GetDropEffect();
  69. }
  71. DROPEFFECT CUI_TreeDropTarget::OnDragOver( CWnd* pWnd, COleDataObject* pDataObject, DWORD dwKeyState, CPoint point )
  72. {
  73. // disallow if the control key pressed
  74. EraseOldImage();
  75. CUIDragDropTree *pTree = static_cast<CUIDragDropTree*>(pWnd);
  76. if (pTree == NULL)
  77. return DROPEFFECT_NONE;
  78. // ASSERT_KINDOF(CUIDragDropTree,pWnd);
  79. CDD_OleDropTargetInfo Info(pWnd->GetSafeHwnd(),point,pDataObject);
  80. m_dwKeyboardState = dwKeyState;
  81. Info.SetKeyboardState(dwKeyState);
  82. // WM_APP_OLE_DD_OVER message sent in SelectCurrentTarget
  83. DROPEFFECT dropEffect = pTree->SelectCurrentTarget(&Info);
  84. CUI_ImageDropTarget::OnDragOver(pWnd,pDataObject,dwKeyState,point);
  85. return dropEffect;
  86. }
  88. BOOL CUI_TreeDropTarget::OnDrop( CWnd* pWnd, COleDataObject* pDataObject, DROPEFFECT dropEffect, CPoint point )
  89. {
  90. CUIDragDropTree *pTree = static_cast<CUIDragDropTree*>(pWnd);
  91. if (pTree == NULL)
  92. return FALSE;
  93. // ASSERT_KINDOF(CUIDragDropTree,pWnd);
  94. pTree->KillDragTimer();
  95. HTREEITEM hItem = pTree->GetDropHilightItem();
  96. BOOL bRet=FALSE;
  97. if (hItem) 
  98. {
  99. CDD_OleDropTargetInfo Info(pWnd->GetSafeHwnd(),point,pDataObject);
  100. Info.SetDropEffect(dropEffect);
  101. Info.SetItem(hItem);
  102.         if (m_dwEnterKeyboardState & MK_RBUTTON)
  103. m_dwKeyboardState |= MK_RBUTTON;
  104.         if (m_dwEnterKeyboardState & MK_LBUTTON)
  105. m_dwKeyboardState |= MK_LBUTTON;
  106. Info.SetKeyboardState(m_dwKeyboardState);
  107. bRet = pTree->SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  108. if (bRet == FALSE)
  109. bRet = pTree->GetParent()->SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  110. }
  111. pTree->SelectDropTarget(NULL);
  112. return bRet;
  113. }
  115. // During slow scroll, process every third message.
  116. #define SLOWSCROLL_FREQUENCY 3
  117. /////////////////////////////////////////////////////////////////////////////
  118. // CUIDragDropTree
  120. CUIDragDropTree::CUIDragDropTree(bool bDragDrop): m_nUpperYCoor(0), 
  121. m_nLowerYCoor(0), 
  122. m_nSlowScrollTimeout(0),
  123. m_nTimerID(0),
  124. m_bDragging(FALSE),
  125. m_pImageList(NULL),
  126. m_hitemDrag(NULL),
  127. m_hitemDrop(NULL),
  128. m_bDragDrop(bDragDrop),
  129. m_bDropFiles(true)
  131. {
  132. m_nScrollBarSize = GetSystemMetrics( SM_CYHSCROLL );
  133. m_CopyMode = eDDCancel;
  134. }
  136. CUIDragDropTree::~CUIDragDropTree()
  137. {
  138. }
  140. void CUIDragDropTree::OnDropFile(HTREEITEM hItem,LPCTSTR pszFile,UINT nFlags)
  141. {
  142. }
  144. BEGIN_MESSAGE_MAP(CUIDragDropTree, CTreeCtrl)
  145. //{{AFX_MSG_MAP(CUIDragDropTree)
  146. ON_NOTIFY_REFLECT_EX(TVN_BEGINDRAG, OnBegindrag)
  147. ON_NOTIFY_REFLECT_EX(TVN_BEGINRDRAG, OnBeginRDrag)
  148. ON_WM_TIMER()
  149. ON_WM_RBUTTONUP()
  150. ON_WM_MOUSEMOVE()
  151. ON_WM_DESTROY()
  152. ON_WM_CREATE()
  153. ON_WM_DROPFILES()
  154. ON_WM_LBUTTONUP()
  155. //}}AFX_MSG_MAP
  156. END_MESSAGE_MAP()
  158. /////////////////////////////////////////////////////////////////////////////
  159. // CUIDragDropTree message handlers
  160. void CUIDragDropTree::OnDropFiles(HDROP hDropInfo)
  161. {
  162. UINT wNumFilesDropped = DragQueryFile(hDropInfo, 0XFFFFFFFF, NULL, 0);
  163. TCHAR szFile[MAX_PATH];
  164. UINT nLen;
  165. UINT nFlags;
  166. POINT pt;
  167. ::DragQueryPoint(hDropInfo,&pt);
  168. HTREEITEM hitemDrag = HitTest(CPoint(pt), &nFlags);
  169. for(UINT i=0; i < wNumFilesDropped;i++)
  170. {
  171. nLen = DragQueryFile(hDropInfo,i,szFile,sizeof(szFile)/sizeof(TCHAR));
  172. if (nLen)
  173. OnDropFile(hitemDrag,szFile,nFlags);
  174. }
  175. }
  177. BOOL CUIDragDropTree::OnBeginRDrag(NMHDR* pNMHDR, LRESULT* pResult) 
  178. {
  179. NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  180. return StartDragDrop(pNMTreeView);
  181. }
  183. BOOL CUIDragDropTree::OnBegindrag(NMHDR* pNMHDR, LRESULT* pResult) 
  184. {
  185. NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  186. return StartDragDrop(pNMTreeView);
  187. }
  189. BOOL CUIDragDropTree::StartDragDrop(NM_TREEVIEW* pNMTreeView)
  190. {
  191. /* if (GetDragDrop() == false || pNMTreeView->itemNew.hItem == GetRootItem())
  192. return FALSE;
  193. // See if COM drag drop is implemented in this window or parent window
  194. DWORD dwDragEffect = SendMessage(WM_APP_OLE_DD_DODRAGDROP,(WPARAM)pNMTreeView,(LPARAM)&m_OleDataSource);
  195. if (dwDragEffect == 0)
  196. dwDragEffect = GetParent()->SendMessage(WM_APP_OLE_DD_DODRAGDROP,(WPARAM)pNMTreeView,(LPARAM)&m_OleDataSource);
  197. if (dwDragEffect)   
  198. {
  199. CRect rcDrag; 
  200. m_hitemDrag = pNMTreeView->itemNew.hItem;
  201. // Define starting rect
  202. GetItemRect(pNMTreeView->itemNew.hItem,rcDrag,TRUE);
  203. // Start the DragDrop
  204. DWORD dwEffect = m_OleDataSource.DoDragDrop(dwDragEffect,rcDrag);
  205. // Clear the cache
  206. m_OleDataSource.Empty();        
  207. }
  208. else // otherwise start local drag drop
  209. {
  210. CPoint ptAction;
  211. UINT nFlags;
  213. GetCursorPos(&ptAction);
  214. ScreenToClient(&ptAction);
  216. m_bDragging = TRUE;
  217. m_hitemDrag = HitTest(pNMTreeView->ptDrag, &nFlags);
  218. m_hitemDrop = NULL;
  220. // Create drag image and begin dragging
  221. m_pImageList = CreateDragImage(m_hitemDrag);  
  222. m_pImageList->BeginDrag(0, CPoint(0,0));
  223. m_pImageList->DragEnter(GetDesktopWindow(), ptAction);
  224. SetCapture();
  226. SetDragTimer();  
  227. }
  228. return TRUE;
  229. */ //all commit by ygcl
  230. TRACE0("BEGIN DRAG");
  231. CPoint      ptAction;
  232. UINT        nFlags;
  233. GetCursorPos(&ptAction);
  234. ScreenToClient(&ptAction);
  235. m_bDragging = TRUE;
  236. m_hitemDrag = HitTest(ptAction, &nFlags);
  237. m_hitemDrop = NULL;
  239. ASSERT(m_pImageList == NULL);
  240. m_pImageList = CreateDragImage(m_hitemDrag);  // get the image list for dragging
  241. m_pImageList->DragShowNolock(TRUE);
  242. m_pImageList->SetDragCursorImage(0, CPoint(0, 0));
  243. m_pImageList->BeginDrag(0, CPoint(0,0));
  244. m_pImageList->DragMove(ptAction);
  245. m_pImageList->DragEnter(this, ptAction);
  246. SetCapture();
  247. return TRUE;
  248. }
  250. void CUIDragDropTree::SetDragTimer()
  251. {
  252. // Set the timer to slow down the scrolling when the dragging cursor
  253. // is close to the top/bottom border of the tree control
  254. if (!m_nTimerID) 
  255. {
  256. m_nTimerID = SetTimer(1, 75, NULL);
  257. CRect rect;
  258. GetClientRect(&rect);
  259. ClientToScreen(&rect);
  260. m_nUpperYCoor = rect.top;
  261. m_nLowerYCoor = rect.bottom;
  262. }
  263. }
  265. void CUIDragDropTree::KillDragTimer()
  266. {
  267. if (m_nTimerID)
  268. {
  269. KillTimer(m_nTimerID);
  270. }
  271. m_nTimerID = 0;
  272. m_nUpperYCoor = 0;
  273. m_nLowerYCoor = 0;
  274. m_nSlowScrollTimeout = 0;
  275. }
  277. void CUIDragDropTree::OnTimer(UINT nIDEvent) 
  278. {
  279. // TODO: Add your message handler code here and/or call default
  280. if (nIDEvent != m_nTimerID)
  281. {
  282. CTreeCtrl::OnTimer(nIDEvent);
  283. return;
  284. }
  286. // Get the "current" mouse position
  287. const MSG* pMessage;
  288. CPoint ptMouse;
  289. pMessage = GetCurrentMessage();
  290. ASSERT(pMessage);
  291. ptMouse = pMessage->pt;
  293. // Move the ghost image
  294. if (m_pImageList)
  295. m_pImageList->DragMove(ptMouse);
  297. // Find out if scrolling is needed.
  298. // Scrolling is not needed for example, if the dragging cursor is 
  299. // within the tree control itself
  300. if(!NeedToScroll(ptMouse))
  301. {
  302.    CTreeCtrl::OnTimer(nIDEvent);
  303. return;
  304. }
  305. if (!m_bDragging)
  306. m_OleDropTarget.EraseOldImage();
  308. // Refine the scrolling mode -
  309. // Scroll Up/Down, Slow/Normal
  310.   int nScrollMode = RefineScrollMode(ptMouse);
  312. switch(nScrollMode) 
  313. {
  314. case SCROLL_UP_SLOW:
  315. case SCROLL_DOWN_SLOW:
  316. if( m_nSlowScrollTimeout == 0)
  317. SendMessage( WM_VSCROLL, 
  318. nScrollMode == SCROLL_UP_SLOW ? SB_LINEUP : SB_LINEDOWN);
  319. m_nSlowScrollTimeout = ++m_nSlowScrollTimeout%SLOWSCROLL_FREQUENCY;
  320. break;
  321. case SCROLL_UP_NORMAL:
  322. case SCROLL_DOWN_NORMAL:
  323. SendMessage( WM_VSCROLL, 
  324. nScrollMode == SCROLL_UP_NORMAL ? SB_LINEUP : SB_LINEDOWN);
  325. break;
  326. default:
  327. ASSERT(FALSE);
  328. return;
  329. break;
  330. }
  331. if (m_bDragging)
  332. {
  333. // Select the drop target
  334. if (m_pImageList)
  335. m_pImageList->DragLeave(this);
  336. HTREEITEM hitem = GetFirstVisibleItem();
  338. switch( nScrollMode )
  339.   {
  340. case SCROLL_UP_SLOW:
  341. case SCROLL_UP_NORMAL:
  342.   {
  343. SelectDropTarget(hitem);
  344. m_hitemDrop = hitem;
  345. break;
  346.   }
  347. case SCROLL_DOWN_SLOW:
  348. case SCROLL_DOWN_NORMAL:
  349.   {
  350. // Get the last visible item in the control
  351. int nCount = GetVisibleCount();
  352. for ( int i=0; i<nCount-1; ++i )
  353. hitem = GetNextVisibleItem(hitem);
  354. SelectDropTarget(hitem);
  355. m_hitemDrop = hitem;
  356. break;
  357.   }
  358. default:
  359. ASSERT(FALSE);
  360. return;
  361. break;
  362.   }
  364. if (m_pImageList)
  365. m_pImageList->DragEnter(this, ptMouse); CTreeCtrl::OnTimer(nIDEvent);
  366. }
  367. }
  369. void CUIDragDropTree::OnRButtonUp(UINT nFlags, CPoint point) 
  370. {
  371. if (!m_bDragging)
  372. return;
  373. // Kill the timer and reset all variables
  374. EndDragging();
  375. CMenu menu;
  376. VERIFY(menu.LoadMenu(IDR_POPUPMENU_DRAGDROP));
  377. CMenu* pPopup = menu.GetSubMenu(0);
  378. ASSERT(pPopup != NULL);
  379. pPopup->SetDefaultItem(ID_POPUP_DD_MOVE);
  380. CPoint pts(point);
  381. ClientToScreen(&pts);
  382. if (GetRDragMenu(pPopup))
  383. {
  384. UINT nCmd = pPopup->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_NONOTIFY | TPM_RIGHTBUTTON | TPM_RETURNCMD, pts.x, pts.y,this);
  385. if (nCmd == ID_POPUP_DD_MOVE)
  386. {
  387. OnButtonUp(true);
  388. }
  389. else if (nCmd == ID_POPUP_DD_COPY)
  390. {
  391. OnButtonUp(false);
  392. }
  393. }
  394. else
  395. {
  396. // otherwise just move
  397. OnButtonUp(true);
  398. }
  399. CTreeCtrl::OnRButtonUp(nFlags, point);
  400. }
  402. void CUIDragDropTree::OnMouseMove(UINT nFlags, CPoint point) 
  403. {
  404. /* // TODO: Add your message handler code here and/or call default
  405. HTREEITEM hItem;
  406. UINT flags;
  408. if (!m_bDragging)
  409. return;
  410. CPoint ptScreen(point);
  411. ClientToScreen(&ptScreen);
  413. m_pImageList->DragMove(ptScreen);
  415. m_pImageList->DragShowNolock(FALSE);  by ygcl
  417. if ((hItem = HitTest(point, &flags)) != NULL)
  418. {
  419. CDD_OleDropTargetInfo Info(this->GetSafeHwnd(),point,NULL);
  420. Info.SetItem(hItem);
  421. LRESULT lResult = SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)&Info);
  422. if (lResult == 0)
  423. {
  424. lResult = GetParent()->SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)&Info);
  425. }
  426. if (lResult)
  427. {
  428. SelectDropTarget(hItem);
  429. m_hitemDrop = hItem;
  430. }
  431. }
  432. m_pImageList->DragShowNolock(TRUE);
  434. CTreeCtrl::OnMouseMove(nFlags, point);
  435. */ // all commit by ygcl
  436. HTREEITEM           hitem;
  437. UINT                flags;
  439. if (m_bDragging)
  440. {
  441. ASSERT(m_pImageList != NULL);
  442. m_pImageList->DragMove(point);
  443. if ((hitem = HitTest(point, &flags)) != NULL)
  444. {
  445. m_pImageList->DragLeave(this);
  446. SelectDropTarget(hitem);
  447. m_hitemDrop = hitem;
  448. m_pImageList->DragEnter(this, point);
  449. }
  450. HTREEITEM t_hItem;
  451. t_hItem = GetDropHilightItem();
  452. }
  453. CTreeCtrl::OnMouseMove(nFlags, point);
  454. }
  456. void CUIDragDropTree::OnButtonUp(bool bMove)
  457. {
  458. if (!m_bDragging)
  459. return;
  460. EndDragging();
  461. if (m_hitemDrag && m_hitemDrag != m_hitemDrop && !IsChildNodeOf(m_hitemDrop, m_hitemDrag) && 
  462. GetParentItem(m_hitemDrag) != m_hitemDrop)
  463. {
  464. CDD_OleDropTargetInfo Info(GetSafeHwnd(),CPoint(),NULL);
  465. Info.SetDropEffect(bMove ? DROPEFFECT_MOVE : DROPEFFECT_COPY);
  466. Info.SetItem(m_hitemDrop);
  467. LRESULT lResult = SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  468. if (lResult == 0)
  469. lResult = GetParent()->SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  470. }
  471. }
  473. void CUIDragDropTree::EndDragging()
  474. {
  475. if (!m_bDragging)
  476. return;
  477. m_bDragging = FALSE;
  478. if (m_pImageList)
  479. {
  480. m_pImageList->DragLeave(this);
  481. m_pImageList->EndDrag();
  482. }
  483. delete m_pImageList;
  484. m_pImageList = NULL;
  485. ReleaseCapture();
  486. SelectDropTarget( NULL );
  487. KillDragTimer();  
  488. TRACE0("END DRAG");
  489. }
  491. void CUIDragDropTree::NewTransferItem(HTREEITEM hNewItem)
  492. {
  493. }
  495. BOOL CUIDragDropTree::TransferItem(HTREEITEM hitemDrag, HTREEITEM hitemDrop)
  496. {
  497. TV_INSERTSTRUCT tvstruct;
  498. TCHAR sztBuffer[256];
  499. HTREEITEM hNewItem, hFirstChild;
  501. // avoid an infinite recursion situation
  502. tvstruct.item.hItem = hitemDrag;
  503. tvstruct.item.cchTextMax = sizeof(sztBuffer)-1;
  504. tvstruct.item.pszText = sztBuffer;
  505. tvstruct.item.mask = TVIF_CHILDREN | TVIF_HANDLE | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
  506. GetItem(&tvstruct.item);  
  507. tvstruct.hParent = hitemDrop;
  508. tvstruct.hInsertAfter = TVI_SORT;
  509. tvstruct.item.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_TEXT | TVIF_PARAM;
  510. hNewItem = InsertItem(&tvstruct);
  511. NewTransferItem(hNewItem);
  513. while ((hFirstChild = GetChildItem(hitemDrag)) != NULL)
  514. {
  515. // recursively transfer all the items
  516. TransferItem(hFirstChild, hNewItem);  
  517. // delete the first child and all its children
  518. DeleteItem(hFirstChild);
  519. }
  520. return TRUE;
  521. }
  525. BOOL CUIDragDropTree::NeedToScroll( CPoint ptMouse )
  526. {
  527. if (m_bDragging)
  528. {
  529. return ptMouse.y < m_nUpperYCoor || ptMouse.y > m_nLowerYCoor;
  530. }
  531. else
  532. {
  533. return ptMouse.y < m_nUpperYCoor+10 || ptMouse.y > m_nLowerYCoor-30;
  534. }
  535. }
  538. CUIDragDropTree::SCROLLMODE CUIDragDropTree::RefineScrollMode( CPoint ptMouse )
  539. {
  540. int nYCoor = ptMouse.y;
  541. CUIDragDropTree::SCROLLMODE nScrollMode;
  543. if (m_bDragging)
  544. {
  545. nScrollMode = nYCoor > m_nLowerYCoor + m_nScrollBarSize ? SCROLL_DOWN_NORMAL :
  546.   nYCoor > m_nLowerYCoor ? SCROLL_DOWN_SLOW :
  547.   nYCoor < m_nUpperYCoor - m_nScrollBarSize ? SCROLL_UP_NORMAL :
  548.   SCROLL_UP_SLOW;
  549. }
  550. else
  551. {
  552. nScrollMode = nYCoor > m_nLowerYCoor-30 ? SCROLL_DOWN_NORMAL : 
  553. nYCoor < m_nUpperYCoor-10 ? SCROLL_UP_NORMAL : SCROLL_UP_NORMAL;
  554. }
  555. return nScrollMode;
  556. }
  558. BOOL CUIDragDropTree::IsChildNodeOf(HTREEITEM hitemChild, HTREEITEM hitemSuspectedParent)
  559. {
  560. do
  561. {
  562. if (hitemChild == hitemSuspectedParent)
  563. break;
  564. }
  565. while ((hitemChild = GetParentItem(hitemChild)) != NULL);
  567. return (hitemChild != NULL);
  568. }
  570. void CUIDragDropTree::RegisterDropTarget()
  571. {
  572. if (GetDragDrop())
  573. {
  574. VERIFY(m_OleDropTarget.Register(this));
  575. if (GetDropFiles())
  576. DragAcceptFiles();
  577. }
  578. }
  580. DROPEFFECT CUIDragDropTree::SelectCurrentTarget(CDD_OleDropTargetInfo *pInfo)
  581. {
  582. /* HTREEITEM hItem;
  583. UINT flags;
  584. if ((hItem = HitTest(pInfo->GetPoint(), &flags)) != NULL) 
  585. {
  586. // select it
  587. SelectDropTarget(hItem);
  588. // save it
  589. m_hitemDrop = hItem;
  590. // returns 1 if allowed
  591. pInfo->SetItem(hItem);
  592. LRESULT lResult = SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
  593. if (lResult == 0)
  594. {
  595. lResult = GetParent()->SendMessage(WM_APP_OLE_DD_OVER,(WPARAM)pInfo);
  596. }
  597. if (lResult)
  598. {
  599. if (::GetKeyState(VK_LCONTROL) < 0) 
  600. {
  601. if (ItemHasChildren(hItem))
  602. {
  603. Expand(hItem, TVE_EXPAND);
  604. }
  605. }
  606. return pInfo->GetDropEffect();
  607. }
  608. }*/ // ygcl
  609. return DROPEFFECT_NONE;
  610. }
  612. void CUIDragDropTree::OnDestroy() 
  613. {
  615. CTreeCtrl::OnDestroy();
  617. // TODO: Add your message handler code here
  619. }
  621. int CUIDragDropTree::OnCreate(LPCREATESTRUCT lpCreateStruct) 
  622. {
  623. if (CTreeCtrl::OnCreate(lpCreateStruct) == -1)
  624. return -1;
  626. // TODO: Add your specialized creation code here
  627. RegisterDropTarget();
  629. return 0;
  630. }
  632. bool CUIDragDropTree::GetRDragMenu(CMenu *pMenu)
  633. {
  634. return true;
  635. }
  637. void CUIDragDropTree::OnDDMove()
  638. {
  639. m_CopyMode = eDDMove;
  640. }
  642. void CUIDragDropTree::OnDDCopy()
  643. {
  644. m_CopyMode = eDDCopy;
  645. }
  647. void CUIDragDropTree::OnDDCancel()
  648. {
  649. m_CopyMode = eDDCancel;
  650. }
  652. void CUIDragDropTree::OnLButtonUp(UINT nFlags, CPoint point) 
  653. {
  654. // TODO: Add your message handler code here and/or call default
  655. if (!m_bDragging)
  656. return;
  657. EndDragging();
  658. if (m_hitemDrag && m_hitemDrag != m_hitemDrop && !IsChildNodeOf(m_hitemDrop, m_hitemDrag) && 
  659. GetParentItem(m_hitemDrag) != m_hitemDrop)
  660. {
  661. CDD_OleDropTargetInfo Info(GetSafeHwnd(),CPoint(),NULL);
  662. Info.SetDropEffect( /*bMove*/ m_CopyMode ? DROPEFFECT_MOVE : DROPEFFECT_COPY);
  663. Info.SetItem(m_hitemDrop);
  664. LRESULT lResult = SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  665. if (lResult == 0)
  666. lResult = GetParent()->SendMessage(WM_APP_OLE_DD_DROP,(WPARAM)&Info);
  667. }
  669. CTreeCtrl::OnLButtonUp(nFlags, point);
  670. }