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

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

图形图象

开发平台：

Visual C++

ShellContextMenu.cpp：源码内容
  1. /***************************************************************************/
  2. /* NOTE:                                                                   */
  3. /* This document is copyright (c) by Oz Solomonovich.  All non-commercial  */
  4. /* use is allowed, as long as this document is not altered in any way, and */
  5. /* due credit is given.                                                    */
  6. /***************************************************************************/
  8. // ShellContextMenu.cpp : implementation file
  9. //
  10. // Handles the creation of the shell context menu, including the "Send To..."
  11. // sub-menu.  
  12. // Personal note: I think that MS should have made the code to populate and
  13. // handle the "Send To..." sub-menu a part of the shell context menu code.  
  14. // But they didn't, so now we're forced to write a whole lot of spaghetti COM 
  15. // code to do what should have been a trivial part of the OS.  See the code 
  16. // below and judge for yourself.
  17. //
  18. // ==========================================================================  
  19. // HISTORY:   
  20. // ==========================================================================
  21. //    1.01  7 Jul 2000 - Philip Oldaker [philip@masmex.com] - Fixed a problem
  22. //                with the SendTo menu now checking for menu id. 
  23. //                Added support for the new OpenWith menu. 
  24. //                The SendTo Menu is now sorted.
  27. #include "stdafx.h"
  28. #include "ShellContextMenu.h"
  29. #include "UICoolMenu.h"
  30. #include <atlbase.h>
  31. #include "PIDL.h"
  33. #ifdef _DEBUG
  34. #define new DEBUG_NEW
  35. #undef THIS_FILE
  36. static char THIS_FILE[] = __FILE__;
  37. #endif
  39. #define IDM_SHELLCTXFIRST      20000
  40. #define IDM_SHELLCTXLAST       29999
  42. #define IDM_SENDTOFIRST        30000
  43. #define IDM_SENDTOLAST         32000
  44. #define IDM_OPENWITHFIRST      32001
  45. #define IDM_OPENWITHLAST       32767
  46. #define IDM_SENDTOID           20028
  47. #define IDM_OPENWITHID1        20127
  48. #define IDM_OPENWITHID2        20128
  50. LPSHELLFOLDER is_less_than_pidl::psf;
  51. LPSHELLFOLDER is_greater_than_pidl::psf;
  53. // OpenWith menu registry keys
  54. static LPCTSTR szAppKey = _T("Applications");
  55. static LPCTSTR szOpenWithListKey = _T("OpenWithList");
  56. static LPCTSTR szShellKey = _T("shell");
  57. static LPCTSTR szCommandKey = _T("command");
  58. static LPCTSTR szFileExtKey = _T("Software\Microsoft\Windows\CurrentVersion\Explorer\FileExts");
  59. // OpenWith menu entries
  60. static LPCTSTR szMRUListEntry = _T("MRUList");
  61. static LPCTSTR szDisplayNameEntry = _T("FriendlyCache");
  63. static class CShCMInitializer
  64. {
  65. public:
  66.     CShCMInitializer();
  67.     ~CShCMInitializer();
  69.     static LPSHELLFOLDER   m_sfDesktop;
  70.     static LPSHELLFOLDER   m_sfSendTo;
  71.     static CImageList *    m_pShellImageList;
  72.     static CPIDL           m_pidlSendTo;
  73. } stat_data;
  75. LPSHELLFOLDER CShCMInitializer::m_sfDesktop       = NULL;
  76. LPSHELLFOLDER CShCMInitializer::m_sfSendTo        = NULL;
  77. CImageList *  CShCMInitializer::m_pShellImageList = NULL;
  78. CPIDL         CShCMInitializer::m_pidlSendTo;
  80. CShCMInitializer::CShCMInitializer()
  81. {
  82.     HRESULT     hr;
  83.     SHFILEINFO  sfi;
  85.     SHGetDesktopFolder(&m_sfDesktop);
  87.     hr = SHGetSpecialFolderLocation(NULL, CSIDL_SENDTO, m_pidlSendTo);
  88.     if (SUCCEEDED(hr)) 
  89.     {
  90.         hr = m_sfDesktop->BindToObject(m_pidlSendTo, NULL, IID_IShellFolder, 
  91.             (LPVOID *)&m_sfSendTo);
  92.         if (!SUCCEEDED(hr)) 
  93.         {
  94.             m_sfSendTo = NULL;
  95.         }
  96.     } 
  97.     else 
  98.     {
  99.         m_sfSendTo = NULL;
  100.     }
  102.     m_pShellImageList = CImageList::FromHandle((HIMAGELIST)
  103.         SHGetFileInfo((LPCTSTR)_T("C:\"), 0, &sfi, sizeof(SHFILEINFO), 
  104.         SHGFI_SYSICONINDEX | SHGFI_SMALLICON));
  105. }
  107. CShCMInitializer::~CShCMInitializer()
  108. {
  109.     m_sfSendTo->Release();
  110.     m_sfDesktop->Release();
  111. }
  115. CShellContextMenu::CShellContextMenu(HWND hWnd,const CString &sAbsPath, LPITEMIDLIST *ppidl, UINT cidl, LPSHELLFOLDER psfParent) 
  116. :   m_hWnd(hWnd), 
  117. m_sAbsPath(sAbsPath),
  118. m_psfParent(psfParent),
  119. m_ppidl(ppidl),
  120. m_cidl(cidl),
  121. m_pSendToMenu(NULL)
  122. {
  123.     m_lpcm = NULL;
  124. m_pidl = *ppidl;
  125. // Initialize button sizes
  126. m_szOldButtonSize = g_CoolMenuManager.SetButtonSize();
  127. }
  129. CShellContextMenu::~CShellContextMenu()
  130. {
  131.     if (m_lpcm) m_lpcm->Release();
  133.     if (m_pSendToMenu)
  134.     {
  135.         int     i = IDM_SENDTOFIRST;
  136.         void *  pData;
  138.         pData = CCoolMenuManager::GetItemData(*m_pSendToMenu, i);
  139.         while (pData)
  140.         {
  141.             CPIDL toFree((LPITEMIDLIST)pData);
  142.             pData = CCoolMenuManager::GetItemData(*m_pSendToMenu, ++i);
  143.         }
  144.         g_CoolMenuManager.UnconvertMenu(m_pSendToMenu);
  145.         m_pSendToMenu = NULL;
  146.     }
  147. // Clean up owner draw menus
  148. STL_FOR_ITERATOR(vecODMenu,m_OwnerDrawMenus)
  149. {
  150. g_CoolMenuManager.UnconvertMenu(STL_GET_CURRENT(m_OwnerDrawMenus));
  151. }
  152. STL_ERASE_ALL(m_OwnerDrawMenus);
  153. g_CoolMenuManager.SetButtonSize(m_szOldButtonSize);
  154. //////////////////////////////
  155. }
  157. /////////////////////////////
  158. // Addition: Philip Oldaker
  159. /////////////////////////////
  160. CString CShellContextMenu::GetExt(const CString &sPath) const
  161. {
  162. TCHAR szDir[_MAX_PATH];
  163. TCHAR szDrive[_MAX_DRIVE];
  164. TCHAR szFileName[_MAX_FNAME];
  165. TCHAR szExt[_MAX_EXT];
  166. szDir[0] = szDrive[0] = szFileName[0] = szExt[0] = 0;
  167. _tsplitpath(sPath,szDrive,szDir,szFileName,szExt);
  168. return szExt;
  169. }
  171. // A bunch of registry nonsense to return all relevant details
  172. // but especially the application icon
  173. void CShellContextMenu::GetAppDetails(const CString &sAppName,CString &sDisplayName,CString &sCommand,HICON &hIconApp) const
  174. {
  175. hIconApp = NULL;
  176. sDisplayName.Empty();
  177. sCommand.Empty();
  179. CString sAppKey(szAppKey);
  180. AddKey(sAppKey,sAppName);
  181. AddKey(sAppKey,szShellKey);
  182. HKEY hKey;
  183. if (RegOpenKeyEx(HKEY_CLASSES_ROOT,sAppKey,0,KEY_READ,&hKey) != ERROR_SUCCESS)
  184. return;
  185. BYTE szDisplayName[_MAX_PATH];
  186. DWORD dwSize=sizeof(szDisplayName);
  187. DWORD dwType=REG_SZ;
  188. LONG nRet = RegQueryValueEx(hKey,szDisplayNameEntry,NULL,&dwType,szDisplayName,&dwSize);
  189. if (nRet != ERROR_SUCCESS)
  190. {
  191. RegCloseKey(hKey);
  192. return;
  193. }
  194. sDisplayName = szDisplayName;
  195. TCHAR szSubKey[_MAX_PATH];
  196. TCHAR szClass[_MAX_PATH];
  197. DWORD dwSizeSubKey = sizeof(szSubKey)-1;
  198. DWORD dwSizeClass = sizeof(szClass)-1;
  199. ZeroMemory(szSubKey,sizeof(szSubKey));
  200. ZeroMemory(szClass,sizeof(szClass));
  201. FILETIME ftLastWriteTime;
  202. HKEY hCmdKey=NULL;
  203. CString sCmdKey;
  204. // Search for a key that contains the "command" key as it may not be under "open"
  205. for(DWORD dwIndex=0;RegEnumKeyEx(hKey,dwIndex, 
  206.   szSubKey, 
  207.   &dwSizeSubKey,
  208.   NULL,
  209.   szClass,
  210.   &dwSizeClass,
  211.   &ftLastWriteTime) == ERROR_SUCCESS;dwIndex++)
  212. {
  213. sCmdKey = szSubKey;
  214. AddKey(sCmdKey,szCommandKey);
  215. if (RegOpenKeyEx(hKey,sCmdKey,0,KEY_READ,&hCmdKey) == ERROR_SUCCESS)
  216. {
  217. break;
  218. }
  219. dwSizeSubKey = sizeof(szSubKey)-1;
  220. dwSizeClass = sizeof(szClass)-1;
  221. }
  222. RegCloseKey(hKey);
  223. hKey = NULL;
  224. if (hCmdKey == NULL)
  225. return;
  226. dwType=REG_SZ | REG_EXPAND_SZ;
  227. BYTE szCommand[_MAX_PATH];
  228. dwSize=sizeof(szCommand);
  229. nRet = RegQueryValueEx(hCmdKey,NULL,NULL,&dwType,szCommand,&dwSize);
  230. if (nRet != ERROR_SUCCESS)
  231. return;
  232. TCHAR szPath[MAX_PATH];
  233. sCommand = szCommand;
  234. if (ExpandEnvironmentStrings(sCommand,szPath,sizeof(szPath)))
  235. sCommand = szPath;
  236. CString sIconPath(sCommand);
  237. sIconPath.MakeLower();
  238. // Only extract icons from exe's at the moment
  239. int nPos = sIconPath.Find(_T(".exe"));
  240. if (nPos == -1)
  241. return;
  242. sIconPath = sIconPath.Left(nPos+4);
  243. // Remove auy quotes
  244. if (sIconPath.Left(1) == '"')
  245. sIconPath = sIconPath.Right(sIconPath.GetLength()-1);
  246. if (sIconPath.Right(1) == '"')
  247. sIconPath = sIconPath.Left(sIconPath.GetLength()-1);
  248. ExtractIconEx(sIconPath, 0, NULL, &hIconApp, 1);
  250. RegCloseKey(hCmdKey);
  251. }
  253. // reg helper
  254. void CShellContextMenu::AddKey(CString &sDestKey,const CString &sSrcKey) const
  255. {
  256. if (sDestKey.Right(1) != '\')
  257. sDestKey += '\';
  258. sDestKey += sSrcKey;
  259. }
  260. ////////////////////////////////////////
  262. bool CShellContextMenu::IsMenuCommand(int iCmd) const
  263. {
  264.     return (
  265.             (IDM_SENDTOFIRST   <= iCmd  &&  iCmd <= IDM_SENDTOLAST) ||
  266.             (IDM_SHELLCTXFIRST <= iCmd  &&  iCmd <= IDM_SHELLCTXLAST)
  267.            );
  268. }
  270. void CShellContextMenu::InvokeCommand(int iCmd) const
  271. {
  272. if (!iCmd)
  273. return;
  274. USES_CONVERSION;
  275. /////////////////////////////
  276.         if (IDM_SENDTOFIRST <= iCmd  &&  iCmd <= IDM_SENDTOLAST)
  277.         {
  278.             // "Send To..." item
  280.             CPIDL        pidlFile(m_sAbsPath), pidlDrop;
  281.             LPDROPTARGET pDT;
  282.             LPDATAOBJECT pDO;
  283.             HRESULT hr;
  285.             hr = pidlFile.GetUIObjectOf(IID_IDataObject, (LPVOID *)&pDO, 
  286.                 m_hWnd);
  287.             if (SUCCEEDED(hr))
  288.             {
  289.                 pidlDrop.Set((LPITEMIDLIST)
  290.                     CCoolMenuManager::GetItemData(*m_pSendToMenu, iCmd));
  291.                 hr = pidlDrop.GetUIObjectOf(IID_IDropTarget, 
  292.                     (LPVOID *)&pDT, m_hWnd);
  294.                 if (SUCCEEDED(hr))
  295.                 {
  296.                     // do the drop
  297.                     POINTL pt = { 0, 0 };
  298.                     DWORD dwEffect = 
  299.                         DROPEFFECT_COPY | DROPEFFECT_MOVE | DROPEFFECT_LINK;
  300.                     hr = pDT->DragEnter(pDO, MK_LBUTTON, pt, &dwEffect);
  302.                     if (SUCCEEDED(hr) && dwEffect) 
  303.                     {
  304.                         hr = pDT->Drop(pDO, MK_LBUTTON, pt, &dwEffect);
  305.                     } 
  306.                     else 
  307.                     {
  308.                         hr = pDT->DragLeave();
  309.                     }
  311.                     pDT->Release();
  312.                 }
  314.                 pidlDrop.m_pidl = NULL;
  315.             }
  316.         }
  317.         else
  318.         {
  319. DWORD dwItemData=0;
  320. CMenu *pMenu=NULL;
  321. STL_FOR_ITERATOR(vecODMenu,m_OwnerDrawMenus)
  322. {
  323. pMenu = STL_GET_CURRENT(m_OwnerDrawMenus);
  324. if (pMenu && pMenu->GetMenuItemCount() > 0)
  325. {
  326. // switch to original item data
  327. if ((UINT)iCmd >= pMenu->GetMenuItemID(0) && (UINT)iCmd <= pMenu->GetMenuItemID(pMenu->GetMenuItemCount()-1))
  328. {
  329. dwItemData = g_CoolMenuManager.SwitchContextItemData(pMenu,iCmd,0,FALSE);
  330. break;
  331. }
  332. }
  333. }
  334. CWaitCursor w;
  335.             // Shell command
  336.             CMINVOKECOMMANDINFO cmi;
  337.             cmi.cbSize       = sizeof(cmi);
  338.             cmi.fMask        = 0;
  339.             cmi.hwnd         = m_hWnd;
  340.             cmi.lpVerb       = T2CA(MAKEINTRESOURCE(iCmd - IDM_SHELLCTXFIRST));
  341.             cmi.lpParameters = NULL;
  342.             cmi.lpDirectory  = NULL;
  343.             cmi.nShow        = SW_SHOWNORMAL;
  344.             cmi.dwHotKey     = 0;
  345.             cmi.hIcon        = NULL;
  346.             m_lpcm->InvokeCommand(&cmi);
  347. // switch back to our item data
  348. if (dwItemData)
  349. {
  350. g_CoolMenuManager.SwitchContextItemData(pMenu,iCmd,dwItemData,FALSE);
  351. }
  352.         }
  353. }
  355. // retrieves the shell context menu for a file
  356. void CShellContextMenu::SetMenu(CMenu *pMenu)
  357. {
  358.     if (m_sAbsPath.IsEmpty())
  359. return;
  360. ASSERT(m_psfParent);
  361.     HRESULT hr = m_psfParent->GetUIObjectOf(m_hWnd, m_cidl, (LPCITEMIDLIST*)m_ppidl, IID_IContextMenu, NULL, (LPVOID *)&m_lpcm);
  362. // NOTE: Slight change to return here but change it back if you want: PO
  363.     if (FAILED(hr))
  364. return;
  366.     g_CoolMenuManager.UnconvertMenu(pMenu);
  367. g_CoolMenuManager.SetShellContextMenu(m_lpcm,IDM_SHELLCTXFIRST,IDM_SHELLCTXLAST);
  369.     pMenu->DeleteMenu(0, MF_BYPOSITION);
  370.     hr = m_lpcm->QueryContextMenu(*pMenu, 0, IDM_SHELLCTXFIRST, 
  371.         IDM_SHELLCTXLAST, CMF_EXPLORE);
  372. /////////////////////////////
  373. // Additions Philip Oldaker 
  374. // Check for IContextMenu2 used by owner draw menus
  375.     CMenu *pSubMenu;
  376.     int count = pMenu->GetMenuItemCount();
  377.     for (int i = 0; i < count; i++)
  378.     {
  379. CMenuItemInfo mii;
  380. mii.fMask = MIIM_TYPE | MIIM_ID;
  381. pMenu->GetMenuItemInfo(i,&mii,TRUE);
  382. if (mii.fType & MFT_OWNERDRAW)
  383. {
  384. TRACE(_T("OwnerDraw menu item found in CShellContextMenun"));
  385.             g_CoolMenuManager.AddShellContextMenu(pMenu,m_lpcm,i);
  386. STL_ADD_ITEM(m_OwnerDrawMenus,pMenu);
  387. }
  388.         pSubMenu = pMenu->GetSubMenu(i);
  389. /////////////////////////////
  390. // Additions Philip Oldaker 
  391. // Search for owner draw menus and add the ICM2 pointer
  392. if (pSubMenu)
  393. {
  394. // NOTE: Remove the TRACE statements if not needed
  395. UINT nSubCount = pSubMenu->GetMenuItemCount();
  396. TRACE(_T("Count=%un"),nSubCount);
  397. for(UINT m=0;m < nSubCount;m++)
  398. {
  399. CMenuItemInfo mii;
  400. mii.fMask = MIIM_TYPE;
  401. pSubMenu->GetMenuItemInfo(m,&mii,TRUE);
  402. if (mii.fType & MFT_OWNERDRAW)
  403. {
  404. TRACE(_T("OwnerDraw submenu found in CShellContextMenun"));
  405.                     g_CoolMenuManager.AddShellContextMenu(pSubMenu,m_lpcm,m);
  406. STL_ADD_ITEM(m_OwnerDrawMenus,pSubMenu);
  407. }
  408. }
  409. }
  410. /////////////////////////////
  411.     // find the "Send To" and the new "Open With" submenu: look for a defined menu item id
  412.         if (pSubMenu && pSubMenu->GetMenuItemCount() == 1)
  413.         {
  414.     CString str;
  415. pSubMenu->GetMenuString(0,str,MF_BYPOSITION);
  416.             UINT idmFirst = pSubMenu->GetMenuItemID(0);
  417. TRACE(_T("Menu Item %s=%dn"),str,idmFirst);
  418. /////////////////////////////
  419. // Additions Philip Oldaker 
  420. // Populate the OpenWith menu
  421. if (idmFirst == IDM_OPENWITHID1 || idmFirst == IDM_OPENWITHID2)
  422. {
  423. // ok - found it.  now populate it
  424. IContextMenu2 *lpcm2=NULL;
  425. HRESULT hr = m_lpcm->QueryInterface(IID_IContextMenu2,(LPVOID*)&lpcm2);
  426. if (SUCCEEDED(hr))
  427. {
  428. hr = lpcm2->HandleMenuMsg(WM_INITMENUPOPUP,(WPARAM)pSubMenu->GetSafeHmenu(),0);
  429. lpcm2->Release();
  430. // We need the extension to search the registry for valid applications
  431. CString sExt(GetExt(m_sAbsPath));
  432. // No extension then there's nothing to do
  433. if (sExt.IsEmpty())
  434. continue;
  435. FillOpenWithMenu(pSubMenu,sExt);
  436. STL_ADD_ITEM(m_OwnerDrawMenus,pSubMenu);
  437. }
  438. }
  439.             else if (idmFirst == IDM_SENDTOID)
  440.             {
  441.             UINT idm = IDM_SENDTOFIRST;
  442.                 // ok - found it.  now populate it
  443.                 m_pSendToMenu = CMenu::FromHandle(::CreatePopupMenu());
  444.                 ASSERT_VALID(m_pSendToMenu);
  445.                 pSubMenu->DestroyMenu();
  446.                 pMenu->ModifyMenu(i, MF_BYPOSITION | MF_POPUP, 
  447.                     (UINT)m_pSendToMenu->m_hMenu, str);
  448.                 FillSendToMenu(m_pSendToMenu, stat_data.m_sfSendTo, idm);
  449.             }
  450. /////////////////////////////
  451.         }
  452.     }
  453. // Not needed I think :PO
  454.     return;
  455. }
  457. ////////////////////////////
  458. // Additions: Philip Oldaker
  459. // Scan the registry looking for a OpenWithList key in this format
  460. // Entry MRUList contains the alphabetical order eg. afgrde for each entry
  461. // each of these entries points to the application name which in turn
  462. // has the command and display name
  463. ////////////////////////////
  464. void CShellContextMenu::FillOpenWithMenu(CMenu *pMenu,const CString &sExt)
  465. {
  466. HKEY hKey;
  467. CString sFileExtKey(szFileExtKey);
  468. AddKey(sFileExtKey,sExt);
  469. AddKey(sFileExtKey,szOpenWithListKey);
  470. if (RegOpenKeyEx(HKEY_CURRENT_USER,sFileExtKey,0,KEY_READ,&hKey) != ERROR_SUCCESS)
  471. return;
  472. BYTE szMRUList[_MAX_PATH];
  473. szMRUList[0] = 0;
  474. DWORD dwSize=sizeof(szMRUList);
  475. DWORD dwType=REG_SZ;
  476. RegQueryValueEx(hKey,szMRUListEntry,NULL,&dwType,szMRUList,&dwSize);
  477. int nLen = _tcslen((LPCTSTR)szMRUList);
  478. TCHAR szOpenWithItemEntry[sizeof(TCHAR)*2];
  479. ZeroMemory(szOpenWithItemEntry,sizeof(szOpenWithItemEntry));
  480. BYTE szOpenWithItem[_MAX_PATH];
  481. CString sDisplayName;
  482. HICON hIconApp;
  483. CString sCommand;
  484. CString sMenuText;
  485. for(int i=0;i < nLen;i++)
  486. {
  487. szOpenWithItemEntry[0] = szMRUList[i];
  488. dwSize = sizeof(szOpenWithItem);
  489. RegQueryValueEx(hKey,szOpenWithItemEntry,NULL,&dwType,szOpenWithItem,&dwSize);
  490. GetAppDetails(szOpenWithItem, sDisplayName, sCommand, hIconApp);
  491. if (!sCommand.IsEmpty())
  492. {
  493. for(UINT idm=0;idm < pMenu->GetMenuItemCount();idm++)
  494. {
  495. pMenu->GetMenuString(idm,sMenuText,MF_BYPOSITION);
  496. if (sMenuText == sDisplayName)
  497. {
  498. g_CoolMenuManager.ConvertMenuItem(pMenu, idm);
  499. CCoolMenuManager::SetItemIcon(*pMenu, hIconApp, idm, TRUE);
  500. break;
  501. }
  502. }
  503. }
  504. }
  505. RegCloseKey(hKey);
  506. }
  508. void CShellContextMenu::FillSendToMenu(CMenu *pMenu, LPSHELLFOLDER pSF, 
  509.                                        UINT &idm)
  510. {
  511.     if (pSF == NULL) 
  512. return;
  513.     USES_CONVERSION;
  514.     CPIDL           pidl, abspidl;
  515.     LPENUMIDLIST    peidl;
  516.     HRESULT         hr;
  517.     STRRET          str;
  518.     UINT            idmStart = idm;
  519.     LPSHELLFOLDER   pSubSF;
  520.     SHFILEINFO      sfi;
  521. vecCMSort vMenuItems;
  523.     int idx_folder = 0; // folder insertion index
  525.     hr = pSF->EnumObjects(m_hWnd, 
  526.         SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &peidl);
  527.     if (FAILED(hr))
  528. return;
  529.     g_CoolMenuManager.ConvertMenu(pMenu);
  530.     while (peidl->Next(1, pidl, NULL) == S_OK  &&
  531.            idm < IDM_SENDTOLAST) 
  532.     {
  533.         hr = pSF->GetDisplayNameOf(pidl, SHGDN_NORMAL, &str);
  534.         if (SUCCEEDED(hr)) 
  535.         {
  536.             ULONG ulAttrs = (unsigned)-1;
  537.             pSF->GetAttributesOf(1, pidl, &ulAttrs);
  538.             abspidl.MakeAbsPIDLOf(pSF, pidl);
  539.             SHGetFileInfo((LPCTSTR)abspidl.m_pidl, 0, &sfi, sizeof(sfi),
  540.                 SHGFI_PIDL | SHGFI_ICON | SHGFI_SMALLICON);
  541.             pidl.ExtractCStr(str);
  542.             if (ulAttrs & SFGAO_FOLDER) // folder?
  543.             {
  544.                 // create new submenu & recurse
  545.                 HMENU hSubMenu = ::CreateMenu();
  546.                 pMenu->InsertMenu(idx_folder, 
  547.                     MF_POPUP | MF_BYPOSITION | MF_STRING, 
  548.                     (UINT)hSubMenu, A2T(str.cStr));
  549.                 g_CoolMenuManager.ConvertMenuItem(pMenu, 
  550.                     idx_folder);
  551.                 CCoolMenuManager::SetItemIcon(*pMenu, 
  552.                     sfi.hIcon, idx_folder, TRUE);
  553.                 idx_folder++;
  554.                 hr = pSF->BindToObject(pidl, NULL, 
  555.                     IID_IShellFolder, (LPVOID *)&pSubSF);
  556.                 if (!SUCCEEDED(hr)) pSubSF = NULL;
  557.                 FillSendToMenu(CMenu::FromHandle(hSubMenu), pSubSF, 
  558.                     idm);
  559.                 if (pSubSF) pSubSF->Release();
  560.                 abspidl.Free();
  561.             }
  562.             else
  563.             {
  564. CShCMSort *pSMI = new CShCMSort(idm,pidl.m_pidl,sfi.hIcon,A2T(str.cStr),(DWORD)abspidl.m_pidl);
  565. STL_ADD_ITEM(vMenuItems,pSMI);
  566.                 idm++;
  567.             }
  568.             abspidl.m_pidl = NULL;
  569.         }
  570.     }
  571.     peidl->Release();
  572. // Addition: Philip Oldaker
  573. // To keep it familiar the SendTo menu is sorted
  574. STL_SORT(vMenuItems,pSF,STL_SORT_FUNC);
  575. CShCMSort *pItem=NULL;
  576. STL_FOR_ITERATOR(vecCMSort,vMenuItems)
  577. {
  578. pItem = STL_GET_CURRENT(vMenuItems);
  579. pMenu->AppendMenu(MF_STRING, pItem->GetItemID(), pItem->GetText());
  580. g_CoolMenuManager.ConvertMenuItem(pMenu, 
  581. pMenu->GetMenuItemCount() - 1);
  582. CCoolMenuManager::SetItemIcon(*pMenu, 
  583. pItem->GetIcon(), pItem->GetItemID());
  584. CCoolMenuManager::SetItemData(*pMenu, 
  585. (void*)pItem->GetItemData(), pItem->GetItemID());
  586.         CPIDL toFree(pItem->GetPidl());
  587. delete pItem;
  588. }
  589. STL_ERASE_ALL(vMenuItems);
  590. //////////////////////////////////
  591.     // If the menu is still empty (the user has an empty SendTo folder),
  592.     // then add a disabled "(empty)" item so we have at least something
  593.     // to display.
  594.     if (idm == idmStart) 
  595.     {
  596.         pMenu->AppendMenu(MF_GRAYED | MF_DISABLED | MF_STRING, idm, 
  597.             _T("(empty)"));
  598.         idm++;
  599.     }
  600. }