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

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

图形图象

开发平台：

Visual C++

IEShellTreeCtrl.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. // IEShellTreeCtrl.cpp : implementation file
  19. #include "stdafx.h"
  20. #include "IEShellTreeCtrl.h"
  21. #include "cbformats.h"
  22. #include "UIMessages.h"
  23. #include "dirwalk.h"
  25. #ifdef _DEBUG
  26. #define new DEBUG_NEW
  27. #undef THIS_FILE
  28. static char THIS_FILE[] = __FILE__;
  29. #endif
  31. /////////////////////////////////////////////////////////////////////////////
  32. // CIEShellTreeCtrl
  34. CIEShellTreeCtrl::CIEShellTreeCtrl()
  35. {
  36. m_lptvid = NULL;
  37. m_hListWnd = NULL;
  38. m_hComboWnd = NULL;
  39. m_nThreadCount = 0;
  40. m_bRefreshAllowed = true;
  41. m_bNotifyParent = false;
  42. // Turn off WM_DROPFILES
  43. SetDropFiles(false);
  44. }
  46. CIEShellTreeCtrl::~CIEShellTreeCtrl()
  47. {
  48. }
  50. void CIEShellTreeCtrl::ShellExecute(HTREEITEM hItem,LPCTSTR pszVerb)
  51. {
  52. SHELLEXECUTEINFO si;
  53. ZeroMemory(&si,sizeof(si));
  54. si.cbSize = sizeof(si);
  55. si.hwnd = GetSafeHwnd();
  56. si.nShow = SW_SHOW;
  57. si.lpIDList = (LPVOID)GetPathPidl(hItem);
  58. si.fMask  = SEE_MASK_INVOKEIDLIST;
  59. if (pszVerb)
  60. si.lpVerb = pszVerb;
  61. ShellExecuteEx(&si);
  62. }
  64. void CIEShellTreeCtrl::RefreshComboBox(LPTVITEMDATA lptvid)
  65. {
  66. if (m_hComboWnd)
  67. {
  68. ::PostMessage(m_hComboWnd,WM_APP_CB_IE_POPULATE,(WPARAM)lptvid->lpifq,0);
  69. }
  70. }
  72. void CIEShellTreeCtrl::SetNotificationObject(bool bNotify)
  73. {
  74. if (bNotify)
  75. CreateFileChangeThreads(GetSafeHwnd());
  76. else
  77. DestroyThreads();
  78. }
  80. void CIEShellTreeCtrl::UpOneLevel(HTREEITEM hItem)
  81. {
  82. if (hItem == NULL)
  83. {
  84. hItem = GetSelectedItem();
  85. }
  86. if (hItem == NULL)
  87. return;
  88. HTREEITEM hParentItem = GetParentItem(hItem);
  89. if (hParentItem)
  90. Select(hParentItem,TVGN_CARET);
  91. }
  93. void CIEShellTreeCtrl::DestroyThreads()
  94. {
  95.     if (m_nThreadCount == 0) 
  96. return;
  97.     for (UINT i=0;i < m_nThreadCount; i++)
  98.     m_event[i].SetEvent();
  99.     ::WaitForMultipleObjects (m_nThreadCount, m_hThreads, TRUE, INFINITE);
  100.     for (i=0; i < m_nThreadCount; i++)
  101.         delete m_pThreads[i];
  102.     m_nThreadCount = 0;
  103. }
  105. void CIEShellTreeCtrl::CreateFileChangeThreads(HWND hwnd)
  106. {
  107. if (m_nThreadCount)
  108. return;
  109. TCHAR szDrives[MAX_PATH];
  110. DWORD dwSize = sizeof(szDrives)/sizeof(TCHAR);
  111. DWORD dwChars = GetLogicalDriveStrings(dwSize,szDrives);
  112. if (dwChars == 0 || dwChars > dwSize) 
  113. {
  114. TRACE(_T("Warning: CreateFileChangeThreads failed in GetLogicalDriveStringsn"));
  115. return;
  116. }
  117. UINT nType;
  118. CString sDrive;
  119. LPCTSTR pszDrives=szDrives;
  120. while (*pszDrives != '')
  121. {
  122. sDrive = pszDrives;
  123. nType = ::GetDriveType(sDrive);
  124. if (nType == DRIVE_FIXED || nType == DRIVE_REMOTE || nType == DRIVE_RAMDISK)
  125. {
  126. CreateFileChangeThread(sDrive,hwnd);
  127. }
  128. pszDrives = _tcsninc(pszDrives,sDrive.GetLength()+1);
  129. }
  130. }
  132. void CIEShellTreeCtrl::CreateFileChangeThread(const CString& sPath,HWND hwnd)
  133. {
  134. if (m_nThreadCount >= MAX_THREADS)
  135. return;
  136.     PDC_THREADINFO pThreadInfo = new DC_THREADINFO; // Thread will delete
  137.     pThreadInfo->sPath = sPath;
  138.     pThreadInfo->hEvent = m_event[m_nThreadCount].m_hObject;
  139.     pThreadInfo->pTreeCtrl = this;
  141.     CWinThread* pThread = AfxBeginThread (ThreadFunc, pThreadInfo,
  142.         THREAD_PRIORITY_IDLE);
  144.     pThread->m_bAutoDelete = FALSE;
  145.     m_hThreads[m_nThreadCount] = pThread->m_hThread;
  146.     m_pThreads[m_nThreadCount++] = pThread;
  147. }
  149. HTREEITEM CIEShellTreeCtrl::SearchSiblings(HTREEITEM hItem,LPITEMIDLIST pidlAbs)
  150. {
  151. LPTVITEMDATA pItem = NULL;
  152. HTREEITEM hChildItem = GetChildItem(hItem);
  153. HTREEITEM hFoundItem;
  154. while (hChildItem) 
  155. {
  156. pItem = (LPTVITEMDATA)GetItemData(hChildItem);
  157. if (GetShellPidl().ComparePidls(NULL,pItem->lpifq,pidlAbs))
  158.    break;
  159. hFoundItem = SearchSiblings(hChildItem,pidlAbs);
  160. if (hFoundItem)
  161. return hFoundItem;
  162. hChildItem = GetNextSiblingItem(hChildItem);
  163. }
  164. return hChildItem;
  165. }
  167. HTREEITEM CIEShellTreeCtrl::ExpandMyComputer(LPITEMIDLIST pidlAbs)
  168. {
  169. HTREEITEM hItem=NULL;
  170. if (pidlAbs == NULL)
  171. return hItem;
  172. LPITEMIDLIST pidlMyComputer=NULL;
  173. LPITEMIDLIST pidlFirst=GetShellPidl().CopyItemID(pidlAbs);
  174.     SHGetSpecialFolderLocation(NULL, CSIDL_DRIVES, &pidlMyComputer); 
  175. if (GetShellPidl().ComparePidls(NULL,pidlMyComputer,pidlFirst))
  176. {
  177. hItem = ExpandPidl(pidlMyComputer);
  178. }
  179. if (pidlMyComputer)
  180. GetShellPidl().FreePidl(pidlMyComputer);
  181. if (pidlFirst)
  182. GetShellPidl().FreePidl(pidlFirst);
  183. return hItem;
  184. }
  186. HTREEITEM CIEShellTreeCtrl::ExpandPidl(LPITEMIDLIST pidlAbs)
  187. {
  188. HTREEITEM hItem = SearchSiblings(GetRootItem(),pidlAbs);
  189. if (hItem)
  190. {
  191. Expand(hItem,TVE_EXPAND);
  192. }
  193. return hItem;
  194. }
  196. HTREEITEM CIEShellTreeCtrl::FindPidl(LPITEMIDLIST pidlAbs,BOOL bSelect)
  197. {
  198. HTREEITEM hItem = NULL;
  199. if (pidlAbs == NULL)
  200. hItem = GetRootItem();
  201. else
  202. hItem = SearchSiblings(GetRootItem(),pidlAbs);
  203. if (bSelect && hItem != GetSelectedItem())
  204. {
  205. SelectItem(hItem);
  206. SelectionChanged(hItem,GetItemData(hItem));
  207. }
  208. return hItem;
  209. }
  211. HTREEITEM CIEShellTreeCtrl::FindItem (HTREEITEM hItem, const CString& strTarget)
  212. {
  213.     while (hItem != NULL) 
  214. {
  215.         if (GetItemText (hItem) == strTarget)
  216.             break;
  217.         hItem = GetNextSiblingItem (hItem);
  218.     }
  219.     return hItem;
  220. }
  222. UINT CIEShellTreeCtrl::DeleteChildren (HTREEITEM hItem)
  223. {
  224.     UINT nCount = 0;
  225.     HTREEITEM hChild = GetChildItem (hItem);
  227.     while (hChild != NULL)
  228. {
  229.         HTREEITEM hNextItem = GetNextSiblingItem (hChild);
  230.         DeleteItem (hChild);
  231.         hChild = hNextItem;
  232.         nCount++;
  233.     }
  234.     return nCount;
  235. }
  237. void CIEShellTreeCtrl::Init()
  238. {
  239. ModifyStyle(0,TVS_EDITLABELS);
  240. CIEFolderTreeCtrl::Init();
  241. }
  243. void CIEShellTreeCtrl::Refresh()
  244. {
  245. SetRefreshAllowed(false);
  246. CIEFolderTreeCtrl::Refresh();
  247. SetRefreshAllowed(true);
  248. }
  250. bool CIEShellTreeCtrl::DragEnter(CDD_OleDropTargetInfo *pInfo)
  251. {
  252. HTREEITEM hItem = pInfo->GetTreeItem(); 
  253. if (hItem == NULL)
  254. return false;
  255. LPTVITEMDATA ptvid = (LPTVITEMDATA)GetItemData(hItem);
  256. ASSERT(ptvid);
  257. if (ptvid == NULL)
  258. return false;
  259. return m_ShellDragDrop.DragEnter(pInfo,ptvid->lpsfParent,ptvid->lpi);
  260. }
  262. bool CIEShellTreeCtrl::DragLeave(CDD_OleDropTargetInfo *pInfo)
  263. {
  264. return m_ShellDragDrop.DragLeave(pInfo);
  265. }
  267. bool CIEShellTreeCtrl::DragOver(CDD_OleDropTargetInfo *pInfo)
  268. {
  269. pInfo->SetDropEffect(DROPEFFECT_NONE);
  271. HTREEITEM hItem = pInfo->GetTreeItem(); 
  272. if (hItem == NULL)
  273. return false;
  274. LPTVITEMDATA ptvid = (LPTVITEMDATA)GetItemData(hItem);
  275. ASSERT(ptvid);
  276. if (ptvid == NULL)
  277. return false;
  278. return m_ShellDragDrop.DragOver(pInfo,ptvid->lpsfParent,ptvid->lpi);
  279. }
  281. bool CIEShellTreeCtrl::DragDrop(CDD_OleDropTargetInfo *pInfo)
  282. {
  283. HTREEITEM hItem = pInfo->GetTreeItem(); 
  284. if (hItem == NULL)
  285. return false;
  286. LPTVITEMDATA ptvid = (LPTVITEMDATA)GetItemData(hItem);
  287. ASSERT(ptvid);
  288. if (ptvid == NULL)
  289. return false;
  290. return m_ShellDragDrop.DragDrop(pInfo,ptvid->lpsfParent,ptvid->lpi);
  291. }
  293. DROPEFFECT CIEShellTreeCtrl::DoDragDrop(NM_TREEVIEW* pNMTreeView,COleDataSource *pOleDataSource)
  294. {
  295. if (pNMTreeView->itemNew.hItem == GetRootItem())
  296. return DROPEFFECT_NONE;
  297. CCF_ShellIDList sl;
  298. CShellPidl pidl;
  299. HTREEITEM hParentItem = GetParentItem(pNMTreeView->itemNew.hItem);
  300. LPTVITEMDATA ptvid = (LPTVITEMDATA)GetItemData(pNMTreeView->itemNew.hItem);
  301. LPTVITEMDATA ptvid_parent = (LPTVITEMDATA)GetItemData(hParentItem);
  302. ASSERT(ptvid);
  303. ASSERT(ptvid_parent);
  304. if (GetShellPidl().IsDesktopFolder(ptvid->lpsfParent))
  305. sl.AddPidl(GetShellPidl().GetEmptyPidl());
  306. else
  307. sl.AddPidl(ptvid_parent->lpifq);
  308. sl.AddPidl(ptvid->lpi);
  309. CCF_HDROP cf_hdrop;
  310. CCF_String cf_text;
  311. CString sPath;
  312. pidl.SHPidlToPathEx(ptvid->lpifq,sPath);
  313. cf_hdrop.AddDropPoint(CPoint(pNMTreeView->ptDrag),FALSE);
  314. cf_hdrop.AddFileName(sPath);
  315. sPath += _T("rn");
  316. cf_text.SetString(sPath);
  317. CWDClipboardData::Instance()->SetData(pOleDataSource,&cf_text,CWDClipboardData::e_cfString);
  318. CWDClipboardData::Instance()->SetData(pOleDataSource,&cf_hdrop,CWDClipboardData::e_cfHDROP);
  319. CWDClipboardData::Instance()->SetData(pOleDataSource,&sl,CWDClipboardData::e_cfShellIDList);
  320. return GetShellPidl().GetDragDropAttributes(ptvid);
  321. }
  323. bool CIEShellTreeCtrl::EndLabelEdit(HTREEITEM hItem,LPCTSTR pszText)
  324. {
  325. LPTVITEMDATA plvit = (LPTVITEMDATA)GetItemData(hItem);
  326. CString sFromPath;
  327. CString sToPath;
  328. GetShellPidl().SHPidlToPathEx(plvit->lpifq,sFromPath);
  329. sToPath = sFromPath;
  330. sToPath.Replace(GetItemText(hItem),pszText);
  331. SHFILEOPSTRUCT shf;
  332. TCHAR szFrom[MAX_PATH+1];
  333. TCHAR szTo[MAX_PATH+1];
  334. ZeroMemory(szFrom,sizeof(szFrom));
  335. lstrcpy(szFrom,sFromPath);
  336. ZeroMemory(szTo,sizeof(szTo));
  337. lstrcpy(szTo,sToPath);
  338. ZeroMemory(&shf,sizeof(shf));
  339. shf.hwnd = GetSafeHwnd();
  340. shf.wFunc = FO_RENAME;
  341. shf.pFrom = szFrom;
  342. shf.pTo = szTo;
  343. #ifdef _DEBUG
  344. CString sMess;
  345. sMess = szFrom;
  346. sMess += _T("n");
  347. sMess += szTo;
  348. AfxMessageBox(sMess);
  349. #endif
  350. if (SHFileOperation(&shf) == 0)
  351. return true;
  352. SetRefreshAllowed(false);
  353. return false;
  354. }
  356. bool CIEShellTreeCtrl::SHMoveFile(HTREEITEM hSrcItem,HTREEITEM hDestItem)
  357. {
  358. LPTVITEMDATA plvit_src = (LPTVITEMDATA)GetItemData(hSrcItem);
  359. LPTVITEMDATA plvit_dest = (LPTVITEMDATA)GetItemData(hDestItem);
  360. CString sFromPath;
  361. CString sToPath;
  362. GetShellPidl().SHPidlToPathEx(plvit_src->lpifq,sFromPath);
  363. GetShellPidl().SHPidlToPathEx(plvit_dest->lpifq,sToPath);
  364. SHFILEOPSTRUCT shf;
  365. TCHAR szFrom[MAX_PATH+1];
  366. TCHAR szTo[MAX_PATH+1];
  367. ZeroMemory(szFrom,sizeof(szFrom));
  368. lstrcpy(szFrom,sFromPath);
  369. ZeroMemory(szTo,sizeof(szTo));
  370. lstrcpy(szTo,sToPath);
  371. ZeroMemory(&shf,sizeof(shf));
  372. shf.hwnd = GetSafeHwnd();
  373. shf.wFunc = FO_MOVE;
  374. shf.pFrom = szFrom;
  375. shf.pTo = szTo;
  376. return SHFileOperation(&shf) == 0 ? true : false;
  377. }
  379. BOOL CIEShellTreeCtrl::TransferItem(HTREEITEM hitemDrag, HTREEITEM hitemDrop)
  380. {
  381. return SHMoveFile(hitemDrag,hitemDrop) ? TRUE : FALSE;
  382. }
  384. bool CIEShellTreeCtrl::GetFolderInfo(HTREEITEM hItem,CString &sPath,CString &sName)
  385. {
  386. LPTVITEMDATA lptvid = (LPTVITEMDATA)GetItemData(hItem);
  387. if (lptvid == NULL)
  388. return false;
  389. GetShellPidl().SHPidlToPathEx(lptvid->lpifq,sPath,NULL,SHGDN_NORMAL);
  390. GetShellPidl().GetDisplayName(lptvid->lpi,sName);
  391. return true;
  392. }
  394. bool CIEShellTreeCtrl::LoadFolderItems(LPCTSTR pszPath)
  395. {
  396. return LoadItems(pszPath);
  397. }
  399. CRefresh *CIEShellTreeCtrl::CreateRefreshObject(HTREEITEM hItem,LPARAM lParam)
  400. {
  401. CRefreshShellFolder *pRefresh=NULL;
  402. if (lParam)
  403. {
  404. pRefresh = new CRefreshShellFolder(hItem,lParam);
  405. }
  406. return pRefresh;
  407. }
  409. bool CIEShellTreeCtrl::Expanding(NM_TREEVIEW *nmtvw)
  410. {
  411. if ((nmtvw->itemNew.state & TVIS_EXPANDEDONCE) || nmtvw->itemNew.hItem == GetRootItem())
  412. return false;
  414. LPSHELLFOLDER  pFolder=NULL;
  415. CUIListCtrlData *pData = (CUIListCtrlData*)nmtvw->itemNew.lParam;
  416. ASSERT(pData);
  417. ASSERT_KINDOF(CUIListCtrlData,pData);
  418. LPTVITEMDATA lptvid=(LPTVITEMDATA)pData->GetExtData();
  419. if (lptvid)
  420. {
  421. HRESULT hr=lptvid->lpsfParent->BindToObject(lptvid->lpi,
  422. 0, IID_IShellFolder,(LPVOID*)&pFolder);
  424. if (SUCCEEDED(hr))
  425. {
  426. if (!AddItems(nmtvw->itemNew.hItem,pFolder))
  427. SetButtonState(nmtvw->itemNew.hItem);
  428. }
  429. return false;
  430. }
  431. // prevent from expanding
  432. return true;
  433. }
  435. BEGIN_MESSAGE_MAP(CIEShellTreeCtrl, CIEFolderTreeCtrl)
  436. //{{AFX_MSG_MAP(CIEShellTreeCtrl)
  437. ON_MESSAGE(WM_SETMESSAGESTRING,OnSetmessagestring)
  438. ON_MESSAGE(WM_APP_CB_IE_HIT_ENTER,OnAppCbIeHitEnter)
  439. // NOTE - the ClassWizard will add and remove mapping macros here.
  440. ON_WM_DESTROY()
  441. //}}AFX_MSG_MAP
  442. ON_MESSAGE(WM_APP_POPULATE_TREE,OnAppPopulateTree)
  443. ON_MESSAGE(WM_APP_CB_IE_SEL_CHANGE,OnCBIESelChange)
  444. ON_MESSAGE(WM_APP_DIR_CHANGE_EVENT,OnAppDirChangeEvent)
  446. END_MESSAGE_MAP()
  448. /////////////////////////////////////////////////////////////////////////////
  449. // CIEShellTreeCtrl message handlers
  450. BOOL CIEShellTreeCtrl::OnWndMsg( UINT message, WPARAM wParam, LPARAM lParam, LRESULT* pResult )
  451. {
  452. if ((message == WM_MEASUREITEM || message == WM_DRAWITEM && wParam == 0) || message == WM_INITMENUPOPUP)
  453. {
  454. if (m_lptvid)
  455. {
  456. return GetShellPidl().HandleMenuMsg(m_hWnd,m_lptvid->lpsfParent, m_lptvid->lpi,
  457. message,wParam,lParam);
  458. }
  459. }
  460. return CIEFolderTreeCtrl::OnWndMsg(message, wParam, lParam, pResult );
  461. }
  463. void CIEShellTreeCtrl::PreSubclassWindow()
  464. {
  465. CIEFolderTreeCtrl::PreSubclassWindow();
  466. CreateFileChangeThreads(GetSafeHwnd());
  467. }
  469. /////////////////////////////////////////////////////////////////////////
  470. // Thread function for detecting file system changes
  471. UINT CIEShellTreeCtrl::ThreadFunc (LPVOID pParam)
  472. {
  473. ///////////////////////////////
  474.     PDC_THREADINFO pThreadInfo = (PDC_THREADINFO) pParam;
  475.     HANDLE hEvent = pThreadInfo->hEvent;
  476. CIEShellTreeCtrl *pTreeCtrl = pThreadInfo->pTreeCtrl;
  477.     HWND hWnd = pTreeCtrl->GetSafeHwnd();
  478. TCHAR szPath[MAX_PATH];
  479. lstrcpy(szPath,pThreadInfo->sPath);
  480.     delete pThreadInfo;
  481.     ////////////////////////////////////
  483.     // Get a handle to a file change notification object.
  484. TRACE(_T("Creating directory thread handler for %sn"),szPath);
  485.     HANDLE hDirChange = ::FindFirstChangeNotification (szPath,TRUE,FILE_NOTIFY_CHANGE_DIR_NAME);
  487.     // Return now if ::FindFirstChangeNotification failed.
  488.     if (hDirChange == INVALID_HANDLE_VALUE)
  489.         return 1;
  490. const int nHandles=2;
  491.     HANDLE aHandles[nHandles];
  492.     aHandles[0] = hDirChange;
  493.     aHandles[1] = hEvent;
  494.     BOOL bContinue = TRUE;
  496.     // Sleep until a file change notification wakes this thread or
  497.     // m_event becomes set indicating it's time for the thread to end.
  498.     while (bContinue)
  499. {
  500. TRACE(_T("TreeControl waiting for %u multiple objectsn"),nHandles);
  501.         DWORD dw = ::WaitForMultipleObjects (nHandles, aHandles, FALSE, INFINITE);
  502.         if (dw - WAIT_OBJECT_0 == 0) 
  503. { // Respond to a change notification.
  504.             ::FindNextChangeNotification (hDirChange);
  505. TRACE(_T("-- Directory notify event was fired in CIEShellTreeCtrl --n"));
  506. if (pTreeCtrl->RefreshAllowed())
  507. {
  508. ::PostMessage (hWnd, WM_APP_DIR_CHANGE_EVENT,0,0);
  509. }
  510. else
  511. {
  512. TRACE(_T("but not sending as refresh disallowedn"));
  513. pTreeCtrl->SetRefreshAllowed(true);
  514. TRACE(_T("Refresh is now allowedn"));
  515. }
  516.         }
  517.         else if(dw - WAIT_OBJECT_0 == 1) 
  518. {
  519.             bContinue = FALSE;
  520. TRACE(_T("Directory Notify Thread was signalled to stopn"));
  521. }
  522.     }
  524.     // Close the file change notification handle and return.
  525.     ::FindCloseChangeNotification (hDirChange);
  526. TRACE(_T("Directory Notify Thread is endingn"));
  527.     return 0;
  528. }
  530. void CIEShellTreeCtrl::OnDestroy()
  531. {
  532. DestroyThreads();
  533. CIEFolderTreeCtrl::OnDestroy();
  534. }
  536. LRESULT CIEShellTreeCtrl::OnAppDirChangeEvent(WPARAM wParam, LPARAM lParam)
  537. {
  538. if (!RefreshAllowed())
  539. return 1L;
  540. Refresh();
  541. if (m_bNotifyParent)
  542. GetParent()->SendMessage(WM_APP_UPDATE_ALL_VIEWS,(WPARAM)HINT_SHELL_DIR_CHANGED,(LPARAM)(LPCTSTR)GetRootPath());
  543. return 1L;
  544. }
  546. LRESULT CIEShellTreeCtrl::OnCBIESelChange(WPARAM wParam,LPARAM lParam)
  547. {
  548. LPITEMIDLIST pidl = (LPITEMIDLIST)wParam;
  549. ExpandMyComputer(pidl);
  550. FindPidl(pidl);
  551. GetShellPidl().FreePidl(pidl);
  552. SetFocus();
  553. return 1L;
  554. }
  556. // Selection has changed
  557. void CIEShellTreeCtrl::UpdateEvent(LPARAM lHint,CObject *pHint)
  558. {
  559. // TODO: Add your specialized code here and/or call the base class
  560. // Notify the combo box
  561. const CRefreshShellFolder *pRefresh = static_cast<CRefreshShellFolder*>(pHint);
  562. LPTVITEMDATA lptvid = reinterpret_cast<LPTVITEMDATA>(pRefresh->GetItemData());
  563. ASSERT(lptvid);
  564. // Notify combo box
  565. RefreshComboBox(lptvid);
  566. // Notify list control
  567. if (m_hListWnd)
  568. {
  569. ::SendMessage(m_hListWnd,WM_APP_UPDATE_ALL_VIEWS,(WPARAM)lHint,(LPARAM)pHint);
  570. return;
  571. }
  572. // or let base class handle it
  573. CUITreeCtrl::UpdateEvent(lHint,pHint);
  574. }
  576. LRESULT CIEShellTreeCtrl::OnAppPopulateTree(WPARAM wParam, LPARAM lParam)
  577. {
  578. TRACE0("Selecting root itemn");
  579. HTREEITEM hRoot = GetRootItem();
  580. if (hRoot == NULL)
  581. return 1L;
  582. SelectItem(hRoot);
  583. //#ifndef _DEBUG
  584. SelectionChanged(hRoot,GetItemData(hRoot));
  585. /*#else
  586. LPTVITEMDATA lptvid = reinterpret_cast<LPTVITEMDATA>(GetItemData(hRoot));
  587. RefreshComboBox(lptvid);
  588. #endif
  589. */
  590. return 1;
  591. }
  593. void CIEShellTreeCtrl::DeleteKey(HTREEITEM hItem)
  594. {
  595. // TODO: Add your specialized code here and/or call the base class
  596. SHFILEOPSTRUCT shf;
  597. ZeroMemory(&shf,sizeof(shf));
  598. TCHAR szFrom[MAX_PATH+1];
  599. ZeroMemory(szFrom,sizeof(szFrom)*sizeof(TCHAR));
  600. lstrcpy(szFrom,GetPathName(hItem));
  601. shf.hwnd = GetSafeHwnd();
  602. shf.wFunc = FO_DELETE;
  603. shf.pFrom = szFrom;
  604. shf.fFlags = GetKeyState(VK_SHIFT) < 0 ? 0 : FOF_ALLOWUNDO;
  605. SHFileOperation(&shf);
  606. }
  608. void CIEShellTreeCtrl::DoubleClick(HTREEITEM hItem)
  609. {
  610. // TODO: Add your specialized code here and/or call the base class
  611. //ShellExecute(hItem);  //comment by 阳光灿烂，i dont need this.
  612. }
  614. void CIEShellTreeCtrl::GoBack(HTREEITEM hItem)
  615. {
  616. // TODO: Add your specialized code here and/or call the base class
  617. UpOneLevel(hItem);
  618. }
  620. void CIEShellTreeCtrl::ShowPopupMenu(HTREEITEM hItem,CPoint point)
  621. {
  622. // TODO: Add your specialized code here and/or call the base class
  623. if (m_PopupID)
  624. {
  625. CUITreeCtrl::ShowPopupMenu(hItem,point);
  626. }
  627. // TODO: Add your control notification handler code here
  628. m_lptvid = (LPTVITEMDATA)GetItemData(hItem);
  629. if (m_lptvid)
  630. GetShellPidl().PopupTheMenu(m_hWnd,m_lptvid->lpsfParent, &m_lptvid->lpi, 1, &point);
  631. }
  633. void CIEShellTreeCtrl::ShowProperties(HTREEITEM hItem)
  634. {
  635. // TODO: Add your specialized code here and/or call the base class
  636. ShellExecute(hItem,_T("properties"));
  637. }
  639. LRESULT CIEShellTreeCtrl::OnAppCbIeHitEnter(WPARAM wParam, LPARAM lParam)
  640. {
  641. if (lParam == NULL)
  642. return 0L;
  643. LPCTSTR pszPath = (LPCTSTR)lParam;
  644. LPITEMIDLIST pidl=NULL;
  645. GetShellPidl().SHPathToPidlEx(pszPath,&pidl,NULL);
  646. if (pidl == NULL)
  647. return 0L;
  648. int nCount = GetShellPidl().GetCount(pidl);
  649. LPITEMIDLIST pidlPart=NULL;
  650. LPITEMIDLIST pidlFull=NULL;
  651. HTREEITEM hItem=NULL;
  652. SetRedraw(FALSE);
  653. for(int i=0;i < nCount;i++)
  654. {
  655. pidlPart=GetShellPidl().CopyItemID(pidl,i+1);
  656. if (pidlPart)
  657. {
  658. pidlFull = GetShellPidl().ConcatPidl(pidlFull,pidlPart);
  659. hItem = ExpandPidl(pidlFull);
  660. if (hItem == NULL)
  661. break;
  662. GetShellPidl().FreePidl(pidlPart);
  663. }
  664. }
  665. if (hItem && GetShellPidl().ComparePidls(NULL,pidl,pidlFull))
  666. {
  667. Select(hItem,TVGN_CARET);
  668. }
  669. else
  670. {
  671. CString sMess;
  672. sMess.Format(_T("%s was not found"),pszPath);
  673. AfxMessageBox(sMess,MB_ICONSTOP);
  674. }
  675. if (pidl)
  676. GetShellPidl().FreePidl(pidl);
  677. if (pidlFull)
  678. GetShellPidl().FreePidl(pidlFull);
  679. SetRedraw(TRUE);
  680. return 1;
  681. }
  683. LRESULT CIEShellTreeCtrl::OnSetmessagestring(WPARAM wParam, LPARAM lParam)
  684. {
  685. if (GetParent())
  686. return GetParent()->SendMessage(WM_SETMESSAGESTRING,wParam,lParam);
  687. return 0;
  688. }