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

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

对话框与窗口

开发平台：

Visual C++

XTShellListBase.cpp：源码内容
  1. // XTShellListBase.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 "Resource.h"
  24. #include "Common/XTPVC80Helpers.h"  // Visual Studio 2005 helper functions
  25. #include "Common/XTPResourceManager.h"
  27. #include "XTDefines.h"
  28. #include "XTVC50Helpers.h"
  29. #include "XTFunctions.h"
  30. #include "XTHeaderCtrl.h"
  31. #include "XTListCtrlView.h"
  33. #include "XTShellPidl.h"
  34. #include "XTShellSettings.h"
  35. #include "XTDirWatcher.h"
  36. #include "XTShellListBase.h"
  37. #include "XTSortClass.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  45. /////////////////////////////////////////////////////////////////////////////
  46. // CXTShellListBase
  48. CXTShellListBase::CXTShellListBase()
  49. : m_pDirThread(0)
  50. {
  51. m_bContextMenu = TRUE;
  52. m_uFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;
  54. if (m_shSettings.ShowAllFiles() && !m_shSettings.ShowSysFiles())
  55. {
  56. m_uFlags |= SHCONTF_INCLUDEHIDDEN;
  57. }
  59. if (!SUCCEEDED(::SHGetSpecialFolderLocation(NULL, CSIDL_INTERNET, &m_pidlINet)))
  60. {
  61. m_pidlINet = NULL;
  62. }
  64. m_nNameColumnWidth = 150;
  66. m_lpsfFolder = NULL;
  67. }
  69. CXTShellListBase::~CXTShellListBase()
  70. {
  71. // End the directory monitoring thread.
  72. if (m_pDirThread)
  73. {
  74. m_pDirThread->StopNotifications();
  75. m_pDirThread = NULL;
  76. }
  78. if (m_pidlINet)
  79. {
  80. CShellMalloc lpMalloc;
  81. lpMalloc.Free(m_pidlINet);
  82. }
  84. SAFE_RELEASE(m_lpsfFolder);
  85. }
  87. /////////////////////////////////////////////////////////////////////////////
  88. // CXTShellListBase message handlers
  90. BOOL CXTShellListBase::PopulateListView(XT_TVITEMDATA* lptvid, LPSHELLFOLDER lpsf)
  91. {
  92. // Turn off redraw so the user does't see resorting
  93. m_pListCtrl->SetRedraw(false);
  95. //clear the view for new items
  96. m_pListCtrl->DeleteAllItems();
  98. SAFE_RELEASE(m_lpsfFolder);
  100. if (InitListViewItems(lptvid, lpsf))
  101. {
  102. SortList((m_nSortedCol > -1) ? m_nSortedCol : 0,
  103. (m_nSortedCol > -1) ? m_bAscending : 1);
  105. // create the directory monitoring thread.
  106. if (m_pDirThread == NULL)
  107. {
  108. m_pDirThread = (CXTDirWatcher*)AfxBeginThread(RUNTIME_CLASS(CXTDirWatcher),
  109. THREAD_PRIORITY_LOWEST, 0, CREATE_SUSPENDED, NULL);
  111. m_pDirThread->SetFolderData(m_pListCtrl, lptvid);
  112. m_pDirThread->ResumeThread();
  113. }
  115. // if the folder changed, update the folder data.
  116. else
  117. {
  118. TCHAR szFolderPath[_MAX_PATH];
  119. if (::SHGetPathFromIDList(lptvid->lpifq, szFolderPath))
  120. {
  121. CString strFolderPath = m_pDirThread->GetFolderPath();
  122. if (strFolderPath.CompareNoCase(szFolderPath) != 0)
  123. {
  124. m_pDirThread->SuspendThread();
  125. m_pDirThread->SetFolderData(m_pListCtrl, lptvid);
  126. m_pDirThread->ResumeThread();
  127. }
  128. }
  129. }
  131. m_lpsfFolder = lpsf;
  132. m_lpsfFolder->AddRef();
  134. m_pListCtrl->SetRedraw(true);
  135. return TRUE;
  136. }
  138. m_pListCtrl->SetRedraw(true);
  139. return FALSE;
  140. }
  142. void CXTShellListBase::BuildDefaultColumns()
  143. {
  144. CString strLabel;
  145. VERIFY(XTPResourceManager()->LoadString(&strLabel, XT_IDS_NAME));
  146. m_pListCtrl->InsertColumn(0, strLabel, LVCFMT_LEFT, m_nNameColumnWidth, 0);
  148. VERIFY(XTPResourceManager()->LoadString(&strLabel, XT_IDS_SIZE));
  149. m_pListCtrl->InsertColumn(1, strLabel, LVCFMT_RIGHT, 100, 1);
  151. VERIFY(XTPResourceManager()->LoadString(&strLabel, XT_IDS_TYPE));
  152. m_pListCtrl->InsertColumn(2, strLabel, LVCFMT_LEFT, 120, 2);
  154. VERIFY(XTPResourceManager()->LoadString(&strLabel, XT_IDS_MODIFIED));
  155. m_pListCtrl->InsertColumn(3, strLabel, LVCFMT_LEFT, 120, 3);
  156. }
  158. BOOL CXTShellListBase::InitSystemImageLists()
  159. {
  160. HIMAGELIST himlSmall = GetSystemImageList(SHGFI_SMALLICON);
  162. HIMAGELIST himlLarge = GetSystemImageList(SHGFI_LARGEICON);
  164. if (himlSmall && himlLarge)
  165. {
  166. ListView_SetImageList(m_pListCtrl->GetSafeHwnd(), himlSmall, LVSIL_SMALL);
  167. ListView_SetImageList(m_pListCtrl->GetSafeHwnd(), himlLarge, LVSIL_NORMAL);
  168. return TRUE;
  169. }
  171. return FALSE;
  172. }
  174. BOOL CXTShellListBase::IsItemFiltered(LPCTSTR lpszItemName, ULONG ulItemAttrs)
  175. {
  176. if (ulItemAttrs & SFGAO_FOLDER)
  177. return FALSE;
  179. if (!m_csIncludeEXT.IsEmpty())
  180. {
  181. TCHAR szDrive[_MAX_DRIVE];
  182. TCHAR szDir[_MAX_DIR];
  183. TCHAR szFileName[_MAX_FNAME];
  184. TCHAR szExt[_MAX_EXT];
  186. SPLITPATH_S(lpszItemName, szDrive, szDir, szFileName, szExt);
  188. if (_tcsclen(szExt) == 0)
  189. return m_csIncludeEXT.Find(_T("*.;")) == -1;
  191. return m_csIncludeEXT.Find(szExt) == -1;
  192. }
  194. return FALSE;
  195. }
  198. BOOL CXTShellListBase::InitListViewItems(XT_TVITEMDATA* lptvid, LPSHELLFOLDER lpsf)
  199. {
  200. CShellMalloc lpMalloc;
  202. if (!lpMalloc)
  203. return FALSE;
  205. LPENUMIDLIST lpe = NULL;
  207. if (FAILED(lpsf->EnumObjects(::GetParent(m_pListCtrl->m_hWnd), m_uFlags, &lpe)))
  208. return FALSE;
  210. int          iCtr = 0;
  211. ULONG        ulFetched = 0;
  212. LPITEMIDLIST lpi = NULL;
  214. while (lpe->Next(1, &lpi, &ulFetched) == S_OK)
  215. {
  216. // Now get the friendly name that we'll put in the treeview...
  217. CString szFileName, szFullFilePath;
  218. GetName(lpsf, lpi, SHGDN_NORMAL, szFileName);
  219. GetName(lpsf, lpi, SHGDN_FORPARSING, szFullFilePath);
  221. // Note that since we are interested in the display attributes as well as
  222. // the other attributes, we need to set ulAttrs to SFGAO_DISPLAYATTRMASK
  223. // before calling GetAttributesOf();
  224. ULONG ulAttrs = SFGAO_DISPLAYATTRMASK | SFGAO_REMOVABLE;
  225. UINT  uFlags = SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON;
  226. lpsf->GetAttributesOf(1, (const struct _ITEMIDLIST **)&lpi, &ulAttrs);
  228. BOOL bIncludeFile = !IsItemFiltered(szFullFilePath, ulAttrs);
  230. if (bIncludeFile)
  231. {
  232. // allocate memory for ITEMDATA struct
  233. XT_LVITEMDATA* lplvid = new XT_LVITEMDATA;
  234. if (lplvid == NULL)
  235. {
  236. if (lpe)
  237. {
  238. lpe->Release();
  239. }
  241. return FALSE;
  242. }
  244. lplvid->ulAttribs = ulAttrs;
  245. LPITEMIDLIST lpifqThisItem = ConcatPidls(lpMalloc, lptvid->lpifq, lpi);
  247. LV_ITEM lvi;
  248. lvi.mask = LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
  249. lvi.iItem = iCtr++;
  250. lvi.iSubItem = 0;
  251. lvi.pszText = (LPTSTR)(LPCTSTR)szFileName;
  252. lvi.cchTextMax = 0;
  253. lvi.iImage = GetItemIcon(lpifqThisItem, uFlags);
  255. lplvid->lpsfParent = lpsf;
  256. lpsf->AddRef();
  258. // Make a copy of the ITEMIDLIST
  259. lplvid->lpi = DuplicateItem(lpMalloc, lpi);
  260. lvi.lParam = (LPARAM)lplvid;
  262. // Add the item to the listview
  263. int iIndex = m_pListCtrl->InsertItem(&lvi);
  264. SetAttributes(iIndex, ulAttrs);
  265. if (iIndex >= 0)
  266. {
  267. TCHAR szItemPath[_MAX_PATH];
  268. ::SHGetPathFromIDList(lpifqThisItem, szItemPath);
  270. if (((ulAttrs & SFGAO_FILESYSTEM) == SFGAO_FILESYSTEM) &&
  271. ((ulAttrs & SFGAO_FOLDER) == 0))
  272. {
  273. WIN32_FIND_DATA fdata;
  274. HANDLE handle = ::FindFirstFile(szItemPath, &fdata);
  276. if (handle != INVALID_HANDLE_VALUE)
  277. {
  278. LONGLONG fsize = fdata.nFileSizeHigh*((LONGLONG)ULONG_MAX + 1) + fdata.nFileSizeLow;
  280. TCHAR szBuffer[16];
  281. CString strSize;
  282. strSize.Format(_T("%s KB"), InsertCommas((fsize + 1024)/1024, szBuffer, 15));
  284. m_pListCtrl->SetItemText(iIndex, 1, strSize);
  286. FILETIME ltime;
  287. ::FileTimeToLocalFileTime(&fdata.ftLastWriteTime, &ltime);
  289. SYSTEMTIME time;
  290. ::FileTimeToSystemTime(&ltime, &time);
  292. if ((time.wYear >= 1970 && time.wYear <= 2038) &&
  293. (time.wMonth >= 1 && time.wMonth <= 12))
  294. {
  295. CTime cTime;
  296. cTime = CTime(
  297. time.wYear,
  298. time.wMonth,
  299. time.wDay,
  300. time.wHour,
  301. time.wMinute,
  302. time.wSecond);
  304. m_pListCtrl->SetItemText(iIndex, 3, cTime.Format(_T("%m/%d/%y %I:%M %p")));
  305. }
  306. else
  307. {
  308. m_pListCtrl->SetItemText(iIndex, 3, _T("")); // Invalid date
  309. }
  311. ::FindClose(handle);
  312. }
  314. }
  315. else
  316. {
  317. m_pListCtrl->SetItemText(iIndex, 2, _T("0 bytes"));
  318. }
  320. SHFILEINFO sfi;
  321. ::SHGetFileInfo((TCHAR*)lpifqThisItem, 0, &sfi,
  322. sizeof(SHFILEINFO), SHGFI_PIDL | SHGFI_TYPENAME);
  324. m_pListCtrl->SetItemText(iIndex, 2, sfi.szTypeName);
  325. }
  326. else
  327. {
  328. if (lpifqThisItem)
  329. {
  330. lpMalloc.Free(lpifqThisItem);
  331. }
  333. return FALSE;
  334. }
  337. if (lpifqThisItem)
  338. {
  339. lpMalloc.Free(lpifqThisItem);
  340. }
  341. }
  343. // Free the pidl that the shell gave us.
  344. if (lpi)
  345. {
  346. lpMalloc.Free(lpi);
  347. lpi = NULL;
  348. }
  349. }
  351. if (lpe)
  352. {
  353. lpe->Release();
  354. }
  356. return TRUE;
  357. }
  359. TCHAR* CXTShellListBase::InsertCommas(LONGLONG value, TCHAR* szBufferOut, UINT nSize)
  360. {
  361. CString strValue; // 30 digits is a really big number
  362. TCHAR szBufferIn[30]; // 30 digits is a really big number
  363. TCHAR szDecimalSep[ 5 ];
  364. TCHAR szThousandSep[ 5 ];
  366. NUMBERFMT fmt;
  367. fmt.NumDigits = 0; // No decimal places
  368. ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_ILZERO, szBufferIn, 2);
  369. fmt.LeadingZero = _ttoi(szBufferIn);
  370. fmt.Grouping = 3;
  371. ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SDECIMAL, szDecimalSep, 4);
  372. fmt.lpDecimalSep = szDecimalSep;
  373. ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_STHOUSAND, szThousandSep, 4);
  374. fmt.lpThousandSep = szThousandSep;
  375. ::GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_INEGNUMBER, szBufferIn, 2);
  376. fmt.NegativeOrder = _ttoi(szBufferIn);
  377. strValue.Format(_T("%I64d"), value);
  378. ::GetNumberFormat(LOCALE_USER_DEFAULT, 0, strValue, &fmt, szBufferOut, nSize);
  380. return szBufferOut;
  381. }
  383. void CXTShellListBase::GetNormalAndSelectedIcons(LPITEMIDLIST lpifq, LPTV_ITEM lptvitem)
  384. {
  385. // Note that we don't check the return value here because if GetIcon()
  386. // fails, then we're in big trouble...
  387. lptvitem->iImage = GetItemIcon(lpifq,
  388. SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  390. lptvitem->iSelectedImage = GetItemIcon(lpifq,
  391. SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON | SHGFI_OPENICON);
  392. }
  394. int CXTShellListBase::GetDoubleClickedItem()
  395. {
  396. CPoint point;
  397. ::GetCursorPos(&point);
  398. m_pListCtrl->ScreenToClient(&point);
  400. LV_HITTESTINFO  lvhti;
  401. lvhti.pt = point;
  402. m_pListCtrl->HitTest(&lvhti);
  404. if ((lvhti.flags & LVHT_ONITEM) == 0)
  405. {
  406. return -1;
  407. }
  409. return lvhti.iItem;
  410. }
  412. void CXTShellListBase::ShowShellContextMenu(CPoint point)
  413. {
  414. if (m_bContextMenu == FALSE)
  415. return;
  417. CPoint ptClient(point);
  418. m_pListCtrl->ScreenToClient(&ptClient);
  420. int nIndex = point == CPoint(-1, -1) ? m_pListCtrl->GetNextItem(-1, LVNI_FOCUSED) : m_pListCtrl->HitTest(ptClient);
  422. if (nIndex != -1)
  423. {
  424. if (point == CPoint(-1, -1))
  425. {
  426. CRect rcItem;
  427. m_pListCtrl->GetItemRect(nIndex, &rcItem, LVIR_ICON);
  428. point = rcItem.CenterPoint();
  429. m_pListCtrl->ClientToScreen(&point);
  430. }
  432. XT_LVITEMDATA* lplvid = (XT_LVITEMDATA*)m_pListCtrl->GetItemData(nIndex);
  433. ASSERT(lplvid != NULL);
  434. if (!lplvid)
  435. return;
  437. CPtrArray arrItems;
  438. arrItems.Add(lplvid->lpi);
  440. POSITION pos = m_pListCtrl->GetFirstSelectedItemPosition();
  442. while (NULL != pos)
  443. {
  444. int nSelItem = m_pListCtrl->GetNextSelectedItem(pos);
  446. XT_LVITEMDATA* lplvidSelected = (XT_LVITEMDATA*)m_pListCtrl->GetItemData(nSelItem);
  447. ASSERT(lplvidSelected != NULL);
  449. if (lplvidSelected != lplvid && lplvidSelected)
  450. arrItems.Add(lplvidSelected->lpi);
  451. }
  453. CXTShellPidl::ShowContextMenu(m_pListCtrl->m_hWnd,
  454. lplvid->lpsfParent, (LPCITEMIDLIST*)arrItems.GetData(), (int)arrItems.GetSize(), &point);
  456. }
  457. else if (m_lpsfFolder)
  458. {
  459. ShowContextMenu(m_pListCtrl->m_hWnd, m_lpsfFolder, 0, 0, &point);
  460. }
  461. }
  463. bool CXTShellListBase::ShellOpenItem(int iItem)
  464. {
  465. // Long pointer to ListView item data
  466. XT_LVITEMDATA*  lplvid = (XT_LVITEMDATA*)m_pListCtrl->GetItemData(iItem);
  467. return ShellOpenItem(lplvid);
  468. }
  470. bool CXTShellListBase::ShellOpenItem(XT_LVITEMDATA* lplvid)
  471. {
  472. // Long pointer to ListView item data
  473. if (!(lplvid->ulAttribs & (SFGAO_FOLDER | SFGAO_FILESYSANCESTOR | SFGAO_REMOVABLE)))
  474. {
  475. SHELLEXECUTEINFO sei;
  476. ::ZeroMemory(&sei, sizeof(SHELLEXECUTEINFO));
  478. sei.cbSize = sizeof(SHELLEXECUTEINFO);
  479. sei.fMask = SEE_MASK_INVOKEIDLIST;
  480. sei.hwnd = ::GetParent(m_pListCtrl->m_hWnd);
  481. sei.nShow = SW_SHOWNORMAL;
  482. sei.hInstApp = AfxGetInstanceHandle();
  483. sei.lpIDList = GetFullyQualPidl(lplvid->lpsfParent, lplvid->lpi);
  485. if (::ShellExecuteEx(&sei))
  486. {
  487. return true;
  488. }
  489. }
  491. return false;
  492. }
  494. BOOL CXTShellListBase::GetItemPath(int iItem, CString& strItemPath)
  495. {
  496. if (iItem >= 0)
  497. {
  498. // Long pointer to TreeView item data
  499. XT_LVITEMDATA*  lplvid = (XT_LVITEMDATA*)m_pListCtrl->GetItemData(iItem);
  500. if (lplvid != 0)
  501. {
  502. LPITEMIDLIST lpid = GetFullyQualPidl(lplvid->lpsfParent, lplvid->lpi);
  504. TCHAR szItemPath[_MAX_PATH];
  505. if (::SHGetPathFromIDList(lpid, szItemPath))
  506. {
  507. strItemPath = szItemPath;
  508. return TRUE;
  509. }
  510. }
  511. }
  513. return FALSE;
  514. }
  516. void CXTShellListBase::OnDeleteListItem(NMHDR* pNMHDR, LRESULT* pResult)
  517. {
  518. NM_LISTVIEW* pNMTreeView = (NM_LISTVIEW*)pNMHDR;
  520. XT_LVITEMDATA* lplvid = (XT_LVITEMDATA*)pNMTreeView->lParam;
  521. if (lplvid != NULL)
  522. {
  523. CShellMalloc lpMalloc;
  525. if (lplvid->lpi)
  526. {
  527. lpMalloc.Free(lplvid->lpi);
  528. lplvid->lpi = NULL;
  529. }
  530. if (lplvid->lpsfParent)
  531. {
  532. lplvid->lpsfParent->Release();
  533. lplvid->lpsfParent = NULL;
  534. }
  536. delete lplvid;
  537. }
  539. *pResult = 0;
  540. }
  543. void CXTShellListBase::UpdateList(int nMessage, XT_TVITEMDATA* pItemData)
  544. {
  545. switch (nMessage)
  546. {
  547. case SHN_XT_CONTENTSCHANGED:
  548. case SHN_XT_TREESELCHANGE:
  549. {
  550. CWnd* pOwner = m_pListCtrl->GetOwner();
  551. ASSERT_VALID(pOwner);
  552. if (!pOwner)
  553. return;
  555. // The tree view selection has changed, so update the contents
  556. // of the list view
  557. XT_TVITEMDATA*  lptvid = (XT_TVITEMDATA*)pItemData;
  558. ASSERT(lptvid != NULL);
  559. if (!lptvid)
  560. return;
  562. if (lptvid->lpsfParent == NULL)
  563. {
  564. CShellMalloc lpMalloc;
  565. if (!lpMalloc)
  566. {
  567. return;
  568. }
  570. LPSHELLFOLDER lpShellFolder;
  571. if (FAILED(::SHGetDesktopFolder(&lpShellFolder)))
  572. {
  573. return;
  574. }
  576. LPITEMIDLIST pidlDesktop = NULL;
  577. if (FAILED(::SHGetSpecialFolderLocation(NULL, CSIDL_DESKTOP, &pidlDesktop)))
  578. {
  579. lpShellFolder->Release();
  580. return;
  581. }
  583. IShellFolder *pFolder = NULL;
  584. if (lpShellFolder->CompareIDs(0, lptvid->lpifq, pidlDesktop) == 0)
  585. {
  586. pFolder = lpShellFolder;
  587. }
  588. else
  589. {
  590. lpShellFolder->BindToObject(lptvid->lpifq, 0, IID_IShellFolder, (LPVOID*)&pFolder);
  591. lpShellFolder->Release();
  592. }
  593. ASSERT (pFolder != 0);
  595. PopulateListView(lptvid, pFolder);
  597. if (m_pidlINet && (pFolder->CompareIDs(0, lptvid->lpifq, m_pidlINet) == 0))
  598. {
  599. pOwner->SendMessage(XTWM_SHELL_NOTIFY, SHN_XT_INETFOLDER);
  600. }
  601. else
  602. {
  603. pOwner->SendMessage(XTWM_SHELL_NOTIFY);
  604. }
  606. if (pidlDesktop)
  607. {
  608. lpMalloc.Free(pidlDesktop);
  609. }
  610. if (pFolder)
  611. {
  612. pFolder->Release();
  613. }
  614. }
  615. else
  616. {
  617. LPSHELLFOLDER lpsf = NULL;
  618. if (SUCCEEDED(lptvid->lpsfParent->BindToObject(lptvid->lpi,
  619. 0, IID_IShellFolder, (LPVOID*)&lpsf)))
  620. {
  621. PopulateListView(lptvid, lpsf);
  622. lpsf->Release();
  624. if (SUCCEEDED(::SHGetDesktopFolder(&lpsf)))
  625. {
  626. if (m_pidlINet && (lpsf->CompareIDs(0, lptvid->lpifq, m_pidlINet) == 0))
  627. {
  628. pOwner->SendMessage(XTWM_SHELL_NOTIFY, SHN_XT_INETFOLDER);
  629. }
  630. else
  631. {
  632. pOwner->SendMessage(XTWM_SHELL_NOTIFY);
  633. }
  635. lpsf->Release();
  636. }
  637. }
  638. else
  639. {
  640. if (SUCCEEDED(::SHGetDesktopFolder(&lpsf)))
  641. {
  642. if (m_pidlINet && (lpsf->CompareIDs(0, lptvid->lpifq, m_pidlINet) == 0))
  643. {
  644. pOwner->SendMessage(XTWM_SHELL_NOTIFY, SHN_XT_INETFOLDER);
  645. }
  647. lpsf->Release();
  648. }
  649. }
  650. }
  651. break;
  652. }
  654. case SHN_XT_REFRESHFOLDER:
  655. case SHN_XT_REFRESHTREE:
  656. {
  657. // Directory monitory thread has issued an update notification,
  658. // refresh the list control.
  659. XT_TVITEMDATA*  lpTVID = (XT_TVITEMDATA*)pItemData;
  660. ASSERT(lpTVID);
  661. if (!lpTVID)
  662. return;
  664. PopulateListView(lpTVID, lpTVID->lpsfParent);
  665. break;
  666. }
  668. case SHN_XT_NOFOLDER:
  669. {
  670. // The item double clicked was not found in the treeview
  671. // so it sent us back a confirmation to execute it
  672. XT_LVITEMDATA*  lplvid = (XT_LVITEMDATA*)pItemData;
  673. ASSERT(lplvid);
  674. if (!lplvid)
  675. return;
  677. ShellOpenItem(lplvid);
  678. }
  679. break;
  681. default:
  682. break;
  683. }
  684. }
  686. bool CXTShellListBase::SortList(int nCol, bool bAscending)
  687. {
  688. if (m_nSortedCol >= 0)
  689. {
  690. CXTFlatHeaderCtrl* pHeaderCtrl = GetFlatHeaderCtrl();
  691. if (pHeaderCtrl && pHeaderCtrl->GetSortedCol() < 0)
  692. {
  693. pHeaderCtrl->SetSortImage(nCol, bAscending);
  694. }
  695. }
  697. if (nCol == 0)
  698. {
  699. return m_pListCtrl->SortItems(
  700. ListViewCompareProc, (DWORD)bAscending) == TRUE;
  701. }
  703. XTSortType arrColType[] =
  704. {
  705. xtSortString, xtSortInt, xtSortString, xtSortDateTime
  706. };
  708. CXTSortClass sortClass(m_pListCtrl, nCol);
  709. sortClass.Sort(bAscending, arrColType[nCol]);
  711. return true;
  712. }
  714. void CXTShellListBase::SetAttributes(int iItem, DWORD dwAttributes)
  715. {
  716. MapShellFlagsToItemAttributes(m_pListCtrl, iItem, dwAttributes);
  717. }
  719. void CXTShellListBase::OnDragDrop(NM_LISTVIEW* /*pNMListView*/)
  720. {
  721. COleDataSource oleDataSource;
  722. HGLOBAL        hgDrop;
  723. DROPFILES*     pDrop;
  724. CStringList    lsDraggedFiles;
  725. POSITION       pos;
  726. int            nSelItem;
  727. CString        sFile;
  728. UINT           uBuffSize = 0;
  729. TCHAR*         pszBuff;
  731. FORMATETC      etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
  733. // For every selected item in the list, put the filename into lsDraggedFiles.
  734. pos = m_pListCtrl->GetFirstSelectedItemPosition();
  736. while (NULL != pos)
  737. {
  738. nSelItem = m_pListCtrl->GetNextSelectedItem(pos);
  739. GetItemPath(nSelItem, sFile);
  740. lsDraggedFiles.AddTail (sFile);
  742. // Calculate the # of chars required to hold this string.
  743. uBuffSize += lstrlen (sFile) + 1;
  744. }
  746. // Add 1 extra for the final null char, and the size of the DROPFILES struct.
  747. uBuffSize = sizeof(DROPFILES) + sizeof(TCHAR) * (uBuffSize + 1);
  749. // Allocate memory from the heap for the DROPFILES struct.
  750. hgDrop = ::GlobalAlloc (GHND | GMEM_SHARE, uBuffSize);
  752. if (NULL == hgDrop)
  753. return;
  755. pDrop = (DROPFILES*) ::GlobalLock (hgDrop);
  757. if (NULL == pDrop)
  758. {
  759. ::GlobalFree (hgDrop);
  760. return;
  761. }
  763. // Fill in the DROPFILES struct.
  764. pDrop->pFiles = sizeof(DROPFILES);
  766. #ifdef _UNICODE
  767. // If we're compiling for Unicode, set the Unicode flag in the struct to
  768. // indicate it contains Unicode strings.
  769. pDrop->fWide = TRUE;
  770. #endif
  772. // Copy all the filenames into memory after the end of the DROPFILES struct.
  773. pos = lsDraggedFiles.GetHeadPosition();
  774. pszBuff = (TCHAR*) (LPBYTE(pDrop) + sizeof(DROPFILES));
  776. while (NULL != pos)
  777. {
  778. lstrcpy (pszBuff, (LPCTSTR) lsDraggedFiles.GetNext (pos));
  779. pszBuff = 1 + _tcschr (pszBuff, '');
  780. }
  782. ::GlobalUnlock (hgDrop);
  784. // Put the data in the data source.
  785. oleDataSource.CacheGlobalData (CF_HDROP, hgDrop, &etc);
  787. // Add in our own custom data, so we know that the drag originated from our
  788. // window.  OnDragEnter() checks for this custom format, and
  789. // doesn't allow the drop if it's present.  This is how we prevent the user
  790. // from dragging and then dropping in our own window.
  791. // The data will just be a dummy bool.
  792. HGLOBAL hgBool;
  794. hgBool = ::GlobalAlloc (GHND | GMEM_SHARE, sizeof(bool));
  796. if (NULL == hgBool)
  797. {
  798. ::GlobalFree (hgDrop);
  799. return;
  800. }
  802. static CLIPFORMAT clpFormat = (CLIPFORMAT)
  803. ::RegisterClipboardFormat(_T("{B0D76F7A-B5D9-436c-8F10-BA16AEE69D42}"));
  805. // Put the data in the data source.
  806. etc.cfFormat = clpFormat;
  807. oleDataSource.CacheGlobalData(clpFormat, hgBool, &etc);
  809. // Start the drag 'n' drop!
  810. DROPEFFECT dwEffect = oleDataSource.DoDragDrop (DROPEFFECT_COPY | DROPEFFECT_MOVE);
  812. // If the DnD completed OK, we remove all of the dragged items from our
  813. //
  814. switch (dwEffect)
  815. {
  816. case DROPEFFECT_MOVE:
  817. {
  818. // The files were copied or moved.
  819. // Note: Don't call ::GlobalFree() because the data will be freed by the drop target.
  820. for (nSelItem = m_pListCtrl->GetNextItem (-1, LVNI_SELECTED);
  821. nSelItem != -1;
  822. nSelItem = m_pListCtrl->GetNextItem (nSelItem, LVNI_SELECTED))
  823. {
  824. m_pListCtrl->DeleteItem (nSelItem);
  825. nSelItem--;
  826. }
  827. }
  828. break;
  830. case DROPEFFECT_COPY:
  831. break;
  833. case DROPEFFECT_NONE:
  834. {
  835. // This needs special handling, because on NT, DROPEFFECT_NONE
  836. // is returned for move operations, instead of DROPEFFECT_MOVE.
  837. // See Q182219 for the details.
  838. // So if we're on NT, we check each selected item, and if the
  839. // file no longer exists, it was moved successfully and we can
  840. // remove it from the
  841. if ((GetVersion() & 0x80000000) == 0)
  842. {
  843. bool bDeletedAnything = false;
  845. for (nSelItem = m_pListCtrl->GetNextItem (-1, LVNI_SELECTED);
  846. nSelItem != -1;
  847. nSelItem = m_pListCtrl->GetNextItem(nSelItem, LVNI_SELECTED))
  848. {
  849. GetItemPath(nSelItem, sFile);
  851. if (GetFileAttributes(sFile) == DWORD(-1) &&
  852. GetLastError() == ERROR_FILE_NOT_FOUND)
  853. {
  854. // We couldn't read the file's attributes, and GetLastError()
  855. // says the file doesn't exist, so remove the corresponding
  856. // item from the
  857. m_pListCtrl->DeleteItem(nSelItem);
  859. nSelItem--;
  860. bDeletedAnything = true;
  861. }
  862. }
  864. // Resize the list columns if we deleted any items.
  865. if (bDeletedAnything)
  866. {
  867. m_pListCtrl->SetColumnWidth (0, LVSCW_AUTOSIZE_USEHEADER);
  868. m_pListCtrl->SetColumnWidth (1, LVSCW_AUTOSIZE_USEHEADER);
  869. m_pListCtrl->SetColumnWidth (2, LVSCW_AUTOSIZE_USEHEADER);
  871. // Note: Don't call ::GlobalFree() because the data belongs to
  872. // the caller.
  873. }
  874. else
  875. {
  876. // The DnD operation wasn't accepted, or was canceled, so we
  877. // should call ::GlobalFree() to clean up.
  878. ::GlobalFree (hgDrop);
  879. ::GlobalFree (hgBool);
  880. }
  881. }   // end if (NT)
  882. else
  883. {
  884. // We're on 9x, and a return of DROPEFFECT_NONE always means
  885. // that the DnD operation was aborted.  We need to free the
  886. // allocated memory.
  887. ::GlobalFree (hgDrop);
  888. ::GlobalFree (hgBool);
  889. }
  890. }
  891. break;  // end case DROPEFFECT_NONE
  892. }   // end switch
  893. }
  896. bool CXTShellListBase::Init()
  897. {
  898. if (!CXTListBase::Init())
  899. return false;
  901. if (!m_pListCtrl->GetImageList(LVSIL_SMALL))
  902. {
  903. // Initialize the columns and image list for the list control.
  904. BuildDefaultColumns();
  905. InitSystemImageLists();
  906. m_pListCtrl->ModifyStyle(NULL, LVS_REPORT | LVS_SHAREIMAGELISTS);
  908. SubclassHeader(FALSE);
  909. GetFlatHeaderCtrl()->ShowSortArrow(TRUE);
  911. m_pListCtrl->DragAcceptFiles(TRUE);
  912. }
  914. return true;
  915. }