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

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

图形图象

开发平台：

Visual C++

IEShellListCtrl.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. // IEShellListCtrl.cpp : implementation file
  19. #include "stdafx.h"
  20. #include "IEShellListCtrl.h"
  21. #include "UIMessages.h"
  22. #include "dirwalk.h"
  23. #include "cbformats.h"
  24. #include "..IRWEngineIRWEngine.h"
  26. #ifdef _DEBUG
  27. #define new DEBUG_NEW
  28. #undef THIS_FILE
  29. static char THIS_FILE[] = __FILE__;
  30. #endif
  32. #ifdef _DEBUG
  33. #pragma comment(lib,"..\IRWEngine\Debug\IRWEngine.lib")
  34. #else
  35. #pragma comment(lib,"..\IRWEngine\Release\IRWEngine.lib")
  36. #endif
  38. COLORREF bkColor[15] = 
  39. { 
  40. RGB(255,255,255),
  41. RGB(255,255,255),
  42. RGB(255,255,255),
  43. RGB(255,255,255),
  44. RGB(255,255,255),
  45. RGB(255,255,255),
  46. RGB(255,255,255),
  47. RGB(255,255,255),
  48. RGB(255,255,255),
  49. RGB(255,255,255),
  50. RGB(255,255,255),
  51. RGB(255,255,255),
  52. RGB(255,255,255),
  53. RGB(255,255,255),
  54. RGB(255,255,255),
  55. };
  58. #define UMAKEINT64(low,high) ((unsigned __int64)(((DWORD)(low)) | ((unsigned __int64)((DWORD)(high))) << 32))
  59. /////////////////////////////////////////////////////////////////////////////
  60. // CIEShellListCtrl
  62. CIEShellListCtrl::CIEShellListCtrl()
  63. {
  64. SetEditSubItems(false);
  65. SetDropFiles(false);
  66. ZeroMemory(&m_tvid,sizeof(m_tvid));
  67. m_psfSubFolder = NULL;
  68. m_pMalloc = NULL;
  69. m_bCallBack = false;
  70. m_bNoExt = false;
  71. m_nThreadCount = 0;
  72. m_bRefreshAllowed = true;
  73. m_bPopulateInit = false;
  74. m_bInitiliazed = false;
  75. m_bNotifyParent = false;
  76. m_pidlInternet = NULL;
  77. SHGetMalloc(&m_pMalloc);
  78. SHGetSpecialFolderLocation(NULL,CSIDL_INTERNET,&m_pidlInternet);
  79. m_sColumns = _T("名称|大小|类型|修改时间");
  80. }
  82. CIEShellListCtrl::~CIEShellListCtrl()
  83. {
  84. FreeTVID();
  85. AllItemsDeleted();
  86. if (m_pidlInternet)
  87. m_pMalloc->Release();
  88. if (m_pMalloc)
  89. m_pMalloc->Release();
  90. }
  92. void CIEShellListCtrl::PopupTheMenu(int nRow,CPoint point)
  93. {
  94. if (!GetSelectedCount())
  95. return;
  96. int nSel=-1;
  97. LPLVITEMDATA lplvid=NULL;
  98. LPITEMIDLIST *pidls=(LPITEMIDLIST*)GetShellPidl().GetMalloc()->Alloc(GetSelectedCount()*sizeof(LPITEMIDLIST));
  99. int i=0;
  100. while ((nSel = GetNextSel(nSel)) != -1)
  101. {
  102. lplvid=(LPLVITEMDATA)GetItemData(nSel);
  103. pidls[i] = lplvid->lpi;
  104. i++;
  105. }
  106. // at least one
  107. if (pidls && i)
  108. {
  109. GetShellPidl().PopupTheMenu(m_hWnd, lplvid->lpsfParent, pidls, i, &point);
  110. }
  111. GetShellPidl().Free(pidls);
  112. }
  114. void CIEShellListCtrl::ShellExecute(int nRow,LPCTSTR pszVerb)
  115. {
  116. SHELLEXECUTEINFO si;
  117. ZeroMemory(&si,sizeof(si));
  118. si.cbSize = sizeof(si);
  119. si.hwnd = GetSafeHwnd();
  120. si.nShow = SW_SHOW;
  121. si.lpIDList = (LPVOID)GetPathPidl(nRow);
  122. si.fMask  = SEE_MASK_INVOKEIDLIST;
  123. if (pszVerb)
  124. si.lpVerb = pszVerb;
  125. ShellExecuteEx(&si);
  126. }
  128. void CIEShellListCtrl::SetNotificationObject(bool bNotify)
  129. {
  130. if (bNotify)
  131. CreateFileChangeThread(GetSafeHwnd());
  132. else
  133. DestroyThreads();
  134. }
  136. void CIEShellListCtrl::FreeInterface(IUnknown *pInterface)
  137. {
  138. if (pInterface)
  139. pInterface->Release();
  140. }
  142. void CIEShellListCtrl::DestroyThreads()
  143. {
  144.     if (m_nThreadCount == 0) 
  145. return;
  146.     for (UINT i=0; i<m_nThreadCount; i++)
  147.     m_event[i].SetEvent();
  148.     ::WaitForMultipleObjects (m_nThreadCount, m_hThreads, TRUE, INFINITE);
  149.     for (i=0; i<m_nThreadCount; i++)
  150.         delete m_pThreads[i];
  151.     m_nThreadCount = 0;
  152. }
  154. void CIEShellListCtrl::FreeTVID()
  155. {
  156. if (m_tvid.lpsfParent)
  157. m_tvid.lpsfParent->Release();
  158. if (m_tvid.lpi)
  159. m_pMalloc->Free(m_tvid.lpi);
  160. if (m_tvid.lpifq)
  161. m_pMalloc->Free(m_tvid.lpifq);
  162. ZeroMemory(&m_tvid,sizeof(m_tvid));
  163. if (m_psfSubFolder)
  164. m_psfSubFolder->Release();
  165. m_psfSubFolder = NULL;
  166. }
  168. CString CIEShellListCtrl::GetCurrPathName()
  169. {
  170. return GetPathName(GetCurSel());
  171. }
  173. CString CIEShellListCtrl::GetPathName(int nRow)
  174. {
  175. if (nRow == -1)
  176. nRow = GetCurSel();
  177. CString sPath;
  178. if (nRow == -1)
  179. return sPath;
  180. LPLVITEMDATA plvit = (LPLVITEMDATA)GetItemData(nRow);
  181. ASSERT(plvit);
  182. if (plvit == NULL)
  183. return sPath;
  184. SHGetPathFromIDList(plvit->lpifq,sPath.GetBuffer(MAX_PATH));
  185. sPath.ReleaseBuffer();
  186. return sPath;
  187. }
  189. LPCITEMIDLIST CIEShellListCtrl::GetPathPidl(int nRow)
  190. {
  191. if (nRow == -1)
  192. return NULL;
  193. LPLVITEMDATA plvit = (LPLVITEMDATA)GetItemData(nRow);
  194. ASSERT(plvit);
  195. if (plvit == NULL)
  196. return NULL;
  197. return plvit->lpifq;
  198. }
  200. void CIEShellListCtrl::FillExcludedFileTypes(CComboBox &cb)
  201. {
  202. cb.ResetContent();
  203. for(POSITION pos=m_ExcludedLookup.GetHeadPosition();pos != NULL;m_ExcludedLookup.GetNext(pos))
  204. {
  205. cb.AddString(m_ExcludedLookup.GetAt(pos));
  206. }
  207. }
  209. void CIEShellListCtrl::SetExcludedFileTypes(CComboBox &cb)
  210. {
  211. m_ExcludedLookup.RemoveAll();
  212. CString sText;
  213. for(int i=0;i < cb.GetCount();i++)
  214. {
  215. cb.GetLBText(i,sText);
  216. m_ExcludedLookup.AddHead(sText);
  217. }
  218. }
  220. void CIEShellListCtrl::LoadFilterFiles(const CString &sFileFilter)
  221. {
  222. m_FilterLookup.RemoveAll();
  223. CFileFind ff;
  224. CString sPath;
  225. if (FAILED(GetShellPidl().SHPidlToPathEx(m_tvid.lpifq,sPath)))
  226. return;
  227. if (sPath.Right(1) != _T('\'))
  228. sPath += _T('\');
  229. CString sFindPath;
  230. CString sMask;
  231. LPCTSTR pszFilter=sFileFilter;
  232. pszFilter = GetFilterMask(pszFilter,sMask);
  233. while (pszFilter != NULL)
  234. {
  235. sFindPath = sPath;
  236. sFindPath += sMask;
  237. BOOL bFind = ff.FindFile(sFindPath);  
  238. while (bFind)
  239. {
  240. bFind = ff.FindNextFile();
  241. m_FilterLookup.AddHead(ff.GetFilePath());
  242. }
  243. pszFilter = GetFilterMask(pszFilter,sMask);
  244. }
  245. }
  247. LPCTSTR CIEShellListCtrl::GetFilterMask(LPCTSTR pszFilter,CString &sMask)
  248. {
  249. if (*pszFilter == '')
  250. return NULL;
  251. TCHAR szMask[MAX_PATH];
  252. szMask[0] = 0;
  253. for(int i=0;*pszFilter != '';i++)
  254. {
  255. if (*pszFilter == _T(';') || *pszFilter == _T(','))
  256. {
  257. pszFilter = _tcsinc(pszFilter);
  258. break;
  259. }
  260. szMask[i] = *pszFilter;
  261. pszFilter = _tcsinc(pszFilter);
  262. }
  263. szMask[i] = 0;
  264. sMask = szMask;
  265. return pszFilter;
  266. }
  268. void CIEShellListCtrl::AllItemsDeleted()
  269. {
  270. LPLVITEMDATA pItemData=NULL;
  271. for(vecListItemData::iterator it=m_vecItemData.begin();it != m_vecItemData.end();it++)
  272. {
  273. pItemData = *it;
  274. if (pItemData)
  275. {
  276. if (pItemData->lpsfParent)
  277. pItemData->lpsfParent->Release();
  278. if (pItemData->lpi)
  279. m_pMalloc->Free(pItemData->lpi);  
  280. if (pItemData->lpifq)
  281. m_pMalloc->Free(pItemData->lpifq);  
  282. if (pItemData->lParam)
  283. {
  284. PSLC_COLUMN_DATA pColData = (PSLC_COLUMN_DATA)pItemData->lParam;
  285. if (pColData->pidl)
  286. GetShellPidl().FreePidl(pColData->pidl);
  287. delete pColData;
  288. }
  289. //清除文件项的回执单
  290. if ( pItemData->pRReceipt )
  291. {
  292. //回执单的析构函数将自动清除各种资源
  293. //pItemData->pRReceipt->ClearImageBitData();
  294. delete pItemData->pRReceipt;
  295. }
  296. m_pMalloc->Free(pItemData);
  297. }
  298. }
  299. m_vecItemData.erase(m_vecItemData.begin(),m_vecItemData.end());
  300. }
  302. void CIEShellListCtrl::StartPopulate()
  303. {
  304. m_bPopulateInit = true;
  305. m_iProcessed = 0;
  306. DeleteAllItems();
  307. for(UINT i=0;i < m_nThreadCount;i++)
  308. m_MonitorEvent[i].SetEvent();
  309. if (m_sFileFilter.IsEmpty() || m_sFileFilter == _T("*.*") || m_sFileFilter == _T("*"))
  310. return;
  311. LoadFilterFiles(m_sFileFilter);
  312. }
  314. void CIEShellListCtrl::EndPopulate()
  315. {
  316. m_bPopulateInit = false;
  317. Sort();
  318. SetColumnWidths();
  319. }
  321. BOOL CIEShellListCtrl::Populate(LPTVITEMDATA lptvid)
  322. {
  323. IShellFolder *pFolder=NULL;
  324. BOOL bRet=FALSE;
  325. HRESULT hr=E_FAIL;
  326. if (lptvid->lpsfParent)
  327. {
  328. hr=lptvid->lpsfParent->BindToObject(lptvid->lpi,0,IID_IShellFolder,(LPVOID*)&pFolder);
  329. }
  330. else
  331. {
  332. LPSHELLFOLDER psfDesktop;
  333. LPITEMIDLIST pidlDesktop=NULL;
  334. hr=SHGetDesktopFolder(&psfDesktop);
  335. SHGetSpecialFolderLocation(NULL,CSIDL_DESKTOP,&pidlDesktop);
  336. if (GetShellPidl().ComparePidls(NULL,lptvid->lpifq,pidlDesktop))
  337. {
  338. pFolder = psfDesktop;
  339. }
  340. else
  341. {
  342. hr=psfDesktop->BindToObject(lptvid->lpifq,0,IID_IShellFolder,(LPVOID*)&pFolder);
  343. psfDesktop->Release();
  344. }
  345. if (pidlDesktop)
  346. GetShellPidl().FreePidl(pidlDesktop);
  347. }
  348. if (SUCCEEDED(hr))
  349. {
  350. bRet = Populate(lptvid,pFolder,true);
  351. pFolder->Release();
  352. }
  353. return bRet;
  354. }
  356. BOOL CIEShellListCtrl::Populate(LPCTSTR pszPath, bool bCallBack)
  357. {
  358. LPITEMIDLIST pidlfq=NULL;
  359. LPITEMIDLIST pidl=NULL;
  360. LPSHELLFOLDER pDesktop = NULL;
  361.     SHGetDesktopFolder(&pDesktop);
  362. if (FAILED(GetShellPidl().SHPathToPidlEx(pszPath,&pidlfq,pDesktop)))
  363. return FALSE;
  364. LPSHELLFOLDER pSubFolder = NULL;
  365. pidl = pidlfq; //add this by 阳光灿烂
  366. //i think the author forget this statment;
  367. if (FAILED(pDesktop->BindToObject(pidl, 0, IID_IShellFolder,(LPVOID*)&pSubFolder)))
  368. return FALSE;
  369. pidl = GetShellPidl().CopyLastItemID(pidlfq);
  370. TVITEMDATA tvid;
  371. tvid.lpifq = pidlfq;
  372. tvid.lpi = pidl;
  373. tvid.lpsfParent = NULL;
  374. BOOL bRet = Populate(&tvid,pSubFolder,bCallBack);
  375. if (pDesktop)
  376. pDesktop->Release();
  377. if (pSubFolder)
  378. pSubFolder->Release();
  379. if (pidl)
  380. m_pMalloc->Free(pidl);
  381. if (pidlfq)
  382. m_pMalloc->Free(pidlfq);
  384. return bRet;
  385. }
  387. BOOL CIEShellListCtrl::Populate(LPTVITEMDATA lptvid,LPSHELLFOLDER psfFolder,bool bCallBack)
  388. {
  389. m_bCallBack = bCallBack;
  390. FreeTVID();
  391. m_tvid.lpi = GetShellPidl().CopyItemIDList(lptvid->lpi);
  392. m_tvid.lpifq = GetShellPidl().CopyItemIDList(lptvid->lpifq);
  393. #ifdef _DEBUG
  394. CString sPath;
  395. GetShellPidl().SHPidlToPathEx(m_tvid.lpifq,sPath,NULL);
  396. TRACE1("Populating path %s in CIEShellListCtrln",sPath);
  397. #endif
  398. if (lptvid->lpsfParent)
  399. {
  400. m_tvid.lpsfParent = lptvid->lpsfParent;
  401. m_tvid.lpsfParent->AddRef();
  402. }
  403. m_psfSubFolder = psfFolder;
  404. m_psfSubFolder->AddRef();
  405. Load();
  406.     return TRUE;
  407. }
  409. CString CIEShellListCtrl::GetColumns()
  410. {
  411. SHELLDETAILS sd;
  412. LPTSTR pszHeader=NULL;
  413. CString sColumns;
  414. for(int i=0;SUCCEEDED(m_ShellDetails.GetDetailsOf(NULL,i,&sd));i++)
  415. {
  416. GetShellPidl().StrRetToStr(sd.str,&pszHeader,NULL);
  417. if (pszHeader)
  418. {
  419. TRACE1("Column found %sn",pszHeader);
  420. if (!sColumns.IsEmpty())
  421. sColumns += _T("|");
  422. sColumns += pszHeader;
  423. GetShellPidl().Free(pszHeader);
  424. pszHeader= NULL;
  425. }
  426. }
  427. return sColumns;
  428. }
  430. void CIEShellListCtrl::InitColumns()
  431. {
  432. CString sColumns = GetColumns();
  433. if (sColumns.IsEmpty())
  434. sColumns = m_sColumns;
  435. InitListCtrl(sColumns);
  436. }
  438. void CIEShellListCtrl::SetColumnWidths()
  439. {
  440. if (!m_bCallBack)
  441. {
  442. for(int i=0;i < GetColumnCount();i++)
  443. SetColumnWidth(i,LVSCW_AUTOSIZE);
  444. }
  445. }
  447. void CIEShellListCtrl::Refresh()
  448. {
  449. if (m_psfSubFolder==NULL)
  450. return;
  451. SetRefreshAllowed(false);
  452. SetRedraw(FALSE);
  453. int nCurSel = GetCurSel();
  454. TRACE(_T("Refreshing shell list controln"));
  455. Load();
  456. SetCurSel(nCurSel);
  457. LONG Result;
  458. OnSelChanged(nCurSel,&Result);
  459. SetRedraw(TRUE);
  460. SetRefreshAllowed(true);
  461. }
  463. void CIEShellListCtrl::Load()
  464. {
  465. CWaitCursor w;
  466.     if (!InitItems(&m_tvid,m_bCallBack))
  467.         return;
  468. }
  470. void CIEShellListCtrl::Init()
  471. {
  472. if (m_bInitiliazed)
  473. return;
  474. CUIODListCtrl::Init();
  475. InitShellSettings();
  476. InitImageLists();
  477. m_bInitiliazed = true;
  478. }
  480. BOOL CIEShellListCtrl::InitItems(LPTVITEMDATA lptvid, bool bCallBack)
  481. {
  482. CWaitCursor w;
  484. Init();
  486. ASSERT(m_psfSubFolder);
  487. if (m_psfSubFolder == NULL)
  488. return FALSE;
  490. // Try to initialize columns from shell
  491. m_ShellDetails.SetShellDetails(NULL);
  492. IShellFolder2 *pShellFolder2=NULL;
  493. HRESULT hr=m_psfSubFolder->QueryInterface(IID_IShellFolder2,(LPVOID*)&pShellFolder2);
  494. if (SUCCEEDED(hr))
  495. {
  496. LPUNKNOWN pUnk=NULL;
  497. if (SUCCEEDED(pShellFolder2->QueryInterface(IID_IUnknown,(LPVOID*)&pUnk)))
  498. {
  499. m_ShellDetails.SetShellDetails(pUnk);
  500. pUnk->Release();
  501. }
  502. m_ShellDetails.SetShellDetails((LPUNKNOWN)pShellFolder2);
  503. pShellFolder2->Release();
  504. }
  505. else
  506. {
  507. IShellDetails *pShellDetails=NULL;
  508. HRESULT hr = m_psfSubFolder->CreateViewObject(GetSafeHwnd(), IID_IShellDetails, (LPVOID*)&pShellDetails);
  509. if (SUCCEEDED(hr))
  510. {
  511. LPUNKNOWN pUnk=NULL;
  512. if (SUCCEEDED(pShellDetails->QueryInterface(IID_IUnknown,(LPVOID*)&pUnk)))
  513. {
  514. m_ShellDetails.SetShellDetails(pUnk);
  515. pUnk->Release();
  516. }
  517. pShellDetails->Release();
  518. }
  519. }
  520. InitColumns();
  522. DWORD dwExStyle = GetExStyle(); 
  523. if(!m_ShellSettings.DoubleClickInWebView()) 
  524. {
  525. dwExStyle |= LVS_EX_ONECLICKACTIVATE | LVS_EX_TRACKSELECT | LVS_EX_UNDERLINEHOT; 
  526. }
  527. else
  528. {
  529. dwExStyle &= ~LVS_EX_ONECLICKACTIVATE;
  530. dwExStyle &= ~LVS_EX_TRACKSELECT;
  531. dwExStyle &= ~LVS_EX_UNDERLINEHOT; 
  532. }
  533. SetExStyle(dwExStyle);
  535.     LPITEMIDLIST lpi=NULL;
  536.     LPENUMIDLIST lpe=NULL;
  537.     LPLVITEMDATA lplvid=NULL;
  538. LPSHELLFOLDER lpsf=m_psfSubFolder;
  539.     ULONG        ulFetched, ulAttrs;
  540.     HWND         hwnd=::GetParent(m_hWnd);
  541. DWORD dwFlags = SHCONTF_FOLDERS | SHCONTF_NONFOLDERS;//add SHCONTF_FOLDERS flags by 阳光灿烂
  542.                                                      //use this can see folder.
  544. if (GetShellSettings().ShowAllObjects() && !GetShellSettings().ShowSysFiles())
  545. dwFlags |= SHCONTF_INCLUDEHIDDEN;
  546.     hr=lpsf->EnumObjects(hwnd,dwFlags, &lpe);
  548.     if (FAILED(hr))
  549. return FALSE;
  551. bool bEndPopulate=false;
  552. if (m_bPopulateInit == false)
  553. {
  554. StartPopulate();
  555. bEndPopulate = true;
  556. }
  557.     while (NO_ERROR==lpe->Next(1, &lpi, &ulFetched))
  558.     {
  559. ulAttrs = SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_DISPLAYATTRMASK | SFGAO_CONTENTSMASK | SFGAO_REMOVABLE; 
  560.         lpsf->GetAttributesOf(1, (LPCITEMIDLIST*)&lpi, &ulAttrs);
  561. if (!FilterItem(lpsf,lpi,ulAttrs))
  562. {
  563.         m_pMalloc->Free(lpi);  // free PIDL the shell gave you
  564.     lpi=NULL;
  565. continue;
  566. }
  567.         lplvid = (LPLVITEMDATA)m_pMalloc->Alloc(sizeof(LVITEMDATA));
  568.         if (!lplvid)
  569.            break;
  570. ZeroMemory(lplvid,sizeof(LVITEMDATA));
  571. m_vecItemData.push_back(lplvid);
  573.         lplvid->ulAttribs=ulAttrs;
  575.         lplvid->lpifq=m_ShellPidl.ConcatPidl(lptvid->lpifq, lpi);
  577.         lplvid->lpsfParent=lpsf;
  578.         lplvid->lpsfParent->AddRef();
  580.         // Now make a copy of the ITEMIDLIST.
  581.         lplvid->lpi=m_ShellPidl.CopyItemID(lpi);
  582. // // Now set the color of this file.
  583. //   lplvid->rgbColor = 
  584. // Add the item to the list view control.   
  585. int nRow=-1;
  586. if (bCallBack)
  587. {
  588. nRow = AddCallBackItem((DWORD)lplvid,I_IMAGECALLBACK);
  589. if ((ulAttrs & SFGAO_COMPRESSED) && m_ShellSettings.ShowCompColor())
  590. SetTextColor(nRow,0,RGB(0,0,255));
  591. else
  592. SetDefaultTextColor(nRow,-1);
  593. }
  594. else
  595. {
  596. nRow = AddTextItem();
  597. if (nRow != -1)
  598. {
  599. TCHAR szText[MAX_PATH+1];
  600. SetItemData(nRow,(DWORD)lplvid);
  601. LV_DISPINFO dsp;
  602. ZeroMemory(&dsp,sizeof(LV_DISPINFO));
  603. dsp.item.mask |= (LVIF_TEXT | LVIF_IMAGE);
  604. for(int i=0; i < GetColumnCount();i++)
  605. {
  606. szText[0] = 0;
  607. dsp.item.iItem = nRow;
  608. dsp.item.iSubItem = i;
  609. dsp.item.cchTextMax = MAX_PATH;
  610. dsp.item.pszText = szText;
  611. if (i > 0)
  612. dsp.item.mask &= ~LVIF_IMAGE;
  613. m_bCallBack = true;
  614. GetDispInfo(&dsp);
  615. m_bCallBack = false;
  616. SetIcon(nRow,dsp.item.iImage);
  617. AddString(nRow,i,szText);
  618. }
  619. }
  620. }
  621.         m_pMalloc->Free(lpi);  // free PIDL the shell gave you
  622.         lpi=NULL;
  623.     }
  625.     if (lpe)  
  626.         lpe->Release();
  628.     // The following two if statements will be TRUE only if you got here
  629.     // on an error condition from the goto statement.  Otherwise, free 
  630.     // this memory at the end of the while loop above.
  631.     if (lpi)           
  632.         m_pMalloc->Free(lpi);
  633.  
  634. if (bEndPopulate)
  635. EndPopulate();
  636.     return TRUE;
  637. }
  639. bool CIEShellListCtrl::FilterItem(LPSHELLFOLDER pFolder,LPCITEMIDLIST pidl,UINT ulAttrs)
  640. {
  641. if ((m_sFileFilter.IsEmpty() || m_sFileFilter == _T("*.*") || m_sFileFilter == _T("*"))
  642. && m_ExcludedLookup.IsEmpty())
  643. return true;
  644. bool bRet=false;
  645. if (m_sFileFilter == _T("*.*") || m_sFileFilter == _T("*"))
  646. {
  647. bRet=true;
  648. }
  649. else if (!m_sFileFilter.IsEmpty())
  650. {
  651. CString sPath;
  652. GetShellPidl().SHPidlToPathEx(pidl,sPath,pFolder);
  653. if (m_FilterLookup.Find(sPath))
  654. bRet = true;
  655. }
  656. if (bRet == false)
  657. return bRet;
  658. if (!m_ExcludedLookup.IsEmpty())
  659. {
  660. SHFILEINFO fileInfo;
  661. ZeroMemory(&fileInfo,sizeof(fileInfo));
  662. SHGetFileInfo((LPCTSTR)pidl, NULL, &fileInfo, sizeof(fileInfo), SHGFI_PIDL|SHGFI_TYPENAME);
  663. if (m_ExcludedLookup.Find(fileInfo.szTypeName))
  664. {
  665. bRet = false;
  666. }
  667. }
  668. return bRet;
  669. }
  671. void CIEShellListCtrl::InitShellSettings()
  672. {
  673. m_ShellSettings.GetSettings();
  674. }  
  676. BOOL CIEShellListCtrl::InitImageLists()
  677. {
  678.     HIMAGELIST himlSmall;
  679.     HIMAGELIST himlLarge;
  680.     SHFILEINFO sfi;
  681.     BOOL       bSuccess=TRUE;
  683.     himlSmall = (HIMAGELIST)SHGetFileInfo((LPCTSTR)_T("C:\"), 
  684.                                            0,
  685.                                            &sfi, 
  686.                                            sizeof(SHFILEINFO), 
  687.                                            SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  689.     himlLarge = (HIMAGELIST)SHGetFileInfo((LPCTSTR)_T("C:\"), 
  690.                                            0,
  691.                                            &sfi, 
  692.                                            sizeof(SHFILEINFO), 
  693.                                            SHGFI_SYSICONINDEX | SHGFI_LARGEICON);
  695.     if (himlSmall && himlLarge)
  696.     {
  697.         ::SendMessage(GetSafeHwnd(), LVM_SETIMAGELIST, (WPARAM)LVSIL_SMALL,
  698.             (LPARAM)himlSmall);
  699.         ::SendMessage(GetSafeHwnd(), LVM_SETIMAGELIST, (WPARAM)LVSIL_NORMAL,
  700.             (LPARAM)himlLarge);
  701.     }
  702.     else
  703.        bSuccess = FALSE;
  705.     return bSuccess;
  706. }
  708. BEGIN_MESSAGE_MAP(CIEShellListCtrl, CUIODListCtrl)
  709. //{{AFX_MSG_MAP(CIEShellListCtrl)
  710. ON_MESSAGE(WM_SETMESSAGESTRING,OnSetmessagestring)
  711. ON_MESSAGE(WM_SETTINGCHANGE,OnSettingChange)
  712. // NOTE - the ClassWizard will add and remove mapping macros here.
  713. ON_WM_DESTROY()
  714. ON_WM_MENUSELECT()
  715. //}}AFX_MSG_MAP
  716. ON_MESSAGE(WM_APP_ON_DELETE_KEY,OnAppDeleteKey)
  717. ON_MESSAGE(WM_APP_ON_PROPERTIES_KEY,OnAppPropertiesKey)
  718. ON_MESSAGE(WM_APP_UPDATE_ALL_VIEWS,OnAppUpdateAllViews)
  719. ON_MESSAGE(WM_APP_FILE_CHANGE_NEW_PATH,OnAppFileChangeNewPath)
  720. ON_MESSAGE(WM_APP_FILE_CHANGE_EVENT,OnAppFileChangeEvent)
  721. END_MESSAGE_MAP()
  723. /////////////////////////////////////////////////////////////////////////////
  724. // CIEShellListCtrl message handlers
  725. void CIEShellListCtrl::OnMenuSelect(UINT nItemID, UINT nFlags, HMENU hSysMenu)
  726. {
  727. CUIODListCtrl::OnMenuSelect(nItemID,nFlags,hSysMenu);
  728. }
  730. void CIEShellListCtrl::ShowPopupMenu(int nRow,int nCol,CPoint point)
  731. {
  732. if ((nCol > 0 || nRow == -1) || (m_PopupID || m_MultiPopupID))
  733. {
  734. CUIODListCtrl::ShowPopupMenu(nRow,nCol,point);
  735. return;
  736. }
  737. PopupTheMenu(nRow,point);
  738. }
  740. void CIEShellListCtrl::OnDestroy()
  741. {
  742. SetImageList(NULL,LVSIL_SMALL);
  743. SetImageList(NULL,LVSIL_NORMAL);
  744. DestroyThreads();
  745. CUIODListCtrl::OnDestroy();
  746. }
  748. bool CIEShellListCtrl::UseShellColumns()
  749. {
  750. return m_ShellDetails.IsValidDetails();
  751. }
  753. BOOL CIEShellListCtrl::GetDispInfo(LV_DISPINFO *pDispInfo)
  754. {
  755. // TODO: Add your specialized code here and/or call the base class
  756. if (m_psfSubFolder == NULL || m_bCallBack == false)
  757. return CUIODListCtrl::GetDispInfo(pDispInfo);
  758. LPLVITEMDATA lplvid = (LPLVITEMDATA)GetItemData(pDispInfo->item.iItem);
  759. ASSERT(lplvid);
  760. if (lplvid == NULL)
  761. return FALSE;
  762. PSLC_COLUMN_DATA pColData=(PSLC_COLUMN_DATA)lplvid->lParam;
  763. if (pColData == NULL)
  764. {
  765. pColData = new SLC_COLUMN_DATA;
  766. pColData->sItems.SetSize(GetColumnCount());
  767. lplvid->lParam = (LPARAM)pColData;
  768. }
  769. if (pColData->pidl == NULL)
  770. pColData->pidl = m_ShellPidl.ConcatPidl(m_tvid.lpifq, lplvid->lpi);
  771. if (pDispInfo->item.mask & LVIF_IMAGE)
  772. {
  773. if (pColData->iImage == -1)
  774. {
  775. pColData->iImage = m_ShellPidl.GetIcon(pColData->pidl,SHGFI_PIDL | SHGFI_SYSICONINDEX | SHGFI_SMALLICON);
  776. }
  777. pDispInfo->item.iImage = pColData->iImage;
  778. if (lplvid->ulAttribs & SFGAO_GHOSTED)
  779. {
  780. pDispInfo->item.mask |= LVIF_STATE;
  781. pDispInfo->item.stateMask = LVIS_CUT;
  782. pDispInfo->item.state = LVIS_CUT;
  783. }
  784. if (lplvid->ulAttribs & SFGAO_LINK)
  785. {
  786. pDispInfo->item.mask |= LVIF_STATE;
  787. pDispInfo->item.stateMask = LVIS_OVERLAYMASK;
  788. pDispInfo->item.state = INDEXTOOVERLAYMASK(2);
  789. }
  790. if (lplvid->ulAttribs & SFGAO_SHARE)
  791. {
  792. pDispInfo->item.mask |= LVIF_STATE;
  793. pDispInfo->item.stateMask = LVIS_OVERLAYMASK;
  794. pDispInfo->item.state = INDEXTOOVERLAYMASK(1);
  795. }
  796. }
  797. if (pDispInfo->item.mask & LVIF_TEXT)
  798. {
  799. if (UseShellColumns())
  800. {
  801. if (pDispInfo->item.iSubItem == COL_NAME)
  802. {
  803. if (pColData->sItems[pDispInfo->item.iSubItem].IsEmpty())
  804. m_ShellPidl.GetName(lplvid->lpsfParent, lplvid->lpi, SHGDN_NORMAL, pColData->sItems[pDispInfo->item.iSubItem]);
  805. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  806. if (m_bNoExt)
  807. RemoveExt(pDispInfo->item.pszText);
  808. }
  809. else
  810. {
  811. if (pColData->sItems[pDispInfo->item.iSubItem].IsEmpty())
  812. {
  813. SHELLDETAILS sd;
  814. ZeroMemory(&sd,sizeof(sd));
  815. HRESULT hr = m_ShellDetails.GetDetailsOf(lplvid->lpi,pDispInfo->item.iSubItem,&sd);
  816. LPTSTR pszText=NULL;
  817. GetShellPidl().StrRetToStr(sd.str,&pszText,lplvid->lpi);
  818. if (pszText)
  819. {
  820. _tcscpy(pDispInfo->item.pszText,pszText);
  821. GetShellPidl().Free(pszText);
  822. }
  823. }
  824. else
  825. {
  826. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  827. }
  828. }
  829. }
  830. else
  831. {
  832. GetText(pColData,pDispInfo,lplvid);
  833. }
  834. }
  835. return TRUE;
  836. }
  838. bool CIEShellListCtrl::GetColText(int nCol,LPCITEMIDLIST pidlAbs,LPLVITEMDATA lplvid,CString &sText)
  839. {
  840. return false;
  841. }
  843. void CIEShellListCtrl::GetText(PSLC_COLUMN_DATA pColData,LV_DISPINFO *pDispInfo,LPLVITEMDATA lplvid)
  844. {
  845. if (!pColData->sItems[pDispInfo->item.iSubItem].IsEmpty())
  846. {
  847. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  848. return;
  849. }
  850. LPITEMIDLIST pidlAbs = pColData->pidl;
  851. CString sText;
  852. if (GetColText(pDispInfo->item.iSubItem,pidlAbs,lplvid,sText))
  853. {
  854. pColData->sItems[pDispInfo->item.iSubItem] = sText;
  855. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  856. return;
  857. }
  858. if (pDispInfo->item.iSubItem == COL_NAME)
  859. {
  860. if (pColData->sItems[pDispInfo->item.iSubItem].IsEmpty())
  861. m_ShellPidl.GetName(lplvid->lpsfParent, lplvid->lpi, SHGDN_NORMAL,pColData->sItems[pDispInfo->item.iSubItem]);
  862. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  863. if (m_bNoExt)
  864. RemoveExt(pDispInfo->item.pszText);
  865. }
  866. else if (pDispInfo->item.iSubItem == COL_TYPE)
  867. {
  868. if (pColData->sItems[pDispInfo->item.iSubItem].IsEmpty())
  869. {
  870. SHFILEINFO fileInfo;
  871. if (SHGetFileInfo((LPCTSTR)lplvid->lpi, NULL, &fileInfo, sizeof(fileInfo), SHGFI_PIDL|SHGFI_TYPENAME))
  872. {
  873. pColData->sItems[pDispInfo->item.iSubItem] = fileInfo.szTypeName;
  874. }
  875. }
  876. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  877. }
  878. else if (pDispInfo->item.iSubItem == COL_SIZE || pDispInfo->item.iSubItem == COL_MODIFIED)
  879. {
  880. if (pColData->sItems[COL_SIZE].IsEmpty() || (pColData->sItems[COL_MODIFIED].IsEmpty()))
  881. {
  882. CString sSize;
  883. CString sDateTime;
  884. GetFileDetails(pidlAbs,sSize,sDateTime);
  885. if (pDispInfo->item.iSubItem == COL_SIZE)
  886. pColData->sItems[pDispInfo->item.iSubItem] = sSize;
  887. else if (pDispInfo->item.iSubItem == COL_MODIFIED)
  888. pColData->sItems[pDispInfo->item.iSubItem] = sDateTime;
  889. }
  890. if (pDispInfo->item.iSubItem == COL_SIZE)
  891. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  892. else if (pDispInfo->item.iSubItem == COL_MODIFIED)
  893. _tcscpy(pDispInfo->item.pszText,pColData->sItems[pDispInfo->item.iSubItem]);
  894. }
  895. }
  897. void CIEShellListCtrl::GetFileDetails(LPCITEMIDLIST pidl, CString &sSize, CString &sDateTime)
  898. {
  899. CString sPath;
  900. GetShellPidl().SHPidlToPathEx((LPITEMIDLIST)pidl,sPath,NULL);
  901. if (sPath.GetLength() <= 3)
  902. return;
  903. WIN32_FIND_DATA FindFileData;
  904.     HANDLE hFind = FindFirstFile(sPath,&FindFileData);
  905.     if (hFind != INVALID_HANDLE_VALUE)
  906. {
  907. if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
  908. {
  909. unsigned __int64 fs = UMAKEINT64(FindFileData.nFileSizeLow, FindFileData.nFileSizeHigh);
  910. unsigned __int64 kb=1;
  911. TCHAR szText[1024];
  912. if (fs > 1024)
  913. {
  914. kb = fs / 1024;
  915. if (fs % 1024)
  916. kb++;
  917. }
  918. _ui64tot(kb,szText,10);
  919. sSize = szText;
  920. AddThousandSeps(sSize);
  921. sSize += _T(" KB");
  922. }
  923. if ((FindFileData.ftLastWriteTime.dwLowDateTime != 0) || (FindFileData.ftLastWriteTime.dwHighDateTime != 0))
  924. {
  925. sDateTime = CLocaleInfo::Instance()->FormatDateTime(FindFileData.ftLastWriteTime);
  926. }
  927. else
  928. {
  929. sDateTime = CLocaleInfo::Instance()->FormatDateTime(FindFileData.ftCreationTime);
  930. }
  931.     FindClose(hFind);
  932. }
  933. }
  935. void CIEShellListCtrl::RemoveExt(LPTSTR pszFileName)
  936. {
  937. if (pszFileName == NULL)
  938. return;
  939. LPTSTR pExtPos=NULL;
  940. LPTSTR pEndPos = pszFileName+lstrlen(pszFileName);
  941. LPTSTR pStartPos = pszFileName;
  942. while (pEndPos > pStartPos)
  943. {
  944. if (*pEndPos == '.')
  945. {
  946. pExtPos = pEndPos;
  947. break;
  948. }
  949. pEndPos = _tcsdec(pStartPos,pEndPos);
  950. }
  951. if (pExtPos)
  952. *pExtPos = '';
  953. }
  955. int CALLBACK ShellCompareFunc(LPARAM lparam1, 
  956.                                  LPARAM lparam2,
  957.                                  LPARAM lparamSort);
  959. PFNLVCOMPARE CIEShellListCtrl::GetCompareFunc()
  960. {
  961. if (m_bCallBack)
  962. return ShellCompareFunc;
  963. return CUIODListCtrl::GetCompareFunc();
  964. }
  966. int CALLBACK ShellCompareFunc(LPARAM lParam1, 
  967.                          LPARAM lParam2,
  968.                          LPARAM lParamSort)
  969. {
  970. CUIListCtrlData *pData1 = (CUIListCtrlData*)lParam1;
  971. CUIListCtrlData *pData2 = (CUIListCtrlData*)lParam2;
  972.     LPLVITEMDATA lplvid1=(LPLVITEMDATA)pData1->GetExtData();
  973.     LPLVITEMDATA lplvid2=(LPLVITEMDATA)pData2->GetExtData();
  974. CUIODListCtrlSortInfo *pSortInfo = (CUIODListCtrlSortInfo*)lParamSort;
  975. int nRet=0;
  976. HRESULT hr = lplvid1->lpsfParent->CompareIDs(pSortInfo->GetColumn(),lplvid1->lpi,lplvid2->lpi);
  977.     if (SUCCEEDED(hr))
  978. nRet = (short)hr;
  979. if (!pSortInfo->Ascending())
  980. nRet = -nRet;
  981. return nRet;
  982. }
  984. /////////////////////////////////////////////////////////////////////////
  985. // Thread function for detecting file system changes
  986. UINT CIEShellListCtrl::ThreadFunc (LPVOID pParam)
  987. {
  988. ///////////////////////
  989.     PFC_THREADINFO pThreadInfo = (PFC_THREADINFO)pParam;
  990.     HANDLE hEvent = pThreadInfo->hEvent;
  991.     HANDLE hMonitorEvent = pThreadInfo->hMonitorEvent;
  992. CIEShellListCtrl *pListCtrl = pThreadInfo->pListCtrl;
  993.     HWND hWnd = pListCtrl->GetSafeHwnd();
  994.     delete pThreadInfo;
  995. ////////////////////////
  996. TCHAR szPath[MAX_PATH];
  997.     int nHandles=2;
  998. int nRet=0;
  999. HANDLE hFileChange=NULL;
  1000.     HANDLE aHandles[3];
  1001. aHandles[0] = hMonitorEvent;
  1002.     aHandles[1] = hEvent;
  1003. aHandles[2] = NULL;
  1004.     BOOL bContinue = TRUE;
  1005.     // Sleep until a file change notification wakes this thread or
  1006.     // m_event becomes set indicating it's time for the thread to end.
  1007.     while (bContinue)
  1008. {
  1009. TRACE(_T("ListControl waiting for %u multiple objectsn"),nHandles);
  1010.         DWORD dw = ::WaitForMultipleObjects (nHandles, aHandles, FALSE, INFINITE);
  1011. if (dw >= WAIT_ABANDONED && dw <= (WAIT_ABANDONED+(nHandles-1)))
  1012. {
  1013. TRACE(_T("ListControl waiting abandonedn"),nHandles);
  1014. break;
  1015. }
  1016. // Reset Event
  1017.         if(dw - WAIT_OBJECT_0 == 0) 
  1018. {
  1019. if (hFileChange && hFileChange != INVALID_HANDLE_VALUE)
  1020. ::FindCloseChangeNotification(hFileChange);
  1021. if (::SendMessage(hWnd, WM_APP_FILE_CHANGE_NEW_PATH, (WPARAM)szPath, 0))
  1022. {
  1023. if (szPath[0] == 0)
  1024. {
  1025. TRACE(_T("File notify path was returned emptyn"));
  1026. hFileChange = NULL;
  1027. aHandles[2] = hFileChange;
  1028. continue;
  1029. }
  1030. TRACE(_T("File notify path returned %sn"),szPath);
  1031.     hFileChange = ::FindFirstChangeNotification (szPath, FALSE, FILE_NOTIFY_CHANGE_FILE_NAME | FILE_NOTIFY_CHANGE_LAST_WRITE | FILE_NOTIFY_CHANGE_SIZE);
  1032.     if (hFileChange == INVALID_HANDLE_VALUE)
  1033. {
  1034. TRACE(_T("File notify thread was unable to create notification objectn"));
  1035. hFileChange = NULL;
  1036. aHandles[2] = hFileChange;
  1037. continue;
  1038. }
  1039. else
  1040. {
  1041. if (nHandles == 2)
  1042. {
  1043. TRACE(_T("File notify thread has created the notification object for the first timen"));
  1044. nHandles++;
  1045. }
  1046. TRACE(_T("File notify thread has created the notification objectn"));
  1047. aHandles[2] = hFileChange;
  1048. }
  1049. }
  1050. }
  1051. // End Event
  1052.         else if(dw - WAIT_OBJECT_0 == 1) 
  1053. {
  1054.             bContinue = FALSE;
  1055. TRACE(_T("File Notify Thread was signalled to stopn"));
  1056. }
  1057. // File Change Event
  1058.         else if (dw - WAIT_OBJECT_0 == 2) 
  1059. { // Respond to a change notification.
  1060.             ::FindNextChangeNotification (hFileChange);
  1061. TRACE(_T("-- File notify event was fired in CIEShellListCtrl --n"));
  1062. if (pListCtrl->RefreshAllowed())
  1063. {
  1064. ::PostMessage (hWnd, WM_APP_FILE_CHANGE_EVENT,0,0);
  1065. }
  1066. else
  1067. {
  1068. TRACE(_T("but not sending as refreshingn"));
  1069. pListCtrl->SetRefreshAllowed(true);
  1070. TRACE(_T("Refresh is now allowedn"));
  1071. }
  1072.         }
  1073.     }
  1074. if (hFileChange && hFileChange != INVALID_HANDLE_VALUE)
  1075. ::FindCloseChangeNotification (hFileChange);
  1076. TRACE(_T("File Notify Thread is endingn"));
  1077.     return nRet;
  1078. }
  1080. LRESULT CIEShellListCtrl::OnAppFileChangeNewPath(WPARAM wParam, LPARAM lParam)
  1081. {
  1082. ASSERT(wParam);
  1083. SHGetPathFromIDList(m_tvid.lpifq,(LPTSTR)wParam);
  1084. return 1;
  1085. }
  1087. LRESULT CIEShellListCtrl::OnAppFileChangeEvent(WPARAM wParam, LPARAM lParam)
  1088. {
  1089. if (!RefreshAllowed())
  1090. return 1L;
  1091. Refresh();
  1092. if (m_bNotifyParent)
  1093. GetParent()->SendMessage(WM_APP_UPDATE_ALL_VIEWS,(WPARAM)HINT_SHELL_FILE_CHANGED,(LPARAM)(LPCTSTR)m_sMonitorPath);
  1094. return 1L;
  1095. }
  1097. void CIEShellListCtrl::PreSubclassWindow()
  1098. {
  1099. CUIODListCtrl::PreSubclassWindow();
  1100. CreateFileChangeThread(GetSafeHwnd());
  1101. }
  1103. void CIEShellListCtrl::CreateFileChangeThread(HWND hwnd)
  1104. {
  1105. if (m_nThreadCount >= MAX_THREADS)
  1106. return;
  1107.     PFC_THREADINFO pThreadInfo = new FC_THREADINFO; // Thread will delete
  1108.     pThreadInfo->hMonitorEvent = m_MonitorEvent[m_nThreadCount].m_hObject;
  1109.     pThreadInfo->hEvent = m_event[m_nThreadCount].m_hObject;
  1110.     pThreadInfo->pListCtrl = this;
  1112.     CWinThread* pThread = AfxBeginThread (ThreadFunc, pThreadInfo,
  1113.         THREAD_PRIORITY_IDLE);
  1115.     pThread->m_bAutoDelete = FALSE;
  1116.     m_hThreads[m_nThreadCount] = pThread->m_hThread;
  1117.     m_pThreads[m_nThreadCount++] = pThread;
  1118. }
  1120. bool CIEShellListCtrl::DragDrop(CDD_OleDropTargetInfo *pInfo)
  1121. {
  1122. // TODO: Add your specialized code here and/or call the base class
  1123. return m_ShellDragDrop.DragDrop(pInfo,m_tvid.lpsfParent,m_tvid.lpi);
  1124. }
  1126. bool CIEShellListCtrl::DragEnter(CDD_OleDropTargetInfo *pInfo)
  1127. {
  1128. // TODO: Add your specialized code here and/or call the base class
  1129. return m_ShellDragDrop.DragEnter(pInfo,m_tvid.lpsfParent,m_tvid.lpi);
  1130. }
  1132. bool CIEShellListCtrl::DragLeave(CDD_OleDropTargetInfo *pInfo)
  1133. {
  1134. // TODO: Add your specialized code here and/or call the base class
  1135. return m_ShellDragDrop.DragLeave(pInfo);
  1136. }
  1138. bool CIEShellListCtrl::DragOver(CDD_OleDropTargetInfo *pInfo)
  1139. {
  1140. // TODO: Add your specialized code here and/or call the base class
  1141. return m_ShellDragDrop.DragOver(pInfo,m_tvid.lpsfParent,m_tvid.lpi);
  1142. }
  1144. // When the use starts a drag drop source
  1145. DROPEFFECT CIEShellListCtrl::DoDragDrop(int *pnRows,COleDataSource *pOleDataSource)
  1146. {
  1147. CShellPidl pidl;
  1148. CCF_ShellIDList sl;
  1149. CCF_HDROP cf_hdrop;
  1150. CCF_String cf_text;
  1151. cf_hdrop.AddDropPoint(CPoint(),FALSE);
  1152. CString sPath;
  1153. CString sText;
  1154. LPLVITEMDATA plvid=NULL;
  1155. if (GetShellPidl().IsDesktopFolder(m_psfSubFolder))
  1156. sl.AddPidl(GetShellPidl().GetEmptyPidl());
  1157. else
  1158. sl.AddPidl(m_tvid.lpifq);
  1159. for(int i=0;*pnRows != -1;i++)
  1160. {
  1161. plvid = (LPLVITEMDATA)GetItemData(*pnRows);
  1162. ASSERT(plvid);
  1163. sl.AddPidl(plvid->lpi);
  1164. pidl.SHPidlToPathEx(plvid->lpi,sPath,plvid->lpsfParent);
  1165. cf_hdrop.AddFileName(sPath);
  1166. sText += sPath;
  1167. sText += _T("n");
  1168. pnRows++;
  1169. }
  1170. cf_text.SetString(sText);
  1171. if (i > 0)
  1172. {
  1173. CWDClipboardData::Instance()->SetData(pOleDataSource,&cf_text,CWDClipboardData::e_cfString);
  1174. CWDClipboardData::Instance()->SetData(pOleDataSource,&sl,CWDClipboardData::e_cfShellIDList);
  1175. CWDClipboardData::Instance()->SetData(pOleDataSource,&cf_hdrop,CWDClipboardData::e_cfHDROP);
  1176. }
  1177. return GetShellPidl().GetDragDropAttributes(plvid);
  1178. }
  1181. LRESULT CIEShellListCtrl::OnAppUpdateAllViews(WPARAM wParam, LPARAM lParam)
  1182. {
  1183. if (wParam == HINT_TREE_SEL_CHANGED)
  1184. {
  1185. ASSERT(lParam);
  1186. const CRefreshShellFolder *pRefresh = reinterpret_cast<CRefreshShellFolder*>(lParam);
  1187. if (pRefresh)
  1188. {
  1189. LPTVITEMDATA lptvid = reinterpret_cast<LPTVITEMDATA>(pRefresh->GetItemData());
  1190. ASSERT(lptvid);
  1191. if (lptvid == NULL)
  1192. return 1L;
  1193. bool bInternet=GetShellPidl().ComparePidls(NULL,lptvid->lpifq,m_pidlInternet);
  1194. if (GetParent())
  1195. GetParent()->SendMessage(WM_APP_UPDATE_ALL_VIEWS,HINT_TREE_INTERNET_FOLDER_SELECTED,(LPARAM)(bInternet ? 1 : 0));
  1196. if (bInternet == false)
  1197. Populate(lptvid);
  1198. }
  1199. }
  1200. return 1L;
  1201. }
  1203. LRESULT CIEShellListCtrl::OnSettingChange(WPARAM wParam,LPARAM lParam)
  1204. { 
  1205. InitShellSettings();
  1206. Refresh();
  1207. LPCTSTR lpszSection=(LPCTSTR)lParam;
  1208. TRACE1("OnSettingsChange in CIEShellListCtrl with %sn",lpszSection ? lpszSection : _T("null"));
  1209. return 1L; 
  1210. }  
  1212. BOOL CIEShellListCtrl::DoubleClick(NM_LISTVIEW* pNMListView)
  1213. {
  1214. //修改此函数以便双击目录时可以直接在listctrl中打开，并实现与TreeCtrl的互动。  阳光灿烂
  1216. /* if (m_ShellSettings.DoubleClickInWebView())
  1217. {
  1218. ShellExecute(pNMListView->iItem);
  1219. return TRUE;
  1220. }
  1221. */
  1222. //是否无效点击
  1223. if ( pNMListView->iItem < 0 || pNMListView->iItem > GetItemCount() )
  1224. return TRUE;
  1226. //取对应的路径
  1227. CString szPath = GetPathName( pNMListView->iItem );
  1228. //取对应的pidl
  1229. LPITEMIDLIST pidlSel = (LPITEMIDLIST) GetPathPidl( pNMListView->iItem );
  1231. //判断是否为目录
  1232. DWORD dwResult;
  1233. dwResult = GetFileAttributes( szPath );
  1234. dwResult &= FILE_ATTRIBUTE_DIRECTORY;
  1235. if ( dwResult ) //is dir
  1236. {
  1237. Populate( szPath , true );
  1238. //打开对应的TreeCtrl
  1239. UINT mess = WM_APP_CB_IE_HIT_ENTER;
  1240. if (m_hTreeWnd)
  1241. ::SendMessage(m_hTreeWnd,mess,(WPARAM)pidlSel,(LPARAM)(LPCTSTR)szPath);
  1242. }
  1243. else
  1244. ShellExecute( pNMListView->iItem );
  1246. return TRUE;
  1247. }
  1249. BOOL CIEShellListCtrl::OnEnter(NM_LISTVIEW* pNMListView)
  1250. {
  1251. // TODO: Add your specialized code here and/or call the base class
  1252. ShellExecute(pNMListView->iItem);
  1253. return TRUE;
  1254. }
  1256. LRESULT CIEShellListCtrl::OnAppDeleteKey(WPARAM wParam, LPARAM lParam)
  1257. {
  1258. // TODO: Add your specialized code here and/or call the base class
  1259. UINT nSize = GetSelectedCount()*MAX_PATH;
  1260. if (nSize == 0)
  1261. return 0L;
  1262. SetRefreshAllowed(false);
  1263. SHFILEOPSTRUCT shf;
  1264. ZeroMemory(&shf,sizeof(shf));
  1265. LPTSTR pszFrom=new TCHAR[nSize];
  1266. LPTSTR pszStartFrom=pszFrom;
  1267. ZeroMemory(pszFrom,nSize*sizeof(TCHAR));
  1268. CString sPath;
  1269. int item=-1;
  1270. while ((item = GetNextSel(item)) != -1)
  1271. {
  1272. sPath = GetPathName(item);
  1273. lstrcpy(pszFrom,(LPCTSTR)sPath);
  1274. pszFrom += sPath.GetLength()+1;
  1275. }
  1276. shf.hwnd = GetSafeHwnd();
  1277. shf.wFunc = FO_DELETE;
  1278. shf.pFrom = (LPCTSTR)pszStartFrom;
  1279. shf.fFlags = GetKeyState(VK_SHIFT) < 0 ? 0 : FOF_ALLOWUNDO;
  1280. if (SHFileOperation(&shf) != 0)
  1281. SetRefreshAllowed(true);
  1282. delete []pszStartFrom;
  1283. return 1L;
  1284. }
  1286. LRESULT CIEShellListCtrl::OnAppPropertiesKey(WPARAM wParam, LPARAM lParam)
  1287. {
  1288. // TODO: Add your specialized code here and/or call the base class
  1289. if (GetSelectedCount() == 0)
  1290. return 0L;
  1291. SHELLEXECUTEINFO si;
  1292. ZeroMemory(&si,sizeof(si));
  1293. si.cbSize = sizeof(si);
  1294. si.hwnd = GetSafeHwnd();
  1295. si.nShow = SW_SHOW;
  1296. si.fMask  = SEE_MASK_INVOKEIDLIST;
  1297. si.lpVerb = _T("properties");
  1298. int item=GetCurSel();
  1299. while ((item = GetNextSel(item)) != -1)
  1300. {
  1301. CString sPath(GetPathName(item));
  1302. si.lpFile = (LPCTSTR)sPath;
  1303. ShellExecuteEx(&si);
  1304. }
  1305. return 1L;
  1306. }
  1308. bool CIEShellListCtrl::EndLabelEdit(int nRow,int nCol,LPCTSTR pszText)
  1309. {
  1310. // TODO: Add your specialized code here and/or call the base class
  1311. if (nCol != 0)
  1312. return CUIODListCtrl::EndLabelEdit(nRow,nCol,pszText);
  1313. CString sFromPath(GetPathName(nRow));
  1314. CString sToPath;
  1315. CSplitPath path(sFromPath);
  1316. if (GetShellSettings().ShowExtensions())
  1317. {
  1318. CSplitPath file(pszText);
  1319. path.SetFileName(file.GetFileName());
  1320. path.SetExt(file.GetExt());
  1321. }
  1322. else
  1323. {
  1324. path.SetFileName(pszText);
  1325. }
  1326. path.Make();
  1327. sToPath = path.GetPath();
  1328. SHFILEOPSTRUCT shf;
  1329. TCHAR szFrom[MAX_PATH+1];
  1330. TCHAR szTo[MAX_PATH+1];
  1331. ZeroMemory(szFrom,sizeof(szFrom));
  1332. lstrcpy(szFrom,sFromPath);
  1333. ZeroMemory(szTo,sizeof(szTo));
  1334. lstrcpy(szTo,sToPath);
  1335. ZeroMemory(&shf,sizeof(shf));
  1336. shf.hwnd = GetSafeHwnd();
  1337. shf.wFunc = FO_RENAME;
  1338. shf.pFrom = szFrom;
  1339. shf.pTo = szTo;
  1340. #ifdef _DEBUG
  1341. CString sMess;
  1342. sMess = szFrom;
  1343. sMess += _T("n");
  1344. sMess += szTo;
  1345. AfxMessageBox(sMess);
  1346. #endif
  1347. int nRet = SHFileOperation(&shf);
  1348. TRACE1("SHFileOperation returned %un",nRet);
  1349. return false;
  1350. }
  1352. void CIEShellListCtrl::GoBack(int nRow)
  1353. {
  1354. // TODO: Add your specialized code here and/or call the base class
  1355. AfxMessageBox(_T("Needs to be implemented"));
  1356. }
  1358. void CIEShellListCtrl::ChangeStyle(UINT &dwStyle)
  1359. {
  1360. // TODO: Add your specialized code here and/or call the base class
  1361. CUIODListCtrl::ChangeStyle(dwStyle);
  1363. dwStyle |= (LVS_SHAREIMAGELISTS | LVS_EDITLABELS);  
  1364. }
  1366. LRESULT CIEShellListCtrl::OnSetmessagestring(WPARAM wParam, LPARAM lParam)
  1367. {
  1368. if (GetParent())
  1369. return GetParent()->SendMessage(WM_SETMESSAGESTRING,wParam,lParam);
  1370. return 0;
  1371. }
  1373. void CIEShellListCtrl::SetTreeCtrlWnd(HWND hWnd)
  1374. {
  1375. m_hTreeWnd = hWnd;
  1376. }
  1378. void CIEShellListCtrl::SelChanged(int nItem, LRESULT *pResult)
  1379. {
  1380. CIRWEngine *pIRWEngine = ISeeGetIRWEngine();
  1381. CReturnReceipt *pRReceipt = NULL;
  1382. CString szPath = GetPathName( nItem );
  1384. LPLVITEMDATA pItemData = (LPLVITEMDATA)GetItemData( nItem );
  1385. if ( pItemData->iFlag == 2 )
  1386. return; //此文件项不能被处理
  1387. pRReceipt = pItemData->pRReceipt;
  1388. if ( pRReceipt == NULL )
  1389. {
  1390. if ( szPath.IsEmpty() )
  1391. {
  1392. pItemData->iFlag = 2;
  1393. return ;  //
  1394. }
  1395. DWORD dwResult;
  1396. dwResult = GetFileAttributes( szPath );
  1397. dwResult &= FILE_ATTRIBUTE_DIRECTORY;
  1398. if ( dwResult ) //is dir
  1399. {
  1400. pItemData->iFlag = 2;
  1401. return ;
  1402. }
  1403. pRReceipt = pIRWEngine->IsValidImageFile( szPath , FALSE);
  1404. if (pRReceipt == NULL)
  1405. return ; // 内存不足
  1406. if (pRReceipt->GetImagePluginID() >= 0) // 该文件能被插件处理
  1407. {
  1408. pIRWEngine->GetImageFileInfo(pRReceipt);
  1409. while(pRReceipt->GetResult() == IRWERRT_ING); // 等待命令处理完毕
  1410. if (pRReceipt->GetResult() == IRWERRT_FAIL)
  1411. return; //处理失败
  1412. }
  1413. else
  1414. {
  1415. pItemData->iFlag = 2;
  1416. delete pRReceipt;
  1417. return;//不能处理
  1418. }
  1419. }
  1421. pIRWEngine->LoadImageFromFile( pRReceipt , TRUE );
  1423. pItemData->iFlag = 1;
  1424. pItemData->pRReceipt = pRReceipt;
  1425. pItemData->rgbColor = bkColor[ pRReceipt->GetImagePluginID() ];
  1427.   //因为引擎是异步执行的，所以LoadImageFromFile()不会立即成功，
  1428.   //是否读完可由工作场模块判断
  1429.   //if ( pRReceipt->GetResult() == IRWERRT_SUCCESS )
  1430.   /*if ( true )
  1431. {
  1432. pItemData->iFlag = 1;
  1433. pItemData->pRReceipt = pRReceipt;
  1434. pItemData->rgbColor = bkColor[ pRReceipt->GetImagePluginID() ];
  1435. }
  1436. else
  1437. {
  1438. delete pRReceipt;
  1439. return; //失败
  1440. }*/
  1442. UINT message = WM_APP_LIST_SELECTCHANGED;
  1443. GetParent()->SendMessage( message , (WPARAM)nItem , 0 );
  1444. *pResult = 0;
  1445. }
  1447. //此函数用来在系统空闲时进行图像的预读。
  1448. //m_iProcessed用来决定预读哪一幅图像， 当m_iProcessed的值大于当前目录中的图像个数时
  1449. //预读结束。
  1450. BOOL CIEShellListCtrl::OnIdle(LONG lCount)
  1451. {
  1452. CIRWEngine *pIRWEngine = ISeeGetIRWEngine();
  1453. CReturnReceipt *pRReceipt = NULL;
  1454. LPLVITEMDATA  pListData;
  1456. if (m_iProcessed < GetItemCount())
  1457. {
  1458. pListData = (LPLVITEMDATA)GetItemData( m_iProcessed );
  1459. CString szPath = GetPathName( m_iProcessed );
  1460. if ( pListData->iFlag > 0 )
  1461. {
  1462. m_iProcessed ++;
  1463. return true;
  1464. }
  1466. if ( szPath.IsEmpty() )  
  1467. {
  1468. pListData->iFlag = 2;
  1469. m_iProcessed++;
  1470. return true;
  1471. }
  1472. DWORD dwResult;
  1473. dwResult = GetFileAttributes( szPath );
  1474. dwResult &= FILE_ATTRIBUTE_DIRECTORY;
  1475. if ( dwResult ) //不处理目录
  1476. {
  1477. pListData->iFlag = 2;
  1478. m_iProcessed++;
  1479. return true;
  1480. }
  1481. pRReceipt = pIRWEngine->IsValidImageFile( szPath , FALSE);
  1482. if (pRReceipt == NULL)
  1483. return false ; // 内存不足
  1484. if (pRReceipt->GetImagePluginID() >= 0) // 该文件能被插件处理
  1485. {
  1486. pIRWEngine->GetImageFileInfo(pRReceipt);
  1487. while(pRReceipt->GetResult() == IRWERRT_ING); // 等待命令处理完毕
  1488. if (pRReceipt->GetResult() == IRWERRT_SUCCESS)
  1489. {
  1490. // 在选择被修改时读取图像的位数据，否则内存耗量太大
  1491. // pIRWEngine->LoadImageFromFile( pRReceipt );
  1492. // if ( pRReceipt->GetResult() == IRWERRT_SUCCESS )
  1493. // if ( true )
  1494. // {
  1495. pListData->iFlag = 1;
  1496. pListData->pRReceipt = pRReceipt;
  1497. pListData->rgbColor = bkColor[ pRReceipt->GetImagePluginID() ];
  1498. // }
  1499. // else
  1500. // delete pRReceipt; //读取数据不成功，删除回执单
  1501.           //当前可处理图像已读取完。
  1502. }
  1503. }
  1504. else 
  1505. {
  1506. pListData->iFlag = 2;
  1507. delete pRReceipt;
  1508. }
  1509. m_iProcessed ++;
  1510. }
  1511. else 
  1512. return false; //通知系统不必调用此函数了。
  1514. return true;
  1515. }
  1517. void * CIEShellListCtrl::GetIdleFuncAddr()
  1518. {
  1519. // BOOL (* pFuncAddr)(LONG);
  1520. // pFuncAddr = OnIdle;
  1521. // return ( (void *)pFuncAddr );
  1522. return NULL;
  1523. }