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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 对话框与窗口 > 查看源码
XTShellTreeBase.cpp
资源名称：Xtreme.ToolkitPro.v12.0.0.rar　[点击查看]
上传用户：szled88
上传日期：2015-04-09
资源大小：43957k
文件大小：29k
源码类别：

对话框与窗口

开发平台：

Visual C++

XTShellTreeBase.cpp：源码内容
  1. // XTShellTreeView.cpp : implementation file
  2. //
  3. // This file is a part of the XTREME CONTROLS MFC class library.
  4. // (c)1998-2008 Codejock Software, All Rights Reserved.
  5. //
  6. // THIS SOURCE FILE IS THE PROPERTY OF CODEJOCK SOFTWARE AND IS NOT TO BE
  7. // RE-DISTRIBUTED BY ANY MEANS WHATSOEVER WITHOUT THE EXPRESSED WRITTEN
  8. // CONSENT OF CODEJOCK SOFTWARE.
  9. //
  10. // THIS SOURCE CODE CAN ONLY BE USED UNDER THE TERMS AND CONDITIONS OUTLINED
  11. // IN THE XTREME TOOLKIT PRO LICENSE AGREEMENT. CODEJOCK SOFTWARE GRANTS TO
  12. // YOU (ONE SOFTWARE DEVELOPER) THE LIMITED RIGHT TO USE THIS SOFTWARE ON A
  13. // SINGLE COMPUTER.
  14. //
  15. // CONTACT INFORMATION:
  16. // support@codejock.com
  17. // http://www.codejock.com
  18. //
  19. /////////////////////////////////////////////////////////////////////////////
  21. #include "stdafx.h"
  22. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  23. #include "Common/XTPResourceManager.h"
  25. #include "XTFunctions.h"
  26. #include "XTDropSource.h"
  28. #include "XTTreeBase.h"
  29. #include "XTShellSettings.h"
  30. #include "XTShellPidl.h"
  31. #include "XTShellTreeBase.h"
  32. #include "XTComboBoxEx.h"
  35. #ifdef _DEBUG
  36. #define new DEBUG_NEW
  37. #undef THIS_FILE
  38. static char THIS_FILE[] = __FILE__;
  39. #endif
  41. /////////////////////////////////////////////////////////////////////////////
  42. // CXTShellTreeBase
  44. CXTShellTreeBase::CXTShellTreeBase()
  45. : m_bTunneling(false)
  46. {
  47. m_bContextMenu = TRUE;
  48. m_pComboBox = NULL;
  49. m_uFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
  51. if (m_shSettings.ShowAllFiles() && !m_shSettings.ShowSysFiles())
  52. {
  53. m_uFlags |= SHCONTF_INCLUDEHIDDEN;
  54. }
  56. m_nRootFolder = CSIDL_DESKTOP;
  57. m_bShowFiles = FALSE;
  58. m_bShowShellLinkIcons = FALSE;
  59. }
  61. CXTShellTreeBase::~CXTShellTreeBase()
  62. {
  64. }
  66. /////////////////////////////////////////////////////////////////////////////
  67. // CXTShellTreeBase message handlers
  69. HTREEITEM CXTShellTreeBase::InsertDesktopItem(int nFolder /*= CSIDL_DESKTOP*/)
  70. {
  71. HTREEITEM hItem = TVI_ROOT;
  73. CShellMalloc lpMalloc;
  75. if (!lpMalloc)
  76. return NULL;
  78. // Get ShellFolder Pidl
  79. LPITEMIDLIST pidlDesktop = NULL;
  80. if (FAILED(::SHGetSpecialFolderLocation(NULL, nFolder, &pidlDesktop)))
  81. {
  82. pidlDesktop = NULL;
  83. }
  85. // insert the desktop.
  86. if (pidlDesktop)
  87. {
  88. SHFILEINFO fileInfo;
  89. ::ZeroMemory(&fileInfo, sizeof(fileInfo));
  91. ::SHGetFileInfo((LPCTSTR)pidlDesktop, NULL, &fileInfo, sizeof(fileInfo),
  92. SHGFI_PIDL | SHGFI_ATTRIBUTES | SHGFI_DISPLAYNAME);
  94. TV_ITEM  tvi;
  95. tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
  97. // Allocate memory for ITEMDATA struct
  98. XT_TVITEMDATA* lptvid = new XT_TVITEMDATA;
  99. if (lptvid != NULL)
  100. {
  101. GetNormalAndSelectedIcons(pidlDesktop, &tvi);
  103. // Now, make a copy of the ITEMIDLIST and store the parent folders SF.
  104. lptvid->lpi = DuplicateItem(lpMalloc, pidlDesktop);
  105. lptvid->lpsfParent = NULL;
  106. lptvid->lpifq = ConcatPidls(lpMalloc, NULL, pidlDesktop);
  108. TCHAR szBuff[MAX_PATH];
  109. STRCPY_S(szBuff, MAX_PATH, fileInfo.szDisplayName);
  111. tvi.lParam = (LPARAM)lptvid;
  112. tvi.pszText = szBuff;
  113. tvi.cchTextMax = MAX_PATH;
  115. // Populate the TreeVeiw Insert Struct
  116. // The item is the one filled above.
  117. // Insert it after the last item inserted at this level.
  118. // And indicate this is a root entry.
  119. TV_INSERTSTRUCT tvins;
  120. tvins.item = tvi;
  121. tvins.hInsertAfter = hItem;
  122. tvins.hParent = hItem;
  124. // Add the item to the tree
  125. hItem = m_pTreeCtrl->InsertItem(&tvins);
  126. }
  128. if (pidlDesktop)
  129. {
  130. lpMalloc.Free(pidlDesktop);
  131. }
  132. }
  134. return hItem;
  135. }
  138. void CXTShellTreeBase::PopulateTreeView()
  139. {
  140. // Get a pointer to the desktop folder.
  141. CShellSpecialFolder lpsfFolder(m_nRootFolder);
  142. if (!lpsfFolder)
  143. return;
  145. // turn off redraw and remove all tree items.
  146. m_pTreeCtrl->SetRedraw(FALSE);
  147. m_pTreeCtrl->DeleteAllItems();
  149. HTREEITEM hItemDesktop = InsertDesktopItem(m_nRootFolder);
  151. LPITEMIDLIST pidlRoot = NULL;
  152. if (FAILED(::SHGetSpecialFolderLocation(NULL, m_nRootFolder, &pidlRoot)))
  153. {
  154. pidlRoot = NULL;
  155. }
  157. // Fill in the tree view from the root.
  158. InitTreeViewItems(lpsfFolder, pidlRoot, hItemDesktop);
  160. if (pidlRoot)
  161. {
  162. CShellMalloc malloc;
  163. malloc.Free(pidlRoot);
  164. }
  166. // Sort the items in the tree view
  167. SortChildren(hItemDesktop);
  169. HTREEITEM hItemRoot = m_pTreeCtrl->GetRootItem();
  170. m_pTreeCtrl->Expand(hItemRoot, TVE_EXPAND);
  172. if (hItemDesktop != TVI_ROOT)
  173. {
  174. HTREEITEM hItemChild = m_pTreeCtrl->GetChildItem(hItemDesktop);
  175. m_pTreeCtrl->Select(hItemChild, TVGN_CARET);
  177. if ((::GetWindowLong(m_pTreeCtrl->m_hWnd, GWL_STYLE) & TVS_SINGLEEXPAND) == 0)
  178. {
  179. m_pTreeCtrl->Expand(hItemChild, TVE_EXPAND);
  180. }
  181. }
  182. else
  183. {
  184. m_pTreeCtrl->Select(hItemRoot, TVGN_CARET);
  185. }
  187. // turn on redraw and refresh tree.
  188. m_pTreeCtrl->SetRedraw(TRUE);
  189. m_pTreeCtrl->RedrawWindow();
  190. m_pTreeCtrl->SetFocus();
  191. }
  193. void CXTShellTreeBase::SetAttributes(HTREEITEM hItem, DWORD dwAttributes)
  194. {
  195. MapShellFlagsToItemAttributes(m_pTreeCtrl, hItem, dwAttributes);
  196. }
  198. BOOL CXTShellTreeBase::InitTreeViewItems(LPSHELLFOLDER lpsf, LPITEMIDLIST  lpifq, HTREEITEM     hParent)
  199. {
  200. CWaitCursor wait; // show wait cursor.
  202. // Allocate a shell memory object.
  203. CShellMalloc lpMalloc;
  205. if (!lpMalloc)
  206. return FALSE;
  208. // Get the IEnumIDList object for the given folder.
  209. LPENUMIDLIST lpe = NULL;
  210. if (FAILED(lpsf->EnumObjects(::GetParent(m_pTreeCtrl->m_hWnd), m_uFlags, &lpe)))
  211. return FALSE;
  213. ULONG        ulFetched = 0;
  214. HTREEITEM    hPrev = NULL;
  215. LPITEMIDLIST lpi = NULL;
  217. // Enumerate through the list of folder and non-folder objects.
  218. while (lpe->Next(1, &lpi, &ulFetched) == S_OK)
  219. {
  220. // Create a fully qualified path to the current item
  221. // the SH* shell api's take a fully qualified path pidl,
  222. // (see GetIcon above where I call SHGetFileInfo) whereas the
  223. // interface methods take a relative path pidl.
  224. ULONG ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_DISPLAYATTRMASK | SFGAO_REMOVABLE;
  226. // Determine what type of object we have.
  227. lpsf->GetAttributesOf(1, (const struct _ITEMIDLIST **)&lpi, &ulAttrs);
  229. // We need this next if statement so that we don't add things like
  230. // the MSN to our tree.  MSN is not a folder, but according to the
  231. // shell it has subfolders.
  232. if ((ulAttrs & SFGAO_FOLDER) || m_bShowFiles)
  233. {
  234. TV_ITEM  tvi;
  235. tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
  237. if ((ulAttrs & SFGAO_HASSUBFOLDER) || (m_bShowFiles && (ulAttrs & SFGAO_FOLDER)))
  238. {
  239. //This item has sub-folders, so let's put the + in the TreeView.
  240. //The first time the user clicks on the item, we'll populate the
  241. //sub-folders.
  242. tvi.cChildren = 1;
  243. tvi.mask |= TVIF_CHILDREN;
  244. }
  246. // Allocate memory for ITEMDATA struct
  247. CString szBuff;
  248. XT_TVITEMDATA* lptvid = new XT_TVITEMDATA;
  249. if (lptvid == NULL || GetName(lpsf, lpi, SHGDN_NORMAL, szBuff) == FALSE)
  250. {
  251. if (lptvid)
  252. {
  253. lpMalloc.Free(lptvid);
  254. }
  255. if (lpe)
  256. {
  257. lpe->Release();
  258. }
  259. if (lpi)
  260. {
  261. lpMalloc.Free(lpi);
  262. }
  263. return FALSE;
  264. }
  267. // Now, make a copy of the ITEMIDLIST and store the parent folders SF.
  268. lptvid->lpi = DuplicateItem(lpMalloc, lpi);
  269. lptvid->lpsfParent = lpsf;
  270. lptvid->lpifq = ConcatPidls(lpMalloc, lpifq, lpi);
  271. lpsf->AddRef();
  273. GetNormalAndSelectedIcons(lptvid->lpifq, &tvi);
  275. tvi.lParam = (LPARAM)lptvid;
  276. tvi.pszText = (LPTSTR)(LPCTSTR)szBuff;
  277. tvi.cchTextMax = 0;
  279. // Populate the TreeVeiw Insert Struct
  280. // The item is the one filled above.
  281. // Insert it after the last item inserted at this level.
  282. // And indicate this is a root entry.
  283. TV_INSERTSTRUCT tvins;
  284. tvins.item = tvi;
  285. tvins.hInsertAfter = hPrev;
  286. tvins.hParent = hParent;
  288. // Add the item to the tree
  289. hPrev = m_pTreeCtrl->InsertItem(&tvins);
  290. SetAttributes(hPrev, ulAttrs);
  291. }
  293. // Free the pidl that the shell gave us.
  294. if (lpi)
  295. {
  296. lpMalloc.Free(lpi);
  297. lpi = 0;
  298. }
  299. }
  300. if (lpi)
  301. {
  302. lpMalloc.Free(lpi);
  303. }
  305. if (lpe)
  306. {
  307. lpe->Release();
  308. }
  310. return TRUE;
  311. }
  313. void CXTShellTreeBase::GetNormalAndSelectedIcons(LPITEMIDLIST lpifq, LPTV_ITEM lptvitem)
  314. {
  315. // Note that we don't check the return value here because if GetIcon()
  316. // fails, then we're in big trouble...
  317. lptvitem->iImage = GetItemIcon(lpifq,
  318. SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  320. lptvitem->iSelectedImage = GetItemIcon(lpifq,
  321. SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON);
  322. }
  324. void CXTShellTreeBase::OnFolderExpanding(NM_TREEVIEW* pNMTreeView)
  325. {
  326. if (!(pNMTreeView->itemNew.state & TVIS_EXPANDEDONCE))
  327. {
  328. // Long pointer to TreeView item data
  329. XT_TVITEMDATA* lptvid = (XT_TVITEMDATA*)pNMTreeView->itemNew.lParam;
  330. if (lptvid != NULL && lptvid->lpsfParent != NULL)
  331. {
  332. LPSHELLFOLDER lpsf = NULL;
  333. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  334. 0, IID_IShellFolder, (LPVOID *)&lpsf)))
  335. {
  336. InitTreeViewItems(lpsf, lptvid->lpifq, pNMTreeView->itemNew.hItem);
  337. }
  339. SortChildren(pNMTreeView->itemNew.hItem);
  341. m_pTreeCtrl->SetItemState(pNMTreeView->itemNew.hItem, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  342. }
  343. }
  344. }
  346. HTREEITEM CXTShellTreeBase::GetContextMenu()
  347. {
  348. CPoint point;
  349. ::GetCursorPos(&point);
  350. m_pTreeCtrl->ScreenToClient(&point);
  352. TV_HITTESTINFO tvhti;
  353. tvhti.pt = point;
  354. m_pTreeCtrl->HitTest(&tvhti);
  356. if (tvhti.flags & (TVHT_ONITEMLABEL | TVHT_ONITEMICON))
  357. {
  358. // Long pointer to TreeView item data
  359. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(tvhti.hItem);
  361. m_pTreeCtrl->ClientToScreen(&point);
  363. if (lptvid->lpsfParent == NULL)
  364. {
  365. LPSHELLFOLDER lpShellFolder;
  366. if (FAILED(::SHGetDesktopFolder(&lpShellFolder)))
  367. {
  368. return NULL;
  369. }
  371. ShowContextMenu(m_pTreeCtrl->m_hWnd,
  372. lpShellFolder, lptvid->lpi, &point);
  374. if (lpShellFolder)
  375. {
  376. lpShellFolder->Release();
  377. }
  378. }
  379. else
  380. {
  381. ShowContextMenu(m_pTreeCtrl->m_hWnd,
  382. lptvid->lpsfParent, lptvid->lpi, &point);
  383. }
  385. return tvhti.hItem;
  386. }
  388. return NULL;
  389. }
  391. void CXTShellTreeBase::SortChildren(HTREEITEM hParent)
  392. {
  393. TV_SORTCB tvscb;
  394. tvscb.hParent = hParent;
  395. tvscb.lParam = 0;
  396. tvscb.lpfnCompare = TreeViewCompareProc;
  397. m_pTreeCtrl->SortChildrenCB(&tvscb);
  398. }
  400. BOOL CXTShellTreeBase::OnFolderSelected(NM_TREEVIEW* pNMTreeView, CString &strFolderPath)
  401. {
  402. BOOL bRet = FALSE;
  404. HTREEITEM hItem = pNMTreeView->itemNew.hItem;
  405. if (hItem == NULL)
  406. return FALSE;
  408. LPSHELLFOLDER lpsf = NULL;
  410. // Long pointer to TreeView item data
  411. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItem);
  412. if (lptvid && lptvid->lpsfParent && lptvid->lpi)
  413. {
  414. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  415. 0, IID_IShellFolder, (LPVOID*)&lpsf)))
  416. {
  417. ULONG ulAttrs = SFGAO_FILESYSTEM;
  419. // Determine what type of object we have.
  420. lptvid->lpsfParent->GetAttributesOf(1, (const struct _ITEMIDLIST **)&lptvid->lpi, &ulAttrs);
  422. if (ulAttrs & (SFGAO_FILESYSTEM))
  423. {
  424. TCHAR szBuff[MAX_PATH];
  425. if (::SHGetPathFromIDList(lptvid->lpifq, szBuff))
  426. {
  427. strFolderPath = szBuff;
  428. bRet = TRUE;
  429. }
  430. }
  432. if (m_pTreeCtrl->ItemHasChildren(pNMTreeView->itemNew.hItem) && !(pNMTreeView->itemNew.state & TVIS_EXPANDEDONCE))
  433. {
  434. InitTreeViewItems(lpsf, lptvid->lpifq, pNMTreeView->itemNew.hItem);
  436. SortChildren(pNMTreeView->itemNew.hItem);
  438. m_pTreeCtrl->SetItemState(pNMTreeView->itemNew.hItem, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  439. }
  441. if (lpsf)
  442. {
  443. lpsf->Release();
  444. }
  445. }
  446. }
  448. return bRet;
  449. }
  451. BOOL CXTShellTreeBase::InitSystemImageLists()
  452. {
  453. HIMAGELIST himlSmall = GetSystemImageList(SHGFI_SMALLICON);
  455. if (himlSmall)
  456. {
  457. TreeView_SetImageList(m_pTreeCtrl->GetSafeHwnd(), himlSmall, TVSIL_NORMAL);
  458. return TRUE;
  459. }
  461. return FALSE;
  462. }
  464. BOOL CXTShellTreeBase::GetSelectedFolderPath(CString &strFolderPath)
  465. {
  466. BOOL bRet = FALSE;
  468. HTREEITEM hItem = m_pTreeCtrl->GetSelectedItem();
  469. if (hItem != NULL)
  470. {
  471. // Long pointer to TreeView item data
  472. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItem);
  473. if (lptvid && lptvid->lpsfParent && lptvid->lpi)
  474. {
  475. LPSHELLFOLDER lpsf = NULL;
  476. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  477. 0, IID_IShellFolder, (LPVOID *)&lpsf)))
  478. {
  479. ULONG ulAttrs = SFGAO_FILESYSTEM;
  481. // Determine what type of object we have.
  482. lptvid->lpsfParent->GetAttributesOf(1, (const struct _ITEMIDLIST **)&lptvid->lpi, &ulAttrs);
  484. if (ulAttrs & (SFGAO_FILESYSTEM))
  485. {
  486. TCHAR szBuff[MAX_PATH];
  487. if (::SHGetPathFromIDList(lptvid->lpifq, szBuff))
  488. {
  489. strFolderPath = szBuff;
  490. bRet = TRUE;
  491. }
  492. }
  493. if (lpsf)
  494. {
  495. lpsf->Release();
  496. }
  497. }
  498. }
  499. }
  501. return bRet;
  502. }
  504. BOOL CXTShellTreeBase::FindTreeItem(HTREEITEM hItem, XT_LVITEMDATA* lplvid, BOOL bRecursively)
  505. {
  506. if (lplvid == NULL)
  507. {
  508. return FALSE;
  509. }
  511. if (!bRecursively)
  512. {
  513. hItem = m_pTreeCtrl->GetChildItem(hItem);
  514. }
  516. while (hItem)
  517. {
  518. // Long pointer to TreeView item data
  519. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItem);
  520. if (lptvid)
  521. {
  522. if (SCODE_CODE(GetScode(lplvid->lpsfParent->CompareIDs(
  523. 0, lplvid->lpi, lptvid->lpi))) == 0)
  524. {
  525. m_pTreeCtrl->EnsureVisible(hItem);
  526. m_pTreeCtrl->SelectItem(hItem);
  527. return TRUE;
  528. }
  529. }
  531. if (bRecursively)
  532. {
  533. HTREEITEM hNextItem = m_pTreeCtrl->GetChildItem(hItem);
  534. if (hNextItem)
  535. {
  536. if (FindTreeItem(hNextItem, lplvid))
  537. {
  538. return TRUE;
  539. }
  540. }
  541. }
  543. hItem = m_pTreeCtrl->GetNextSiblingItem(hItem);
  544. }
  546. return FALSE;
  547. }
  549. void CXTShellTreeBase::OnItemexpanding(NMHDR* pNMHDR, LRESULT* pResult)
  550. {
  551. NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  552. OnFolderExpanding(pNMTreeView);
  553. *pResult = 0;
  554. }
  556. void CXTShellTreeBase::SelectionChanged(HTREEITEM hItem, CString strFolderPath)
  557. {
  558. if (hItem != NULL && !m_bTunneling)
  559. {
  560. if (!m_pComboBox || !::IsWindow(m_pComboBox->m_hWnd))
  561. return;
  563. // update combo box association.
  564. if (m_pComboBox->IsKindOf(RUNTIME_CLASS(CXTComboBoxEx)))
  565. {
  566. CXTComboBoxEx* pComboBoxEx = DYNAMIC_DOWNCAST(CXTComboBoxEx, m_pComboBox);
  567. ASSERT_VALID(pComboBoxEx);
  569. int nFound = CB_ERR;
  570. int nIndex;
  571. for (nIndex = 0; nIndex < pComboBoxEx->GetCount(); ++nIndex)
  572. {
  573. CString strText;
  574. pComboBoxEx->GetLBText(nIndex, strText);
  576. if (strFolderPath.Compare(strText) == 0)
  577. {
  578. nFound = nIndex;
  579. pComboBoxEx->SetCurSel(nIndex);
  580. break;
  581. }
  582. }
  584. if (nFound == CB_ERR)
  585. {
  586. HTREEITEM hti = m_pTreeCtrl->GetSelectedItem();
  587. ASSERT(hti);
  589. if (strFolderPath.IsEmpty())
  590. {
  591. strFolderPath = m_pTreeCtrl->GetItemText(hti);
  592. }
  594. int nImage, nSelectedImage;
  595. m_pTreeCtrl->GetItemImage(hti, nImage, nSelectedImage);
  597. pComboBoxEx->InsertItem(0, strFolderPath, 0, nImage, nImage);
  598. pComboBoxEx->SetCurSel(0);
  599. pComboBoxEx->SetItemDataPtr(0, hti);
  600. }
  601. }
  603. else if (m_pComboBox->IsKindOf(RUNTIME_CLASS(CComboBox)))
  604. {
  605. CComboBox* pComboBox = DYNAMIC_DOWNCAST(CComboBox, m_pComboBox);
  606. ASSERT_VALID(pComboBox);
  608. int nFound = pComboBox->FindStringExact(-1, strFolderPath);
  609. if (nFound == CB_ERR)
  610. {
  611. HTREEITEM hti = m_pTreeCtrl->GetSelectedItem();
  612. ASSERT(hti);
  614. pComboBox->InsertString(0, strFolderPath);
  615. pComboBox->SetCurSel(0);
  616. pComboBox->SetItemDataPtr(0, (HTREEITEM)hti);
  617. }
  618. else
  619. {
  620. pComboBox->SetCurSel(nFound);
  621. }
  622. }
  623. }
  624. }
  625. void CXTShellTreeBase::OnDeleteTreeItem(NMHDR* pNMHDR, LRESULT* pResult)
  626. {
  627. NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  629. XT_TVITEMDATA* lptvid = (XT_TVITEMDATA*)pNMTreeView->itemOld.lParam;
  630. if (lptvid != NULL)
  631. {
  632. CShellMalloc lpMalloc;
  634. if (lptvid->lpi)
  635. {
  636. lpMalloc.Free(lptvid->lpi);
  637. lptvid->lpi = NULL;
  638. }
  639. if (lptvid->lpsfParent)
  640. {
  641. lptvid->lpsfParent->Release();
  642. lptvid->lpsfParent = NULL;
  643. }
  644. if (lptvid->lpifq)
  645. {
  646. lpMalloc.Free(lptvid->lpifq);
  647. lptvid->lpifq = NULL;
  648. }
  650. delete lptvid;
  651. }
  653. *pResult = 0;
  654. }
  656. void CXTShellTreeBase::OnSelchanged(NMHDR* pNMHDR, LRESULT* pResult)
  657. {
  658. NM_TREEVIEW* pNMTreeView = (NM_TREEVIEW*)pNMHDR;
  660. CString strFolderPath;
  661. OnFolderSelected(pNMTreeView, strFolderPath);
  663. if (strFolderPath.IsEmpty())
  664. {
  665. strFolderPath = m_pTreeCtrl->GetItemText(pNMTreeView->itemNew.hItem);
  666. }
  668. // currently selected TreeItem
  669. SelectionChanged(m_pTreeCtrl->GetSelectedItem(), strFolderPath);
  671. *pResult = 0;
  672. }
  674. void CXTShellTreeBase::OnRclick(NMHDR* /*pNMHDR*/, LRESULT* pResult)
  675. {
  676. // Display the shell context menu.
  677. if (m_bContextMenu == TRUE)
  678. {
  679. HTREEITEM hItem = GetContextMenu();
  680. if (hItem != NULL)
  681. {
  682. // TODO: Additional error handling.
  683. }
  684. }
  686. *pResult = 0;
  687. }
  690. BOOL CXTShellTreeBase::InitializeTree(DWORD dwStyle/*= TVS_HASBUTTONS | TVS_HASLINES | TVS_LINESATROOT*/)
  691. {
  692. if (m_pTreeCtrl->GetImageList(TVSIL_NORMAL) == NULL)
  693. {
  694. // Initialize the image list for the list view and populate it.
  695. VERIFY(InitSystemImageLists());
  697. // Set the style for the tree control.
  698. m_pTreeCtrl->ModifyStyle(0, dwStyle);
  700. // Make sure multi-select mode is disabled.
  701. EnableMultiSelect(FALSE);
  703. return TRUE;
  704. }
  706. return FALSE;
  707. }
  709. void CXTShellTreeBase::InitTreeNode(HTREEITEM hItem, XT_TVITEMDATA* lptvid)
  710. {
  711. m_pTreeCtrl->SetRedraw(FALSE);
  712. if (lptvid)
  713. {
  714. LPSHELLFOLDER lpsf = NULL;
  715. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  716. 0, IID_IShellFolder, (LPVOID *)&lpsf)))
  717. {
  718. InitTreeViewItems(lpsf, lptvid->lpifq, hItem);
  719. }
  721. SortChildren(hItem);
  722. }
  724. m_pTreeCtrl->SetRedraw(TRUE);
  725. }
  727. HTREEITEM CXTShellTreeBase::SearchTree(HTREEITEM hItem, LPCITEMIDLIST pABSPidl)
  728. {
  729. XT_TVITEMDATA *pItem = NULL;
  730. HTREEITEM hChildItem = m_pTreeCtrl->GetChildItem(hItem);
  732. CShellSpecialFolder pShellFolder;
  733. if (!pShellFolder)
  734. return NULL;
  736. while (hChildItem)
  737. {
  738. // Get the pidl that is stored in the tree node
  739. pItem = (XT_TVITEMDATA *)m_pTreeCtrl->GetItemData(hChildItem);
  741. // See if it matches the one we're looking for
  742. if (ComparePidls(pItem->lpifq, pABSPidl, pShellFolder))
  743. {
  744. m_pTreeCtrl->Select(hChildItem, TVGN_CARET);
  746. // Ensure that we are expanded
  747. UINT uState = m_pTreeCtrl->GetItemState(hChildItem, TVIS_EXPANDEDONCE);
  748. if (!(uState & TVIS_EXPANDEDONCE))
  749. {
  750. InitTreeNode(hChildItem, (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hChildItem));
  751. m_pTreeCtrl->SetItemState(hChildItem, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  752. }
  753. break;
  754. }
  756. // Didn't compare... try next one
  757. hChildItem = m_pTreeCtrl->GetNextSiblingItem(hChildItem);
  758. }
  760. return hChildItem;
  761. }
  763. BOOL CXTShellTreeBase::TunnelTree(CString strFindPath)
  764. {
  765. if (strFindPath.IsEmpty())
  766. return false;
  768. m_bTunneling = true;
  770. BOOL bLock = m_pTreeCtrl->LockWindowUpdate();
  771. BOOL bFound = false;
  773. LPITEMIDLIST pidlPath;
  775. // Attempt to get the folder's item list
  776. pidlPath = IDLFromPath(strFindPath);
  778. // If it is NULL then see if it is one of the special folders
  779. if (pidlPath == NULL)
  780. {
  781. // These are the ones we care about.
  782. const int nCSIDLMax = 0x001b;
  783. for (int i = 0; i <= nCSIDLMax; i++)
  784. {
  785. LPITEMIDLIST pidlSpecialPath = NULL;
  786. if (::SHGetSpecialFolderLocation(NULL, i, &pidlSpecialPath) != NOERROR)
  787. continue;
  789. SHFILEINFO fileInfo;
  790. ::ZeroMemory(&fileInfo, sizeof(fileInfo));
  791. ::SHGetFileInfo((LPCTSTR)pidlSpecialPath, NULL, &fileInfo, sizeof(fileInfo),
  792. SHGFI_PIDL | SHGFI_DISPLAYNAME);
  794. CString cs = fileInfo.szDisplayName;
  795. if (cs.CompareNoCase(strFindPath) == 0)
  796. {
  797. // Found the pidl for the special folder
  798. pidlPath = pidlSpecialPath;
  799. break;
  800. }
  801. }
  802. }
  804. if (pidlPath != NULL)
  805. {
  806. // Now work through the list and tree nodes until we compare
  807. int nItems = GetPidlCount(pidlPath);
  808. LPITEMIDLIST pPartPidl;
  809. LPITEMIDLIST pABSPidl = NULL;
  810. HTREEITEM hItem = m_pTreeCtrl->GetRootItem();
  811. bFound = false;
  813. // Loop through all the parts and see if we can find a match in the tree.  It should
  814. // be there unless something got added to the namespace after we built the tree last
  815. // and we didn't catch it, but that's pretty unlikely.
  816. for (int i = 0; i < nItems; i++)
  817. {
  818. pPartPidl = CopyPidlItem(pidlPath, i);
  819. pABSPidl = ConcatPidls(pABSPidl, pPartPidl);
  820. FreePidl(pPartPidl);
  822. hItem = SearchTree(hItem, pABSPidl);
  823. if (!hItem)
  824. break; // Our partial path should still found
  825. }
  827. // If it was found the final path should compare to the full path entered
  828. // and the hItem should be set to the place in the tree where the path ends
  829. if (hItem && (nItems == 0 || ComparePidls(pidlPath, pABSPidl, NULL)))
  830. {
  831. m_pTreeCtrl->Select(hItem, TVGN_CARET);
  832. // Ensure that we are expanded
  833. UINT uState = m_pTreeCtrl->GetItemState(hItem, TVIS_EXPANDEDONCE);
  834. if (!(uState & TVIS_EXPANDEDONCE))
  835. {
  836. InitTreeNode(hItem, (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItem));
  837. m_pTreeCtrl->SetItemState(hItem, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  838. }
  839. bFound = true;
  840. }
  842. // Clean up
  843. if (pidlPath)
  844. FreePidl(pidlPath);
  846. if (pABSPidl)
  847. FreePidl(pABSPidl);
  848. }
  849. else
  850. {
  851. // Must not be a special folder (stand alone) or a path that ParseDisplayName() doesn't recognize so look through tree
  852. // directly to see if we can find it that way.
  853. // Start at Desktop ...
  854. HTREEITEM hItemRoot = m_pTreeCtrl->GetRootItem();
  855. TCHAR* pszNext = NULL;
  856. TCHAR szBuff[MAX_PATH];
  858. STRCPY_S(szBuff, MAX_PATH, strFindPath);
  860. TCHAR* lpszContext = 0;
  861. pszNext = STRTOK_S(szBuff, _T("\/"), &lpszContext);
  863. bFound = false;
  865. if (pszNext != NULL)
  866. {
  867. CString strItemText(m_pTreeCtrl->GetItemText(hItemRoot));
  869. // Are we looking from desktop?
  870. if (strItemText.CompareNoCase(pszNext) == 0)
  871. pszNext = STRTOK_S(NULL, _T("\/"), &lpszContext);
  873. hItemRoot = m_pTreeCtrl->GetChildItem(hItemRoot);
  875. // Ensure that we are expanded
  876. UINT uState = m_pTreeCtrl->GetItemState(hItemRoot, TVIS_EXPANDEDONCE);
  877. if (!(uState & TVIS_EXPANDEDONCE))
  878. {
  879. InitTreeNode(hItemRoot, (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItemRoot));
  880. m_pTreeCtrl->SetItemState(hItemRoot, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  881. }
  883. while (pszNext && hItemRoot)
  884. {
  885. strItemText = m_pTreeCtrl->GetItemText(hItemRoot);
  886. if (strItemText.CompareNoCase(pszNext) == 0)
  887. {
  888. // Found it
  889. // We know this was successful - expand at this new root
  890. m_pTreeCtrl->Select(hItemRoot, TVGN_CARET);
  892. // Ensure that we are expanded
  893. uState = m_pTreeCtrl->GetItemState(hItemRoot, TVIS_EXPANDEDONCE);
  894. if (!(uState & TVIS_EXPANDEDONCE))
  895. {
  896. InitTreeNode(hItemRoot, (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItemRoot));
  897. m_pTreeCtrl->SetItemState(hItemRoot, TVIS_EXPANDEDONCE, TVIS_EXPANDEDONCE);
  898. }
  899. pszNext = STRTOK_S(NULL, _T("\/"), &lpszContext);
  900. if (pszNext)
  901. {
  902. // Move down a level
  903. hItemRoot = m_pTreeCtrl->GetChildItem(hItemRoot);
  904. }
  905. }
  906. else
  907. {
  908. hItemRoot = m_pTreeCtrl->GetNextSiblingItem(hItemRoot);
  909. }
  910. }
  911. }
  912. }
  914. if (bLock)
  915. {
  916. m_pTreeCtrl->UnlockWindowUpdate();
  917. }
  919. m_bTunneling = false;
  921. // make sure list gets updated.
  922. SelectionChanged(m_pTreeCtrl->GetSelectedItem(), strFindPath);
  923. return bFound;
  924. }
  928. BOOL CXTShellTreeBase::GetFolderItemPath(HTREEITEM hItem, CString &strFolderPath)
  929. {
  930. BOOL bRet = FALSE;
  932. // Long pointer to TreeView item data
  933. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(hItem);
  934. if (lptvid && lptvid->lpsfParent && lptvid->lpi)
  935. {
  936. LPSHELLFOLDER lpsf = NULL;
  937. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  938. 0, IID_IShellFolder, (LPVOID *)&lpsf)))
  939. {
  940. ULONG ulAttrs = SFGAO_FILESYSTEM;
  942. // Determine what type of object we have.
  943. lptvid->lpsfParent->GetAttributesOf(1,
  944. (const struct _ITEMIDLIST **)&lptvid->lpi, &ulAttrs);
  946. if (ulAttrs & (SFGAO_FILESYSTEM))
  947. {
  948. TCHAR szBuff[MAX_PATH];
  949. if (::SHGetPathFromIDList(lptvid->lpifq, szBuff))
  950. {
  951. strFolderPath = szBuff;
  952. bRet = TRUE;
  953. }
  954. }
  955. }
  956. if (lpsf)
  957. {
  958. lpsf->Release();
  959. }
  960. }
  962. return bRet;
  963. }
  965. //-----------------------------------------------------------------------------
  966. // FUNCTION: XTFuncPathFindNextComponent()
  967. //-----------------------------------------------------------------------------
  969. CString CXTShellTreeBase::PathFindNextComponent(const CString& pszPath)
  970. {
  971. // Find the path delimiter
  972. int nIndex = pszPath.Find(_T('\'));
  974. if (nIndex == -1)
  975. return _T("");
  977. return pszPath.Mid(nIndex + 1);
  978. }
  980. void CXTShellTreeBase::PopulateTree(LPCTSTR lpszPath)
  981. {
  982. CString strFolder = lpszPath;
  983. CString strNextFolder;
  984. CString strPath;
  986. CShellMalloc lpMalloc;
  987. if (!lpMalloc)
  988. return;
  990. // Get a pointer to the desktop folder.
  991. LPSHELLFOLDER lpSF = NULL;
  992. if (FAILED(::SHGetDesktopFolder(&lpSF)))
  993. return;
  995. LPITEMIDLIST lpIDL = NULL;
  997. // turn off redraw and remove all tree items.
  998. m_pTreeCtrl->SetRedraw(FALSE);
  999. m_pTreeCtrl->DeleteAllItems();
  1001. do
  1002. {
  1003. // Get the Next Component
  1004. strNextFolder = PathFindNextComponent(strFolder);
  1005. if (!strNextFolder.IsEmpty())
  1006. {
  1007. strPath = strFolder.Left(strFolder.GetLength() -
  1008. strNextFolder.GetLength());
  1009. }
  1010. else
  1011. {
  1012. strPath = strFolder;
  1013. strNextFolder.Empty();
  1014. }
  1016. // Get ShellFolder Pidl
  1017. ULONG eaten;
  1018. if (FAILED(lpSF->ParseDisplayName(NULL, NULL, (LPOLESTR)XTP_CT2CW(strPath),
  1019. &eaten, &lpIDL, NULL)))
  1020. {
  1021. break;
  1022. }
  1024. LPSHELLFOLDER lpSF2 = NULL;
  1025. if (FAILED(lpSF->BindToObject(lpIDL, 0, IID_IShellFolder, (LPVOID*)&lpSF2)))
  1026. {
  1027. break;
  1028. }
  1030. lpMalloc.Free(lpIDL);
  1032. // Release the Parent Folder pointer.
  1033. lpSF->Release();
  1035. // Change Folder Info
  1036. lpSF = lpSF2;
  1037. strFolder = strNextFolder;
  1038. }
  1039. while (!strNextFolder.IsEmpty());
  1041. // get the base folders item ide list.
  1042. lpIDL = IDLFromPath(lpszPath);
  1044. SHFILEINFO fileInfo;
  1045. ::ZeroMemory(&fileInfo, sizeof(fileInfo));
  1047. ::SHGetFileInfo((LPCTSTR)lpIDL, NULL, &fileInfo, sizeof(fileInfo),
  1048. SHGFI_PIDL | SHGFI_ATTRIBUTES | SHGFI_DISPLAYNAME);
  1050. TV_ITEM  tvi;
  1051. tvi.mask = TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_PARAM;
  1053. // Allocate memory for ITEMDATA struct
  1054. XT_TVITEMDATA* lptvid = new XT_TVITEMDATA;
  1055. if (lptvid != NULL)
  1056. {
  1057. HTREEITEM hItem = TVI_ROOT;
  1059. // get the normal and selected icons for the path.
  1060. GetNormalAndSelectedIcons(lpIDL, &tvi);
  1062. // Now, make a copy of the ITEMIDLIST and store the parent folders SF.
  1063. lptvid->lpi = DuplicateItem(lpMalloc, lpIDL);
  1064. lptvid->lpsfParent = NULL;
  1065. lptvid->lpifq = ConcatPidls(lpMalloc, NULL, lpIDL);
  1067. TCHAR szBuff[MAX_PATH];
  1068. STRCPY_S(szBuff, MAX_PATH, fileInfo.szDisplayName);
  1070. tvi.lParam = (LPARAM)lptvid;
  1071. tvi.pszText = szBuff;
  1072. tvi.cchTextMax = MAX_PATH;
  1074. // Populate the TreeView Insert Struct
  1075. // The item is the one filled above.
  1076. // Insert it after the last item inserted at this level.
  1077. // And indicate this is a root entry.
  1078. TV_INSERTSTRUCT tvins;
  1079. tvins.item = tvi;
  1080. tvins.hInsertAfter = hItem;
  1081. tvins.hParent = hItem;
  1083. // Add the item to the tree
  1084. hItem = m_pTreeCtrl->InsertItem(&tvins);
  1086. // insert child items.
  1087. InitTreeViewItems(lpSF, lpIDL, hItem);
  1089. // Sort the items in the tree view
  1090. SortChildren(TVI_ROOT);
  1092. // expand parent.
  1093. m_pTreeCtrl->Expand(hItem, TVE_EXPAND);
  1094. }
  1096. // turn on redraw and refresh tree.
  1097. m_pTreeCtrl->SetRedraw(TRUE);
  1098. m_pTreeCtrl->RedrawWindow();
  1100. lpMalloc.Free(lpIDL);
  1102. if (lpSF)
  1103. {
  1104. lpSF->Release();
  1105. }
  1106. }
  1108. void CXTShellTreeBase::AssociateCombo(CWnd* pWnd)
  1109. {
  1110. ASSERT_VALID(pWnd); // must be a valid window.
  1112. if (::IsWindow(pWnd->GetSafeHwnd()))
  1113. {
  1114. m_pComboBox = pWnd;
  1116. if (m_pComboBox->IsKindOf(RUNTIME_CLASS(CXTComboBoxEx)))
  1117. {
  1118. HIMAGELIST hImageList = GetSystemImageList(SHGFI_SMALLICON);
  1120. if (hImageList != NULL)
  1121. {
  1122. CXTComboBoxEx* pComboBoxEx = DYNAMIC_DOWNCAST(CXTComboBoxEx, m_pComboBox);
  1123. ASSERT_VALID(pComboBoxEx);
  1124. pComboBoxEx->SetImageList(CImageList::FromHandle(hImageList));
  1125. }
  1126. }
  1127. }
  1128. }
  1130. BOOL CXTShellTreeBase::OnEraseBkgnd(CDC* /*pDC*/)
  1131. {
  1132. return TRUE;
  1133. }
  1135. void CXTShellTreeBase::OnPaint()
  1136. {
  1137. CPaintDC dc(m_pTreeCtrl);
  1138. DoPaint(dc, FALSE);
  1139. }
  1141. void CXTShellTreeBase::BeginDrag(NM_TREEVIEW* pNMTreeView)
  1142. {
  1143. // Long pointer to ListView item data
  1144. XT_TVITEMDATA*  lplvid = (XT_TVITEMDATA*)m_pTreeCtrl->GetItemData(pNMTreeView->itemNew.hItem);
  1145. ASSERT(lplvid);
  1147. if (lplvid && lplvid->lpsfParent)
  1148. {
  1149. LPDATAOBJECT lpdo;
  1151. HRESULT hResult = lplvid->lpsfParent->GetUIObjectOf(AfxGetMainWnd()->m_hWnd, 1,
  1152. (const struct _ITEMIDLIST**)&lplvid->lpi, IID_IDataObject, 0, (LPVOID*)&lpdo);
  1154. if (SUCCEEDED(hResult))
  1155. {
  1156. LPDROPSOURCE lpds = new CXTDropSource();
  1157. ASSERT(lpds != NULL);
  1159. DWORD dwEffect;
  1160. ::DoDragDrop(lpdo, lpds,
  1161. DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK, &dwEffect);
  1163. lpdo->Release();
  1164. lpds->Release();
  1165. }
  1166. }
  1167. }