Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
deskfldr.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 51k
Category:

Windows Kernel

Development Platform:

Visual C++

deskfldr.cpp：Code Content
  1. #include "shellprv.h"
  2. #include "sfviewp.h"
  3. #include "deskfldr.h"
  4. #include "fstreex.h"
  5. #include "datautil.h"
  6. #include "views.h"
  7. #include "ids.h"
  8. #include "caggunk.h"
  9. #include "enum.h"
  10. #include "shitemid.h"
  12. #include "fstreex.h"
  13. #include "drives.h"
  14. #include "deskfldr.h"
  15. #include "infotip.h"
  17. #include "unicppdeskhtm.h"
  19. class CDesktopFolderEnum;
  20. class CDesktopViewCallBack;
  23. class CDesktopFolder : IShellFolder2, IPersistFolder2, IShellIcon, IShellIconOverlay
  24. {
  25. public:
  26.     // IUnknown
  27.     STDMETHODIMP QueryInterface(REFIID riid, void **ppvObj); // { return CAggregatedUnknown::QueryInterface(riid, ppvObj); };
  28.     STDMETHODIMP_(ULONG) AddRef(void)  { return 3; /* CAggregatedUnknown::AddRef(); */ };
  29.     STDMETHODIMP_(ULONG) Release(void) { return 2; /* CAggregatedUnknown::Release(); */ };
  31.     // IShellFolder methods
  32.     STDMETHODIMP ParseDisplayName(HWND hwnd, LPBC pbc, LPOLESTR lpszDisplayName,
  33.                                   ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes);
  34.     STDMETHODIMP EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenumIDList);
  35.     STDMETHODIMP BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvOut);
  36.     STDMETHODIMP BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvObj);
  37.     STDMETHODIMP CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
  38.     STDMETHODIMP CreateViewObject (HWND hwndOwner, REFIID riid, void **ppvOut);
  39.     STDMETHODIMP GetAttributesOf(UINT cidl, LPCITEMIDLIST * apidl, ULONG *rgfInOut);
  40.     STDMETHODIMP GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl,
  41.                                REFIID riid, UINT * prgfInOut, void **ppvOut);
  42.     STDMETHODIMP GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET lpName);
  43.     STDMETHODIMP SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR lpszName, DWORD uFlags,
  44.                            LPITEMIDLIST * ppidlOut);
  46.     // IShellFolder2 methods
  47.     STDMETHODIMP GetDefaultSearchGUID(LPGUID lpGuid);
  48.     STDMETHODIMP EnumSearches(LPENUMEXTRASEARCH *ppenum);
  49.     STDMETHODIMP GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay);
  50.     STDMETHODIMP GetDefaultColumnState(UINT iColumn, DWORD *pbState);
  51.     STDMETHODIMP GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv);
  52.     STDMETHODIMP GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails);
  53.     STDMETHODIMP MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid);
  55.     // IPersist
  56.     STDMETHODIMP GetClassID(LPCLSID lpClassID);
  58.     // IPersistFolder
  59.     STDMETHODIMP Initialize(LPCITEMIDLIST pidl);
  61.     //IPersistFolder2
  62.     STDMETHODIMP GetCurFolder(LPITEMIDLIST *ppidl);
  64.     // IShellIcon methods
  65.     STDMETHOD(GetIconOf)(LPCITEMIDLIST pidl, UINT flags, int *piIndex);
  67.     // IShellIconOverlay methods
  68.     STDMETHOD(GetOverlayIndex)(LPCITEMIDLIST pidl, int * pIndex);
  69.     STDMETHOD(GetOverlayIconIndex)(LPCITEMIDLIST pidl, int * pIndex);
  70.   
  71.     CDesktopFolder(IUnknown *punkOuter);
  72.     HRESULT _Init();
  73.     HRESULT _Init2();
  74.     void _Destroy();
  76. private:
  77. //    HRESULT v_InternalQueryInterface(REFIID riid, void **ppv);
  78.     ~CDesktopFolder();
  80.     friend CDesktopFolderEnum;
  81.     friend CDesktopViewCallBack;
  83.     friend HRESULT CDesktop_HandleCommand(CDesktopFolder *pdf, HWND hwndOwner, WPARAM wparam, BOOL bExecute);
  84.     friend HRESULT CDesktop_DFMCallBackBG(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam);
  86.     IShellFolder2 *_GetItemFolder(LPCITEMIDLIST pidl);
  87.     HRESULT _GetItemUIObject(HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl, REFIID riid, UINT *prgfInOut, void **ppvOut);
  88.     HRESULT _QueryInterfaceItem(LPCITEMIDLIST pidl, REFIID riid, void **ppv);
  89.     HRESULT _CreateEnum(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenum);
  90.     HRESULT _ChildParseDisplayName(LPCITEMIDLIST pidlLeft, HWND hwnd, IBindCtx *pbc, 
  91.                 LPWSTR pwzDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, DWORD *pdwAttributes);
  92.     HRESULT _TrySpecialUrl(HWND hwnd, LPBC pbc, WCHAR *pwzDisplayName, ULONG *pchEaten,
  93.                                        LPITEMIDLIST *ppidl, ULONG *pdwAttributes);
  95.     IShellFolder2 *_psfDesktop;      // "Desktop" shell folder (real files live here)
  96.     IShellFolder2 *_psfAltDesktop;   // "Common Desktop" shell folder
  97.     IUnknown *_punkReg;             // regitem inner folder (agregate)
  98.     IContextMenu *_pcmDesktopExt;
  99. };
  103. class CDesktopFolderEnum : public IEnumIDList
  104. {
  105. public:
  106.     // *** IUnknown methods ***
  107.     STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
  108.     STDMETHOD_(ULONG,AddRef)();
  109.     STDMETHOD_(ULONG,Release)();
  111.     // *** IEnumIDList methods ***
  112.     STDMETHOD(Next)(ULONG celt, LPITEMIDLIST *rgelt, ULONG *pceltFetched);
  113.     STDMETHOD(Skip)(ULONG celt);
  114.     STDMETHOD(Reset)();
  115.     STDMETHOD(Clone)(IEnumIDList **ppenum);
  116.     
  117.     CDesktopFolderEnum(CDesktopFolder *pdf, HWND hwnd, DWORD grfFlags);
  119. private:
  120.     ~CDesktopFolderEnum();
  122.     LONG _cRef;
  123.     BOOL _bUseAltEnum;
  124.     IEnumIDList *_penumFolder;
  125.     IEnumIDList *_penumAltFolder;
  126. };
  128. IShellFolderViewCB* Desktop_CreateSFVCB(CDesktopFolder* pdf);
  130. //
  131. // Global variables
  132. //
  134. SFEnumCacheData g_EnumCache = {0};
  137. #ifdef WINNT
  138. #define NETCPL  TEXT("NCPA.CPL")
  139. #else
  140. #define NETCPL TEXT("NETCPL.CPL")
  141. #endif
  143. //
  144. // this is now perinstance so we can poke at it at runtime :)
  145. //
  146. REQREGITEM g_asDesktopReqItems[] =
  147. {
  148.     { 
  149.         &CLSID_MyComputer,  IDS_DRIVEROOT,  
  150.         TEXT("explorer.exe"), 0, SORT_ORDER_DRIVES, 
  151.         SFGAO_HASSUBFOLDER | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR  | SFGAO_DROPTARGET | SFGAO_FOLDER | SFGAO_CANRENAME | SFGAO_CANMONIKER,
  152.         TEXT("SYSDM.CPL")
  153.     },
  154.     { 
  155.         &CLSID_NetworkPlaces, IDS_NETWORKROOT, 
  156.         TEXT("shell32.dll"), -IDI_MYNETWORK, SORT_ORDER_NETWORK, 
  157.         SFGAO_HASSUBFOLDER | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR | SFGAO_DROPTARGET | SFGAO_FOLDER | SFGAO_CANRENAME | SFGAO_CANMONIKER, 
  158.         NETCPL,
  159.     },
  160.     { 
  161.         &CLSID_Internet, IDS_INETROOT, 
  162.         TEXT("mshtml.dll"),   0, SORT_ORDER_INETROOT, 
  163.         SFGAO_BROWSABLE  | SFGAO_HASPROPSHEET | SFGAO_CANRENAME  | SFGAO_FOLDER, 
  164.         TEXT("INETCPL.CPL")
  165.     },
  166. };
  168. const UNALIGNED ITEMIDLIST c_idlDesktop = { { 0, 0 } };
  170. #define DESKTOP_PIDL  ((LPITEMIDLIST)&c_idlDesktop)
  174. BOOL CDesktop_IsDesktop(HWND hwnd)
  175. {
  176.     TCHAR szClassName[50];
  177.     return GetClassName(hwnd, szClassName, ARRAYSIZE(szClassName)) && 
  178.         lstrcmpi(szClassName, TEXT(STR_DESKTOPCLASS)) == 0;
  179. }
  182. //
  183. // single global instance of this CDesktopFolder object
  184. //
  185. CDesktopFolder *g_pDesktopFolder = NULL;
  187. REGITEMSINFO g_riiDesktop =
  188. {
  189.     REGSTR_PATH_EXPLORER TEXT("\Desktop\NameSpace"),
  190.     NULL,
  191.     TEXT(':'),
  192.     SHID_ROOT_REGITEM,
  193.     1,
  194.     SFGAO_CANLINK,
  195.     ARRAYSIZE(g_asDesktopReqItems),
  196.     g_asDesktopReqItems,
  197.     RIISA_ORIGINAL,
  198.     NULL,
  199.     0,
  200.     0,
  201. };
  204. void Desktop_InitRequiredItems(void)
  205. {
  206.     //  "NoNetHood" restruction -> always hide the hood.
  207.     //  Otherwise, show the hood if either MPR says so or we have RNA.
  208.     if (!(GetSystemMetrics(SM_NETWORK) & RNC_NETWORKS) || SHRestricted(REST_NONETHOOD))
  209.     {
  210.         // Don't enumerate the "Net Hood" thing.
  211.         g_asDesktopReqItems[CDESKTOP_REGITEM_NETWORK].dwAttributes |= SFGAO_NONENUMERATED;
  212.     }
  213.     else
  214.     {
  215.         // Do enumerate the "My Network" thing.
  216.         g_asDesktopReqItems[CDESKTOP_REGITEM_NETWORK].dwAttributes &= ~SFGAO_NONENUMERATED;
  217.     }
  219.     //
  220.     // "NoInternetIcon" restriction -> hide The Internet on the desktop
  221.     //
  222.     if (SHRestricted(REST_NOINTERNETICON))
  223.     {
  224.         g_asDesktopReqItems[CDESKTOP_REGITEM_INTERNET].dwAttributes &=  ~(SFGAO_BROWSABLE | SFGAO_FOLDER);
  225.         g_asDesktopReqItems[CDESKTOP_REGITEM_INTERNET].dwAttributes |= SFGAO_NONENUMERATED;
  226.     }
  228.     // BUGBUG:: Word Perfect 7 faults when it enumerates the Internet item
  229.     // in their background thread.  For now App hack specific to this app
  230.     // later may need to extend...  Note: This app does not install on
  231.     // NT so only do for W95...
  232.     // it repros with Word Perfect Suite 8, too, this time on both NT and 95
  233.     // so removing the #ifndef... -- reljai 11/20/97, bug#842 in ie5 db
  235.     if (SHGetAppCompatFlags(ACF_CORELINTERNETENUM) & ACF_CORELINTERNETENUM)
  236.     {
  237.         g_asDesktopReqItems[CDESKTOP_REGITEM_INTERNET].dwAttributes &=  ~(SFGAO_BROWSABLE | SFGAO_HASSUBFOLDER | SFGAO_FOLDER);
  238.         g_asDesktopReqItems[CDESKTOP_REGITEM_INTERNET].dwAttributes |= SFGAO_NONENUMERATED;
  239.     }
  240. }
  242. CDesktopFolder::CDesktopFolder(IUnknown *punkOuter)
  243. {
  244.     DllAddRef();
  245. }
  247. CDesktopFolder::~CDesktopFolder()
  248. {
  249.     DllRelease();
  250. }
  252. // first phase of init (does not need to be seralized)
  254. HRESULT CDesktopFolder::_Init()
  255. {
  256.     Desktop_InitRequiredItems();
  258.     return CRegFolder_CreateInstance(&g_riiDesktop, SAFECAST(this, IShellFolder2 *), IID_IUnknown, (void **)&_punkReg);
  259. }
  261. // second phase of init (needs to be seralized)
  263. HRESULT CDesktopFolder::_Init2()
  264. {
  265.     HRESULT hr;
  267.     hr = SHCacheTrackingFolder(DESKTOP_PIDL, CSIDL_DESKTOPDIRECTORY | CSIDL_FLAG_CREATE, &_psfDesktop);
  268.     if (FAILED(hr))
  269.     {
  270.         DebugMsg(DM_TRACE, TEXT("Failed to create desktop IShellFolder!"));
  271.         return hr;
  272.     }
  275.     if ( !SHRestricted(REST_NOCOMMONGROUPS))
  276.     {
  277.         hr = SHCacheTrackingFolder(DESKTOP_PIDL, CSIDL_COMMON_DESKTOPDIRECTORY, &_psfAltDesktop);
  278.     }
  280.     return hr;
  281. }
  283. // CLSID_ShellDesktop constructor
  285. STDAPI CDesktop_CreateInstance(IUnknown *punkOuter, REFIID riid, void **ppv)
  286. {
  287.     HRESULT hr;
  289.     if (g_pDesktopFolder)
  290.     {
  291.         hr = g_pDesktopFolder->QueryInterface(riid, ppv);
  292.     }
  293.     else
  294.     {
  295.         *ppv = NULL;
  297.         // WARNING: the order of init of the desktop folder state is very important.
  298.         // the creation of the sub folders, in particular _psfAltDesktop will
  299.         // recurse on this function. we protect ourself from that here. the creation
  300.         // of that also requires the above members to be inited.
  302.         CDesktopFolder *pdf = new CDesktopFolder(punkOuter);
  303.         if (pdf)
  304.         {
  305.             hr = pdf->_Init();
  306.             if (SUCCEEDED(hr))
  307.             {
  308.                 // NOTE: there is a race condition here where we have stored g_pDesktopFolder but
  309.                 // not initialized _psfDesktop & _psfAltDesktop. the main line code deals with
  310.                 // this by testing for NULL on these members.
  311.                 if (SHInterlockedCompareExchange((void **)&g_pDesktopFolder, pdf, 0))
  312.                 {
  313.                     // Someone else beat us to creating the object.
  314.                     // get rid of our copy, global already set (the race case)
  315.                     pdf->_Destroy();    
  316.                 }
  317.                 else
  318.                 {
  319.                     g_pDesktopFolder->_Init2();
  320.                 }
  321.                 hr = g_pDesktopFolder->QueryInterface(riid, ppv);
  322.             }
  323.             else
  324.                 pdf->_Destroy();
  325.         }
  326.         else
  327.             hr = E_OUTOFMEMORY;
  328.     }
  329.     return hr;
  330. }
  333. STDAPI SHGetDesktopFolder(IShellFolder **ppshf)
  334. {
  335.     return CDesktop_CreateInstance(NULL, IID_IShellFolder, (void **)ppshf);
  336. }
  338. IShellFolder2 *CDesktopFolder::_GetItemFolder(LPCITEMIDLIST pidl)
  339. {
  340.     if (_psfAltDesktop && FS_IsCommonItem(pidl))
  341.         return _psfAltDesktop;
  342.     return _psfDesktop;
  343. }
  345. HRESULT CDesktopFolder::_QueryInterfaceItem(LPCITEMIDLIST pidl, REFIID riid, void **ppv)
  346. {
  347.     HRESULT hr;
  348.     IShellFolder2 *psf = _GetItemFolder(pidl);
  349.     if (psf)
  350.         hr = psf->QueryInterface(riid, ppv);
  351.     else
  352.     {
  353.         *ppv = NULL;
  354.         hr = E_NOINTERFACE;
  355.     }
  356.     return hr;
  357. }
  359. __inline BOOL _RegGetsFirstShot(REFIID riid)
  360. {
  361.     return (IsEqualIID(riid, IID_IShellFolder) ||
  362.             IsEqualIID(riid, IID_IShellFolder2) ||
  363.             IsEqualIID(riid, IID_IShellIconOverlay));
  364. }
  366. HRESULT CDesktopFolder::QueryInterface(REFIID riid, void **ppv)
  367. {
  368.     static const QITAB qit[] = {
  369.         QITABENT(CDesktopFolder, IShellFolder2),                        // IID_ISHELLFolder2
  370.         QITABENTMULTI(CDesktopFolder, IShellFolder, IShellFolder2),     // IID_IShellFolder
  371.         QITABENT(CDesktopFolder, IShellIcon),                           // IID_IShellIcon
  372.         QITABENT(CDesktopFolder, IPersistFolder2),                      // IID_IPersistFolder2
  373.         QITABENTMULTI(CDesktopFolder, IPersistFolder, IPersistFolder2), // IID_IPersistFolder
  374.         QITABENTMULTI(CDesktopFolder, IPersist, IPersistFolder2),       // IID_IPersist
  375.         QITABENT(CDesktopFolder, IShellIconOverlay),                    // IID_IShellIconOverlay
  376.         { 0 },
  377.     };
  379.     if (IsEqualIID(riid, CLSID_ShellDesktop))
  380.     {
  381.         *ppv = this;     // class pointer (unrefed!)
  382.         return S_OK;
  383.     }
  384.     else if (_punkReg && _RegGetsFirstShot(riid))
  385.     {
  386.         return _punkReg->QueryInterface(riid, ppv);
  387.     }
  388.     HRESULT hr = QISearch(this, qit, riid, ppv);
  389.     if ((E_NOINTERFACE == hr) && (NULL != _punkReg))
  390.     {
  391.         return _punkReg->QueryInterface(riid, ppv);
  392.     }
  393.     else
  394.     {
  395.         return hr;
  396.     }
  397. }
  400. // During shell32.dll process detach, we will call here to do the final
  401. // release of the IShellFolder ptrs which used to be left around for the
  402. // life of the process.  This quiets things such as OLE's debug allocator,
  403. // which detected the leak.
  406. void CDesktopFolder::_Destroy()
  407. {
  408.     ATOMICRELEASE(_psfDesktop);
  409.     ATOMICRELEASE(_psfAltDesktop);
  410.     ATOMICRELEASE(_pcmDesktopExt);
  411.     SHReleaseInnerInterface(SAFECAST(this, IShellFolder *), &_punkReg);
  412.     delete this;
  413. }
  415. LPITEMIDLIST CreateMyComputerIDList()
  416. {
  417.     return ILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}")); // CLSID_MyComputer
  418. }
  420. LPITEMIDLIST CreateWebFoldersIDList()
  421. {
  422.     return ILCreateFromPath(TEXT("::{20D04FE0-3AEA-1069-A2D8-08002B30309D}\::{BDEADF00-C265-11D0-BCED-00A0C90AB50F}")); // CLSID_MyComputerCLSID_WebFolders
  423. }
  425. LPITEMIDLIST CreateMyNetPlacesIDList()
  426. {
  427.     return ILCreateFromPath(TEXT("::{208D2C60-3AEA-1069-A2D7-08002B30309D}")); // CLSID_NetworkPlaces
  428. }
  430. HRESULT CDesktopFolder::_ChildParseDisplayName(LPCITEMIDLIST pidlLeft, HWND hwnd, IBindCtx *pbc, 
  431.                 LPWSTR pwzDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl, DWORD *pdwAttributes)
  432. {
  433.     IShellFolder *psfBind;
  434.     HRESULT hr = QueryInterface(IID_IShellFolder, (void **)&psfBind);
  435.     if (SUCCEEDED(hr))
  436.     {
  437.         IShellFolder *psfRight;
  438.         hr = psfBind->BindToObject(pidlLeft, pbc, IID_IShellFolder, (void **)&psfRight);
  439.         if (SUCCEEDED(hr))
  440.         {
  441.             LPITEMIDLIST pidlRight;
  442.             hr = psfRight->ParseDisplayName(hwnd, pbc, 
  443.                 pwzDisplayName, pchEaten, &pidlRight, pdwAttributes);
  444.             if (SUCCEEDED(hr))
  445.             {
  446.                 hr = SHILCombine(pidlLeft, pidlRight, ppidl);
  447.                 ILFree(pidlRight);
  448.             }
  449.             psfRight->Release();
  450.         }
  451.         psfBind->Release();
  452.     }
  454.     return hr;
  455. }
  457. STDAPI_(int) SHGetSpecialFolderID(LPCWSTR pszName);
  459. HRESULT CDesktopFolder::_TrySpecialUrl(HWND hwnd, LPBC pbc, WCHAR *pwzDisplayName, ULONG *pchEaten,
  460.                                        LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
  461. {
  462.     HRESULT hr = E_INVALIDARG;
  463.     PARSEDURLW pu = {0};
  464.     pu.cbSize = SIZEOF(pu);
  466.     if (SUCCEEDED(ParseURLW(pwzDisplayName, &pu)) && pu.nScheme == URL_SCHEME_SHELL)
  467.     {
  468.         int csidl = SHGetSpecialFolderID(pu.pszSuffix);
  470.         if (-1 != csidl)
  471.         {
  472.             hr = SHGetFolderLocation(hwnd, csidl | CSIDL_FLAG_CREATE, NULL, 0, ppidl);
  473.             if (SUCCEEDED(hr) && pdwAttributes && *pdwAttributes)
  474.             {
  475.                 hr = SHGetNameAndFlags(*ppidl, 0, NULL, 0, pdwAttributes);
  477.                 if (FAILED(hr))
  478.                 {
  479.                     ILFree(*ppidl);
  480.                     *ppidl = NULL;
  481.                 }
  482.             }
  483.         }
  484.     }
  485.     else if (pu.nScheme != URL_SCHEME_FTP && pu.nScheme != URL_SCHEME_FILE)
  486.     {
  487.         //  string is an URL, webfolders might know what to do with it, as long as its not a file or ftp url.
  488.         LPITEMIDLIST pidlWeb = CreateWebFoldersIDList();
  489.         if (pidlWeb)
  490.         {
  491.             hr = _ChildParseDisplayName(pidlWeb, hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  492.             ILFree(pidlWeb);
  493.         }
  494.     }
  495.     return hr;
  496. }
  498. //----------------------------------------------------------------------------
  499. STDMETHODIMP CDesktopFolder::ParseDisplayName(HWND hwnd, 
  500.                                        LPBC pbc, WCHAR *pwzDisplayName, ULONG *pchEaten,
  501.                                        LPITEMIDLIST *ppidl, ULONG *pdwAttributes)
  502. {
  503.     HRESULT hr = E_INVALIDARG;
  505.     *ppidl = NULL;      // assume error
  507.     if (pwzDisplayName && *pwzDisplayName)
  508.     {
  509.         LPITEMIDLIST pidlLeft = NULL;
  510.         USES_CONVERSION;
  511.         LPTSTR szDisplayName = W2T(pwzDisplayName);
  513.         ASSERT(hr == E_INVALIDARG);
  515.         if ((InRange(szDisplayName[0], TEXT('A'), TEXT('Z')) || 
  516.              InRange(szDisplayName[0], TEXT('a'), TEXT('z'))) && 
  517.             szDisplayName[1] == TEXT(':'))
  518.         {
  519.             // The string contains a path, let "My Computer" figire it out.
  520.             pidlLeft = CreateMyComputerIDList();
  521.             if (pchEaten)
  522.                 *pchEaten = 0;
  523.         }
  524.         else if (PathIsUNC(szDisplayName))
  525.         {
  526.             // The path is UNC, let "World" figure it out.
  527.             pidlLeft = CreateMyNetPlacesIDList();
  528.         }
  529.         else if (UrlIsW(pwzDisplayName, URLIS_URL) && !SHSkipJunctionBinding(pbc, NULL))
  530.         {
  531.             hr = _TrySpecialUrl(hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  532.         }
  534.         if (!pidlLeft && FAILED(hr))
  535.         {
  536.             //  when we request that something be created, we need to
  537.             //  check both folders and make sure that it doesnt exist in 
  538.             //  either one.  and then try and create it in the user folder
  539.             BIND_OPTS bo = {SIZEOF(bo)};
  540.             BOOL fCreate = FALSE;
  542.             if (pbc && SUCCEEDED(pbc->GetBindOptions(&bo)) && 
  543.                 (bo.grfMode & STGM_CREATE))
  544.             {
  545.                 fCreate = TRUE;
  546.                 bo.grfMode &= ~STGM_CREATE;
  547.                 pbc->SetBindOptions(&bo);
  548.             }
  550.             //  give the users desktop first shot.
  551.             // This must be a desktop item, _psfDesktop may not be inited in
  552.             // the case where we are called from ILCreateFromPath()
  553.             if (_psfDesktop)
  554.                 hr = _psfDesktop->ParseDisplayName(hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  556.             //  if the normal desktop folder didnt pick it off, 
  557.             //  it could be in the allusers folder.  give psfAlt a chance.
  558.             if (FAILED(hr) && _psfAltDesktop)
  559.             {
  560.                 hr = _psfAltDesktop->ParseDisplayName(hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  562.                 //  mark this as a common item.  
  563.                 if (SUCCEEDED(hr))
  564.                     FS_MakeCommonItem(*ppidl);
  565.             }
  567.             //  neither of the folders can identify an existing item
  568.             //  so we should pass the create flag to the real desktop
  569.             if (FAILED(hr) && fCreate && _psfDesktop)
  570.             {
  571.                 bo.grfMode |= STGM_CREATE;
  572.                 pbc->SetBindOptions(&bo);
  573.                 hr = _psfDesktop->ParseDisplayName(hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  574.                 //  when this succeeds, we know we got a magical ghost pidl...
  575.             }
  576.         }
  578.         if (pidlLeft)
  579.         {
  580.             hr = _ChildParseDisplayName(pidlLeft, hwnd, pbc, pwzDisplayName, pchEaten, ppidl, pdwAttributes);
  581.             ILFree(pidlLeft);
  582.         }
  583.     } 
  584.     else if (pwzDisplayName)
  585.     {
  586.         // we used to return this pidl when passed an empty string
  587.         // some apps (such as Wright Design) depend on this behavior,
  588.         // so i'm reinstating it --ccooney
  589.         hr = SHILClone((LPCITEMIDLIST)&c_idlDrives, ppidl);
  590.     }
  593.     return hr;
  594. }
  596. STDAPI_(void) UltRoot_Term()
  597. {
  598.     SFEnumCache_Terminate(&g_EnumCache);
  599.     if (g_pDesktopFolder)
  600.     {
  601.         g_pDesktopFolder->_Destroy();
  602.         g_pDesktopFolder = NULL;
  603.     }
  604. }
  607. HRESULT CDesktopFolder::_CreateEnum(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenum)
  608. {
  609.     HRESULT hr;
  610.     CDesktopFolderEnum *pesf = new CDesktopFolderEnum(this, hwnd, grfFlags);
  611.     if (pesf)
  612.     {
  613.         hr = pesf->QueryInterface(IID_IEnumIDList, (void **)ppenum);
  614.         pesf->Release();
  615.     }
  616.     else
  617.         hr = E_OUTOFMEMORY;
  618.     return hr;
  619. }
  621. STDMETHODIMP CDesktopFolder::EnumObjects(HWND hwnd, DWORD grfFlags, IEnumIDList **ppenum)
  622. {
  623.     HRESULT hr;
  624.     // should we cache this enum for later?
  625.     if (IsMainShellProcess() && EnumCanCache(grfFlags))
  626.     {
  627.         IEnumIDList *penum;
  628.         hr = _CreateEnum(hwnd, ENUMGRFFLAGS, &penum);
  629.         if (SUCCEEDED(hr)) 
  630.         {
  631.             hr = SFEnumCache_Create(penum, grfFlags, &g_EnumCache, SAFECAST(this, IShellFolder *), ppenum);
  632.             penum->Release();
  633.         }
  634.     }
  635.     else
  636.         hr = _CreateEnum(hwnd, grfFlags, ppenum);
  637.     return hr;
  638. }
  640. STDMETHODIMP CDesktopFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvOut)
  641. {
  642.     IShellFolder2 *psf = _GetItemFolder(pidl);
  643.     if (psf)
  644.         return psf->BindToObject(pidl, pbc, riid, ppvOut);
  645.     return E_UNEXPECTED;
  646. }
  648. STDMETHODIMP CDesktopFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppvOut)
  649. {
  650.     IShellFolder2 *psf = _GetItemFolder(pidl);
  651.     if (psf)
  652.         return psf->BindToStorage(pidl, pbc, riid, ppvOut);
  653.     return E_UNEXPECTED;
  654. }
  656. STDMETHODIMP CDesktopFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
  657. {
  658.     if (pidl1 == NULL || pidl2 == NULL)
  659.         return E_INVALIDARG;
  661.     if (pidl1->mkid.cb == 0 && pidl2->mkid.cb == 0)
  662.         return ResultFromShort(0);      // 2 empty IDLists, they are the same
  664.     // If both objects aren't from the same directory, they won't match.
  665.     if (_psfAltDesktop) 
  666.     {
  667.         if (FS_IsCommonItem(pidl1)) 
  668.         {
  669.             if (FS_IsCommonItem(pidl2)) 
  670.                 return _psfAltDesktop->CompareIDs(lParam, pidl1, pidl2);
  671.             else 
  672.                 return ResultFromShort(-1);
  673.         } 
  674.         else 
  675.         {
  676.             if (FS_IsCommonItem(pidl2)) 
  677.                 return ResultFromShort(1);
  678.             else if (_psfDesktop)
  679.                 return _psfDesktop->CompareIDs(lParam, pidl1, pidl2);
  680.         }
  681.     } 
  682.     else 
  683.     {
  684.         if (_psfDesktop)
  685.             return _psfDesktop->CompareIDs(lParam, pidl1, pidl2);
  686.     }
  688.     // If we have no _psfDesktop, we get here...
  689.     return ResultFromShort(-1);
  690. }
  692. HRESULT _GetDesktopExtMenu(HWND hwndOwner, IContextMenu** ppcm)
  693. {
  694.     HRESULT hr;
  695.     IShellBrowser *psb = FileCabinet_GetIShellBrowser(hwndOwner);
  696.     if (psb) 
  697.     {
  698.         IServiceProvider* psp;
  699.         hr = psb->QueryInterface(IID_IServiceProvider, (void **)&psp);
  700.         if (SUCCEEDED(hr)) 
  701.         {
  702.             hr = psp->QueryService(SID_SDesktopExtMenu, IID_IContextMenu, (void **)ppcm);
  703.             AssertMsg(SUCCEEDED(0), TEXT("WebBar: QueryService failed %x"), hr);
  704.             psp->Release();
  705.         } 
  706.         else 
  707.         {
  708.             AssertMsg(0, TEXT("WebBar: _GetDesktopExtMenu QI(IIS_ISP) failed %x"), hr);
  709.         }
  710.         // No need to release psb
  711.     } 
  712.     else 
  713.     {
  714.         AssertMsg(0, TEXT("WebBar: _GetDesktopExtMenu GetIShellFolder(%x) failed"), hwndOwner);
  715.         hr = E_UNEXPECTED;
  716.     }
  717.     return hr;
  718. }
  720. //----------------------------------------------------------------------------
  721. HRESULT CDesktop_HandleCommand(CDesktopFolder *pdf, HWND hwndOwner, WPARAM wparam, BOOL bExecute)
  722. {
  723.     HRESULT hr = NOERROR;
  725.     switch (wparam) {
  726.     case FSIDM_SORTBYNAME:
  727.     case FSIDM_SORTBYTYPE:
  728.     case FSIDM_SORTBYSIZE:
  729.     case FSIDM_SORTBYDATE:
  730.         if (bExecute)
  731.         {
  732.             ShellFolderView_ReArrange(hwndOwner, wparam - FSIDM_SORT_FIRST);
  733.         }
  734.         break;
  736.     case DFM_CMD_PROPERTIES:
  737.     case FSIDM_PROPERTIESBG:
  738.         if (bExecute)
  739.         {
  740.             // run the default applet in desk.cpl
  741.             SHRunControlPanel( TEXT("desk.cpl"), hwndOwner );
  742.         }
  743.         break;
  745.     case DFM_CMD_MOVE:
  746.     case DFM_CMD_COPY:
  747.         hr = E_FAIL;
  748.         break;
  750.     default:
  751.         //
  752.         // Dispatch Desktop Extended menus (for WebBar)
  753.         //
  754.         if (wparam >= FSIDM_DESKTOPEX_FIRST && wparam <= FSIDM_DESKTOPEX_LAST) 
  755.         {
  756.             if (pdf->_pcmDesktopExt) 
  757.             {
  758.                 CMINVOKECOMMANDINFO cinfo = {
  759.                         SIZEOF(cinfo), 0, hwndOwner,
  760.                         (LPCSTR)wparam-FSIDM_DESKTOPEX_FIRST, NULL, NULL, SW_SHOWNORMAL, 0, NULL };
  761.                 pdf->_pcmDesktopExt->InvokeCommand(&cinfo);
  762.                 pdf->_pcmDesktopExt->Release();
  763.                 pdf->_pcmDesktopExt = NULL;
  764.             }
  765.         }
  767.         // This is common menu items, use the default code.
  768.         hr = S_FALSE;
  769.         break;
  770.     }
  772.     return hr;
  773. }
  775. //
  776. //----------------------------------------------------------------------------
  777. // Helper function for CDesktop_DFMCallBackBG, adds an item for each desktop
  778. // component to the Add Desktop Items popup menu
  779. //
  780. // Returns:
  781. //  TRUE if at least one item was added to the menu
  782. //  FALSE otherwise
  783. //
  784. #define MAX_COMPONENT_WIDTH 40
  785. BOOL CDesktop_AddDesktopComponentsToMenu(HMENU hmenu)
  786. {
  787.     BOOL fRetVal = FALSE;
  788.     IActiveDesktop * piad;
  790.     if (SUCCEEDED(SHCoCreateInstance(NULL, &CLSID_ActiveDesktop, NULL, IID_IActiveDesktop, (void **)&piad)))
  791.     {
  792.         COMPONENTSOPT co;
  793.         co.dwSize = sizeof(co);
  795.         piad->GetDesktopItemOptions(&co, 0);
  797.         if (co.fActiveDesktop && co.fEnableComponents)
  798.         {
  799.             int cComp, i;
  801.             piad->GetDesktopItemCount(&cComp, 0);
  803.             for (i = 0; i < cComp; i++)
  804.             {
  805.                 COMPONENT comp;
  806.                 comp.dwSize = SIZEOF(comp);
  807.     
  808.                 if (SUCCEEDED(piad->GetDesktopItem(i, &comp, 0)))
  809.                 {
  810.                     MENUITEMINFO mii;
  811.                     WCHAR * pwszName;
  812.                     WCHAR wszName[MAX_COMPONENT_WIDTH];
  814.                     // Insert a menu item for this component
  815.                     mii.cbSize = sizeof(MENUITEMINFO);
  816.                     mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
  817.                     mii.fType = MFT_STRING;
  819.                     if (comp.wszFriendlyName[0])
  820.                         pwszName = comp.wszFriendlyName;
  821.                     else
  822.                         pwszName = comp.wszSource;
  824.                     // Truncate if necessary so the menu doesn't get too wide...
  825.                     if (!PathIsFileSpecW(pwszName))
  826.                     {
  827.                         pwszName = PathFindFileNameW(pwszName);
  828.                     }
  830.                     PathCompactPathExW(wszName, pwszName, ARRAYSIZE(wszName), 0);
  832. #ifdef UNICODE
  833.                     mii.cch = lstrlen(wszName);
  834.                     mii.dwTypeData = wszName;
  835. #else
  836.                     {
  837.                         CHAR szName[MAX_COMPONENT_WIDTH];
  839.                         WideCharToMultiByte( CP_ACP, 0, wszName, -1, (LPSTR)szName, ARRAYSIZE(szName), NULL, NULL);
  841.                         mii.cch = lstrlen(szName);
  842.                         mii.dwTypeData = szName;
  843.                     }
  844. #endif
  845.                     mii.wID = i + SFVIDM_DESKTOPHTML_ADDSEPARATOR + 1;
  846.                     mii.fState = comp.fChecked ? MFS_CHECKED : MFS_ENABLED;
  848.                     InsertMenuItem(hmenu, -1, TRUE, &mii);
  850.                     fRetVal = TRUE;
  851.                 }           
  852.             }
  853.         }
  855.         piad->Release();
  856.     } 
  858.     return fRetVal;
  859. }
  861. STDAPI_(HMENU) CDesktop_GetActiveDesktopMenu()
  862. {
  863.     HMENU hmenuAD;
  865.     // Load the menu and make the appropriate modifications
  866.     if (hmenuAD = SHLoadMenuPopup(HINST_THISDLL, POPUP_SFV_BACKGROUND_AD))
  867.     {
  868.         // Get the present settings regarding HTML on desktop
  869.         SHELLSTATE ss;
  870.         SHGetSetSettings(&ss, SSF_DESKTOPHTML | SSF_HIDEICONS, FALSE);
  872.         if (!ss.fDesktopHTML)
  873.         {
  874.             DeleteMenu(hmenuAD, SFVIDM_DESKTOPHTML_ICONS, MF_BYCOMMAND);
  875.             DeleteMenu(hmenuAD, SFVIDM_DESKTOPHTML_LOCK, MF_BYCOMMAND);
  876.             DeleteMenu(hmenuAD, SFVIDM_DESKTOPHTML_SYNCHRONIZE, MF_BYCOMMAND);
  877.             DeleteMenu(hmenuAD, SFVIDM_DESKTOPHTML_ADDSEPARATOR, MF_BYCOMMAND);
  878.         }
  879.         else
  880.         {
  881.             CheckMenuItem(hmenuAD, SFVIDM_DESKTOPHTML_WEBCONTENT, MF_BYCOMMAND | MF_CHECKED);
  883.             if(SHRestricted(REST_FORCEACTIVEDESKTOPON))
  884.                 EnableMenuItem(hmenuAD, SFVIDM_DESKTOPHTML_WEBCONTENT, MF_BYCOMMAND | MF_GRAYED);
  886.             if (!ss.fHideIcons)
  887.                 CheckMenuItem(hmenuAD, SFVIDM_DESKTOPHTML_ICONS, MF_BYCOMMAND | MF_CHECKED);
  889.             if (GetDesktopFlags() & COMPONENTS_LOCKED)
  890.                 CheckMenuItem(hmenuAD, SFVIDM_DESKTOPHTML_LOCK, MF_BYCOMMAND | MF_CHECKED);
  892.             if (SHRestricted(REST_NOADDDESKCOMP) || SHRestricted(REST_NODESKCOMP))
  893.                 EnableMenuItem(hmenuAD, SFVIDM_DESKTOPHTML_NEWITEM, MF_BYCOMMAND | MF_GRAYED);
  895.             // Add a menu item to the "Add Desktop Item" popup for each Desktop Component installed
  896.             if (SHRestricted(REST_NOCLOSEDESKCOMP) || SHRestricted(REST_NODESKCOMP) || !CDesktop_AddDesktopComponentsToMenu(hmenuAD))
  897.                 DeleteMenu(hmenuAD, SFVIDM_DESKTOPHTML_ADDSEPARATOR, MF_BYCOMMAND);
  898.         }
  900.     }
  902.     return hmenuAD;
  903. }
  905. // static const QCMINFO_IDMAP 
  906. static const struct {
  907.     UINT max;
  908.     struct {
  909.         UINT id;
  910.         UINT fFlags;
  911.     } list[2];
  912. } idMap = {
  913.     2, {
  914.         {FSIDM_FOLDER_SEP, QCMINFO_PLACE_BEFORE},
  915.         {FSIDM_VIEW_SEP, QCMINFO_PLACE_AFTER},
  916.     },
  917. };
  919. // background context menu callback
  920. //
  921. // Returns:
  922. //      NOERROR, if successfully processed.
  923. //      S_FALSE, if default code should be used.
  925. HRESULT CDesktop_DFMCallBackBG(IShellFolder *psf, HWND hwnd, IDataObject *pdtobj, UINT uMsg, WPARAM wParam, LPARAM lParam)
  926. {
  927.     HRESULT hr = NOERROR;
  930.     CDesktopFolder *pdf;
  931.     psf->QueryInterface(CLSID_ShellDesktop, (void **)&pdf);
  933.     ASSERT(pdf);
  935.     switch(uMsg)
  936.     {
  937.     case DFM_MERGECONTEXTMENU:
  938.         if (!(wParam & CMF_VERBSONLY))
  939.         {
  940.             HRESULT hresT;
  941.             UINT idCmdFirst;
  942.             LPQCMINFO pqcm;
  943.             BOOL bDesktop = FALSE;
  945.             // If desktop is in ExtendedView, then the hwnd we get for
  946.             // the context menu is a child of the Desktop.
  947.             while (hwnd)
  948.             {
  949.                 bDesktop = CDesktop_IsDesktop(hwnd);
  950.                 if (bDesktop)
  951.                     break;
  952.                 hwnd = GetParent(hwnd);
  953.             }
  955.             pqcm = (LPQCMINFO)lParam;
  957.             // This needs to be saved before MergeMenu
  958.             idCmdFirst = pqcm->idCmdFirst;
  959.             pqcm->pIdMap = (QCMINFO_IDMAP *)&idMap;
  961.             // HACK: Note the Desktop and FSView menus are the same
  962.             CDefFolderMenu_MergeMenu(HINST_THISDLL, POPUP_FSVIEW_BACKGROUND,
  963.                 POPUP_FSVIEW_POPUPMERGE, pqcm);
  965.             if (bDesktop)
  966.             {
  967.                 TCHAR szMenu[60];
  969.                 // HACK: We only want LargeIcons on the real desktop
  970.                 // so we remove the View menu
  971.                 DeleteMenu(pqcm->hmenu, SFVIDM_MENU_VIEW, MF_BYCOMMAND);
  973.                 // No Choose Columns either
  974.                 DeleteMenu(pqcm->hmenu, SFVIDM_VIEW_COLSETTINGS, MF_BYCOMMAND);
  976.                 // Only put on ActiveDesktop menu item if it isn't restricted.
  977.                 if ((SHRestricted(REST_FORCEACTIVEDESKTOPON) || (!SHRestricted(REST_NOACTIVEDESKTOP) && !SHRestricted(REST_CLASSICSHELL)))
  978.                     && !SHRestricted(REST_NOACTIVEDESKTOPCHANGES))
  979.                 {
  980.                     HMENU hmenuAD;
  981.                     MENUITEMINFO mii;
  983.                     if (hmenuAD = CDesktop_GetActiveDesktopMenu())
  984.                     {
  985.                         // Insert Active Desktop submenu at the top
  986.                         mii.cbSize = sizeof(MENUITEMINFO);
  987.                         mii.fMask = MIIM_SUBMENU | MIIM_TYPE;
  988.                         mii.fType = MFT_STRING;
  989.                         mii.hSubMenu = hmenuAD;
  990.                         mii.cch = LoadString(HINST_THISDLL, IDS_ACTIVEDESKTOP, szMenu, ARRAYSIZE(szMenu));
  991.                         mii.dwTypeData = szMenu;
  992.                         InsertMenuItem(pqcm->hmenu, 0, TRUE, &mii);
  993.                     }
  994.                 }
  996.                 // Give a chance to add menuitem(s) to the extended menu object.
  997.                 //
  998.                 ASSERT(pqcm->idCmdFirst < idCmdFirst+FSIDM_DESKTOPEX_FIRST);
  999.                 ASSERT(pqcm->idCmdLast >= idCmdFirst+FSIDM_DESKTOPEX_LAST);
  1001.                 if (!pdf->_pcmDesktopExt)
  1002.                     hresT = _GetDesktopExtMenu(hwnd, &pdf->_pcmDesktopExt);
  1004.                 if (pdf->_pcmDesktopExt)
  1005.                 {
  1006.                     hresT = pdf->_pcmDesktopExt->QueryContextMenu(
  1007.                                 pqcm->hmenu, 0,
  1008.                                 idCmdFirst+FSIDM_DESKTOPEX_FIRST,
  1009.                                 idCmdFirst+FSIDM_DESKTOPEX_LAST,
  1010.                                 0);
  1011.                     if (SUCCEEDED(hresT))
  1012.                     {
  1013.                         pqcm->idCmdFirst = idCmdFirst + FSIDM_DESKTOPEX_FIRST + HRESULT_CODE(hresT);
  1014.                     }
  1015.                     else
  1016.                     {
  1017.                         DebugMsg(DM_ERROR, TEXT("WebBar: QueryContextMenu failed %x"), hresT);
  1018.                     }
  1019.                 }
  1020.             }
  1021.             else
  1022.             {
  1023.                 // HACK: We want no Properties for DesktopInExplorer
  1024.                 DeleteMenu(pqcm->hmenu, FSIDM_PROPERTIESBG+idCmdFirst, MF_BYCOMMAND);
  1025.             }
  1026.         }
  1027.         break;
  1029.     case DFM_GETHELPTEXT:
  1030.         LoadStringA(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPSTR)lParam, HIWORD(wParam));;
  1031.         break;
  1033.     case DFM_GETHELPTEXTW:
  1034.         LoadStringW(HINST_THISDLL, LOWORD(wParam) + IDS_MH_FSIDM_FIRST, (LPWSTR)lParam, HIWORD(wParam));;
  1035.         break;
  1037.     case DFM_INVOKECOMMAND:
  1038.     case DFM_VALIDATECMD:
  1039.         hr = CDesktop_HandleCommand(pdf, hwnd, wParam, uMsg == DFM_INVOKECOMMAND);
  1040.         break;
  1042.     default:
  1043.         hr = E_NOTIMPL;
  1044.         break;
  1045.     }
  1047.     return hr;
  1048. }
  1050. STDMETHODIMP CDesktopFolder::CreateViewObject(HWND hwnd, REFIID riid, void **ppvOut)
  1051. {
  1052.     HRESULT hr;
  1054.     if (IsEqualIID(riid, IID_IShellView))
  1055.     {
  1056.         SFV_CREATE sSFV;
  1058.         sSFV.cbSize   = sizeof(sSFV);
  1059.         sSFV.psvOuter = NULL;
  1060.         sSFV.psfvcb   = Desktop_CreateSFVCB(this);
  1062.         QueryInterface(IID_IShellFolder, (void **)&sSFV.pshf);   // in case we are agregated
  1064.         hr = SHCreateShellFolderView(&sSFV, (IShellView**)ppvOut);
  1066.         if (sSFV.pshf)
  1067.             sSFV.pshf->Release();
  1069.         if (sSFV.psfvcb)
  1070.             sSFV.psfvcb->Release();
  1071.     }
  1072.     else if (IsEqualIID(riid, IID_IDropTarget) && _psfDesktop)
  1073.     {
  1074.         hr = _psfDesktop->CreateViewObject(hwnd, riid, ppvOut);
  1075.     }
  1076.     else if (IsEqualIID(riid, IID_IContextMenu))
  1077.     {
  1078.         IShellFolder *psfTemp;
  1079.         hr = QueryInterface(IID_IShellFolder, (void **)&psfTemp);
  1080.         if (SUCCEEDED(hr))
  1081.         {
  1082.             HKEY hkNoFiles = NULL;
  1084.             RegOpenKey(HKEY_CLASSES_ROOT, TEXT("Directory\Background"), &hkNoFiles);
  1086.             hr = CDefFolderMenu_Create2(&c_idlDesktop, hwnd, 0, NULL,
  1087.                     psfTemp, CDesktop_DFMCallBackBG,
  1088.                     1, &hkNoFiles, (IContextMenu **)ppvOut);
  1089.             psfTemp->Release();
  1090.             RegCloseKey(hkNoFiles);
  1091.         }
  1092.     }
  1093.     else
  1094.     {
  1095.         *ppvOut = NULL;
  1096.         hr = E_NOINTERFACE;
  1097.     }
  1098.     return hr;
  1099. }
  1101. STDMETHODIMP CDesktopFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST *apidl, ULONG *rgfOut)
  1102. {
  1103.     if (IsSelf(cidl, apidl))
  1104.     {
  1105.         // the desktop's attributes
  1106.         *rgfOut &= SFGAO_FOLDER | SFGAO_FILESYSTEM | SFGAO_CANRENAME | SFGAO_CANMONIKER |
  1107.             SFGAO_HASSUBFOLDER | SFGAO_HASPROPSHEET | SFGAO_FILESYSANCESTOR;
  1108.         return NOERROR;
  1109.     }
  1111.     IShellFolder2 *psf = _GetItemFolder(apidl[0]);
  1112.     if (psf)
  1113.         return psf->GetAttributesOf(cidl, apidl, rgfOut);
  1114.     return E_UNEXPECTED;
  1115. }
  1117. HRESULT CDesktopFolder::_GetItemUIObject(HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl,
  1118.                                          REFIID riid, UINT *prgfInOut, void **ppvOut)
  1119. {
  1120.     IShellFolder2 *psf = _GetItemFolder(apidl[0]);
  1121.     if (psf)
  1122.         return psf->GetUIObjectOf(hwnd, cidl, apidl, riid, prgfInOut, ppvOut);
  1123.     return E_UNEXPECTED;
  1124. }
  1126. STDMETHODIMP CDesktopFolder::GetUIObjectOf(HWND hwnd, UINT cidl, LPCITEMIDLIST *apidl,
  1127.                                     REFIID riid, UINT *prgfInOut, void **ppvOut)
  1128. {
  1129.     HRESULT hr = E_NOINTERFACE;
  1130.     
  1131.     *ppvOut = NULL;
  1133.     if (IsSelf(cidl, apidl))
  1134.     {
  1135.         // for the desktop itself
  1136.         if (IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) 
  1137.         {
  1138.             hr = SHCreateDefExtIcon(NULL, II_DESKTOP, II_DESKTOP, GIL_PERCLASS, riid, ppvOut);
  1139.         }
  1140.         else if (IsEqualIID(riid, IID_IQueryInfo))
  1141.         {
  1142.             hr = CreateInfoTipFromText(MAKEINTRESOURCE(IDS_DESKTOP), riid, ppvOut); //The InfoTip COM object
  1143.         }
  1144.     }
  1145.     else
  1146.     {
  1147.         if (IsEqualIID(riid, IID_IContextMenu))
  1148.         {
  1149.             hr = _GetItemUIObject(hwnd, cidl, apidl, riid, prgfInOut, ppvOut);
  1150.         }
  1151.         else if (IsEqualIID(riid, IID_IDataObject) && cidl)
  1152.         {
  1153.             if (cidl == 1)
  1154.             {
  1155.                 hr = _GetItemUIObject(hwnd, cidl, apidl, riid, prgfInOut, ppvOut);
  1156.             }
  1157.             else
  1158.             {
  1159.                 LPITEMIDLIST *ppidl, pidlAlt;
  1161.                 SHGetIDListFromUnk((IUnknown*)_psfAltDesktop, &pidlAlt);
  1162.             
  1163.                 ppidl = (LPITEMIDLIST *)LocalAlloc(LPTR, sizeof(LPITEMIDLIST) * cidl);
  1164.                 if (ppidl)
  1165.                 {
  1166.                     for (UINT i = 0; i < cidl; i++) 
  1167.                     {
  1168.                         if (pidlAlt && FS_IsCommonItem(apidl[i])) 
  1169.                             ppidl[i] = ILCombine(pidlAlt, apidl[i]);
  1170.                         else 
  1171.                             ppidl[i] = ILClone(apidl[i]);
  1172.                     }
  1173.             
  1174.                     hr = CFSFolder_CreateDataObject(&c_idlDesktop, cidl, (LPCITEMIDLIST *)ppidl, (IDataObject **)ppvOut);
  1175.             
  1176.                     for (i = 0; i < cidl; i++)
  1177.                         ILFree(ppidl[i]);
  1178.             
  1179.                     LocalFree(ppidl);
  1180.                 }
  1181.                 else
  1182.                     hr = E_OUTOFMEMORY;
  1184.                 if (pidlAlt)
  1185.                     ILFree(pidlAlt);
  1186.             }
  1187.         }
  1188.         else
  1189.         {
  1190.             hr = _GetItemUIObject(hwnd, cidl, apidl, riid, prgfInOut, ppvOut);
  1191.         }
  1192.     }
  1193.     return hr;
  1194. }
  1196. STDMETHODIMP CDesktopFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD dwFlags, STRRET *pStrRet)
  1197. {
  1198.     HRESULT hr;
  1200.     if (IsSelf(1, &pidl))
  1201.     {
  1202.         if ((dwFlags & (SHGDN_FORPARSING | SHGDN_INFOLDER | SHGDN_FORADDRESSBAR)) == SHGDN_FORPARSING)
  1203.         {
  1204.             // note some ISV apps puke if we return a full name here but the
  1205.             // rest of the shell depends on this...
  1206.             TCHAR szPath[MAX_PATH];
  1207.             SHGetFolderPath(NULL, CSIDL_DESKTOPDIRECTORY, NULL, 0, szPath);
  1208.             hr = StringToStrRet(szPath, pStrRet);
  1209.         }
  1210.         else
  1211.             hr = ResToStrRet(IDS_DESKTOP, pStrRet);   // display name, "Desktop"
  1212.     }
  1213.     else
  1214.     {
  1215.         IShellFolder2 *psf = _GetItemFolder(pidl);
  1216.         if (psf)
  1217.             hr = psf->GetDisplayNameOf(pidl, dwFlags, pStrRet);
  1218.         else
  1219.             hr = E_UNEXPECTED;
  1220.     }
  1221.     return hr;
  1222. }
  1224. STDMETHODIMP CDesktopFolder::SetNameOf(HWND hwnd, LPCITEMIDLIST pidl, 
  1225.                                        LPCOLESTR pszName, DWORD dwRes, LPITEMIDLIST *ppidlOut)
  1226. {
  1227.     IShellFolder2 *psf = _GetItemFolder(pidl);
  1228.     if (psf)
  1229.         return psf->SetNameOf(hwnd, pidl, pszName, dwRes, ppidlOut);
  1230.     return E_UNEXPECTED;
  1231. }
  1233. STDMETHODIMP CDesktopFolder::GetDefaultSearchGUID(GUID *pGuid)
  1234. {
  1235.     return E_NOTIMPL;
  1236. }   
  1238. STDMETHODIMP CDesktopFolder::EnumSearches(LPENUMEXTRASEARCH *ppenum)
  1239. {
  1240.     *ppenum = NULL;
  1241.     return E_NOTIMPL;
  1242. }
  1244. STDMETHODIMP CDesktopFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
  1245. {
  1246.     if (_psfDesktop)
  1247.         return _psfDesktop->GetDefaultColumn(dwRes, pSort, pDisplay);
  1248.     return E_UNEXPECTED;
  1249. }
  1251. STDMETHODIMP CDesktopFolder::GetDefaultColumnState(UINT iColumn, DWORD *pdwState)
  1252. {
  1253.     if (_psfDesktop)
  1254.         return _psfDesktop->GetDefaultColumnState(iColumn, pdwState);
  1255.     return E_UNEXPECTED;
  1256. }
  1258. STDMETHODIMP CDesktopFolder::GetDetailsEx(LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
  1259. {
  1260.     IShellFolder2 *psf = _GetItemFolder(pidl);
  1261.     if (psf)
  1262.         return psf->GetDetailsEx(pidl, pscid, pv);
  1263.     return E_UNEXPECTED;
  1264. }
  1266. STDMETHODIMP CDesktopFolder::GetDetailsOf(LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *pDetails)
  1267. {
  1268.     IShellFolder2 *psf = _GetItemFolder(pidl);
  1269.     if (psf)
  1270.         return psf->GetDetailsOf(pidl, iColumn, pDetails);
  1271.     return E_UNEXPECTED;
  1272. }
  1274. STDMETHODIMP CDesktopFolder::MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid)
  1275. {
  1276.     if (_psfDesktop)
  1277.         return _psfDesktop->MapColumnToSCID(iColumn, pscid);
  1278.     return E_UNEXPECTED;
  1279. }
  1281. STDMETHODIMP CDesktopFolder::GetClassID(CLSID *pCLSID)
  1282. {
  1283.     *pCLSID = CLSID_ShellDesktop;
  1284.     return NOERROR;
  1285. }
  1287. STDMETHODIMP CDesktopFolder::Initialize(LPCITEMIDLIST pidl)
  1288. {
  1289.     return ILIsEmpty(pidl) ? S_OK : E_INVALIDARG;
  1290. }
  1292. STDMETHODIMP CDesktopFolder::GetCurFolder(LPITEMIDLIST *ppidl)
  1293. {
  1294.     return GetCurFolderImpl(&c_idlDesktop, ppidl);
  1295. }
  1297. STDMETHODIMP CDesktopFolder::GetIconOf(LPCITEMIDLIST pidl, UINT flags, int *piIndex)
  1298. {
  1299.     IShellIcon *psi;
  1300.     HRESULT hr = _QueryInterfaceItem(pidl, IID_IShellIcon, (void **)&psi);
  1301.     if (SUCCEEDED(hr))
  1302.     {
  1303.         hr = psi->GetIconOf(pidl, flags, piIndex);
  1304.         psi->Release();
  1305.     }
  1306.     return hr;
  1307. }
  1309. STDMETHODIMP CDesktopFolder::GetOverlayIndex(LPCITEMIDLIST pidl, int *pIndex)
  1310. {
  1311.     IShellIconOverlay *psio;
  1312.     HRESULT hr = _QueryInterfaceItem(pidl, IID_IShellIconOverlay, (void **)&psio);
  1313.     if (SUCCEEDED(hr))
  1314.     {
  1315.         hr = psio->GetOverlayIndex(pidl, pIndex);
  1316.         psio->Release();
  1317.     }
  1318.     return hr;
  1319. }
  1321. STDMETHODIMP CDesktopFolder::GetOverlayIconIndex(LPCITEMIDLIST pidl, int *pIconIndex)
  1322. {
  1323.     IShellIconOverlay *psio;
  1324.     HRESULT hr = _QueryInterfaceItem(pidl, IID_IShellIconOverlay, (void **)&psio);
  1325.     if (SUCCEEDED(hr))
  1326.     {
  1327.         hr = psio->GetOverlayIconIndex(pidl, pIconIndex);
  1328.         psio->Release();
  1329.     }
  1330.     return hr;
  1331. }
  1333. //
  1334. // we only care about events that actually change the enumeration
  1335. // so updateimage and the like we don't care about
  1336. //
  1337. STDAPI_(void) Desktop_InvalidateEnumCache(LPCITEMIDLIST pidl, LONG lEvent)
  1338. {
  1339.     if (pidl) 
  1340.     {
  1341.         if (ILIsEmpty(pidl)) 
  1342.         {
  1343.             if (lEvent & SHCNE_DISKEVENTS) 
  1344.             {
  1345.                 // change on the desktop itself
  1346.                 // invalidate all
  1347.                 SFEnumCache_Invalidate(&g_EnumCache, ENUMGRFFLAGS);
  1348.             }
  1349.         } 
  1350.         else if (ILIsEmpty(_ILNext(pidl))) 
  1351.         {
  1352.             // if it's the direct child of the desktop...
  1354.             if (lEvent & (SHCNE_RENAMEITEM | SHCNE_CREATE | SHCNE_DELETE))
  1355.                 SFEnumCache_Invalidate(&g_EnumCache, SHCONTF_INCLUDEHIDDEN | SHCONTF_NONFOLDERS);
  1356.             else if (lEvent & (SHCNE_RENAMEFOLDER | SHCNE_MKDIR | SHCNE_RMDIR))
  1357.                 SFEnumCache_Invalidate(&g_EnumCache, SHCONTF_INCLUDEHIDDEN | SHCONTF_FOLDERS);
  1358.             else if (lEvent & SHCNE_UPDATEITEM)
  1359.                 SFEnumCache_Invalidate(&g_EnumCache, SHCONTF_INCLUDEHIDDEN | SHCONTF_FOLDERS | SHCONTF_NONFOLDERS);
  1360.         }
  1361.     }
  1362. }
  1365. // Sets *ppidl to the proper pidl to notify and
  1366. // returns TRUE iff pidl is a desktop/commondesktop item.
  1367. // In the commondesktop case, it munges the pidl and stores the newly allocated pidl in ppidlTemp
  1368. BOOL CDesktop_FSEventHelper(LPITEMIDLIST pidfDesktop, LPITEMIDLIST pidfCommonDesktop, LPCITEMIDLIST pidl, LPITEMIDLIST * ppidl, LPITEMIDLIST * ppidlTemp)
  1369. {
  1370.     BOOL fResend;
  1372.     if (NULL != (*ppidl = ILFindChild(pidfDesktop, pidl))) 
  1373.     {
  1374.         fResend = TRUE;
  1375.     } 
  1376.     else if (NULL != (*ppidl = ILFindChild(pidfCommonDesktop, pidl))) 
  1377.     {
  1378.         fResend = TRUE;
  1380.         if (!ILIsEmpty(*ppidl)) 
  1381.         {
  1382.             *ppidlTemp = ILClone(*ppidl);
  1383.             if (*ppidlTemp) 
  1384.             {
  1385.                 FS_MakeCommonItem(*ppidlTemp);
  1386.                 *ppidl = *ppidlTemp;
  1387.             }
  1388.         }
  1389.     } 
  1390.     else
  1391.     {
  1392.         fResend = FALSE;
  1394.         *ppidl = (LPITEMIDLIST)pidl;
  1395.     }
  1397.     return fResend;
  1398. }
  1400. class CDesktopViewCallBack : public CBaseShellFolderViewCB
  1401. {
  1402. public:
  1403.     CDesktopViewCallBack(CDesktopFolder* pdf);
  1404.     STDMETHODIMP RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam);
  1406. private:
  1407.     CDesktopFolder* _pdf;
  1409.     HRESULT OnMERGEMENU(DWORD pv, QCMINFO*lP)
  1410.     {
  1411.         CDefFolderMenu_MergeMenu(HINST_THISDLL, 0, POPUP_FSVIEW_POPUPMERGE, lP);
  1412.         return S_OK;
  1413.     }
  1415.     HRESULT OnINVOKECOMMAND(DWORD pv, UINT wP)
  1416.     {
  1417.         return CDesktop_DFMCallBackBG(m_pshf, m_hwndMain, NULL, DFM_INVOKECOMMAND, wP, 0);
  1418.     }
  1420.     HRESULT OnSupportsIdentity(DWORD pv)
  1421.     {
  1422.         return S_OK;
  1423.     }
  1425.     HRESULT OnGETHELPTEXT(DWORD pv, UINT wPl, UINT wPh, LPTSTR lP)
  1426.     {
  1427. #ifdef UNICODE
  1428.         return CDesktop_DFMCallBackBG(m_pshf, m_hwndMain, NULL, DFM_GETHELPTEXTW, MAKEWPARAM(wPl, wPh), (LPARAM)lP);
  1429. #else
  1430.         return CDesktop_DFMCallBackBG(m_pshf, m_hwndMain, NULL, DFM_GETHELPTEXT, MAKEWPARAM(wPl, wPh), (LPARAM)lP);
  1431. #endif
  1432.     }
  1434.     HRESULT OnGETCCHMAX(DWORD pv, LPCITEMIDLIST pidlItem, UINT *lP)
  1435.     {
  1436.         if (SIL_GetType(pidlItem) == SHID_ROOT_REGITEM) // evil, we should not have to know this
  1437.         {
  1438.             *lP = MAX_REGITEMCCH;
  1439.             return NOERROR;
  1440.         }
  1441.         else
  1442.         {
  1443.             IShellFolder2 *psf = _pdf->_GetItemFolder(pidlItem);
  1444.             if (psf)
  1445.             {
  1446.                 CFSFolder *pfsf = FS_GetFSFolderFromShellFolder(psf);
  1447.                 return CFSFolder_GetCCHMax(pfsf, FS_IsValidID(pidlItem), lP);
  1448.             }
  1449.         }
  1450.         return E_FAIL;
  1451.     }
  1453.     HRESULT OnGetViews(DWORD pv, SHELLVIEWID *pvid, IEnumSFVViews **ppObj);
  1455.     HRESULT OnGetWorkingDir(DWORD pv, UINT wP, LPTSTR pszDir)
  1456.     {
  1457.         return SHGetSpecialFolderPath(NULL, pszDir, CSIDL_DESKTOPDIRECTORY, TRUE) ? S_OK : E_FAIL;
  1458.     }
  1459. };
  1462. #define DESKTOP_EVENTS 
  1463.     SHCNE_DISKEVENTS | 
  1464.     SHCNE_ASSOCCHANGED | 
  1465.     SHCNE_NETSHARE | 
  1466.     SHCNE_NETUNSHARE
  1468. CDesktopViewCallBack::CDesktopViewCallBack(CDesktopFolder* pdf) : 
  1469.     CBaseShellFolderViewCB(SAFECAST(pdf, IShellFolder *), (LPCITEMIDLIST)&c_idlDesktop, DESKTOP_EVENTS),
  1470.     _pdf(pdf)
  1471. { 
  1473. }
  1475. IShellFolderViewCB* Desktop_CreateSFVCB(CDesktopFolder* pdf)
  1476. {
  1477.     return new CDesktopViewCallBack(pdf);
  1478. }
  1481. HRESULT CDesktopViewCallBack::OnGetViews(DWORD pv, SHELLVIEWID *pvid, IEnumSFVViews **ppObj)
  1482. {
  1483.     *ppObj = NULL;
  1485.     CViewsList cViews;
  1487.     // Add base class stuff
  1488.     cViews.AddReg(HKEY_CLASSES_ROOT, TEXT("folder"));
  1490.     // Add 2nd base class stuff
  1491.     cViews.AddReg(HKEY_CLASSES_ROOT, TEXT("directory"));
  1493.     IBrowserService2* pbs;
  1494.     if (SUCCEEDED(IUnknown_QueryService(_punkSite, SID_SShellDesktop, IID_IUnknown, (void**)&pbs)))
  1495.     {   // It's the actual desktop
  1496.         pbs->Release();
  1497.         // Add this class stuff
  1498.         cViews.AddCLSID(&CLSID_ShellDesktop);
  1499.     }
  1500.     else    // Don't add the desktop.ini stuff for the actual desktop. Add it only if we are in folder view
  1501.     {
  1502.         TCHAR szHere[MAX_PATH];
  1503.         if (SHGetPathFromIDList(m_pidl, szHere))
  1504.         {
  1505.             TCHAR szIniFile[MAX_PATH];
  1506.             PathCombine(szIniFile, szHere, c_szDesktopIni);
  1507.             cViews.AddIni(szIniFile, szHere);
  1508.         }
  1509.     }
  1511.     cViews.GetDef(pvid);
  1513.     return CreateEnumCViewList(&cViews, ppObj);
  1515.     // Note the automatic destructor will free any views still left
  1516. }
  1519. STDMETHODIMP CDesktopViewCallBack::RealMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
  1520. {
  1521.     switch (uMsg)
  1522.     {
  1523.     HANDLE_MSG(0, SFVM_MERGEMENU, OnMERGEMENU);
  1524.     HANDLE_MSG(0, SFVM_INVOKECOMMAND, OnINVOKECOMMAND);
  1525.     HANDLE_MSG(0, SFVM_SUPPORTSIDENTITY, OnSupportsIdentity);
  1526.     HANDLE_MSG(0, SFVM_GETHELPTEXT, OnGETHELPTEXT);
  1527.     HANDLE_MSG(0, SFVM_GETCCHMAX, OnGETCCHMAX);
  1528.     HANDLE_MSG(0, SFVM_GETVIEWS, OnGetViews);
  1529.     HANDLE_MSG(0, SFVM_GETWORKINGDIR, OnGetWorkingDir);
  1531.     default:
  1532.         return E_FAIL;
  1533.     }
  1535.     return NOERROR;
  1536. }
  1538. CDesktopFolderEnum::CDesktopFolderEnum(CDesktopFolder *pdf, HWND hwnd, DWORD grfFlags) : 
  1539.     _cRef(1), _bUseAltEnum(FALSE)
  1540. {
  1541.     if (pdf->_psfDesktop)
  1542.         pdf->_psfDesktop->EnumObjects(hwnd, grfFlags, &_penumFolder);
  1544.     if (pdf->_psfAltDesktop) 
  1545.         pdf->_psfAltDesktop->EnumObjects(hwnd, grfFlags, &_penumAltFolder);
  1546. }
  1548. CDesktopFolderEnum::~CDesktopFolderEnum()
  1549. {
  1550.     if (_penumFolder)
  1551.         _penumFolder->Release();
  1553.     if (_penumAltFolder)
  1554.         _penumAltFolder->Release();
  1555. }
  1557. STDMETHODIMP CDesktopFolderEnum::QueryInterface(REFIID riid, void **ppv)
  1558. {
  1559.     static const QITAB qit[] = {
  1560.         QITABENT(CDesktopFolderEnum, IEnumIDList),                        // IID_IEnumIDList
  1561.         { 0 },
  1562.     };
  1563.     return QISearch(this, qit, riid, ppv);
  1564. }
  1566. STDMETHODIMP_(ULONG) CDesktopFolderEnum::AddRef()
  1567. {
  1568.     return InterlockedIncrement(&_cRef);
  1569. }
  1571. STDMETHODIMP_(ULONG) CDesktopFolderEnum::Release()
  1572. {
  1573.     if (InterlockedDecrement(&_cRef))
  1574.         return _cRef;
  1576.     delete this;
  1577.     return 0;
  1578. }
  1580. STDMETHODIMP CDesktopFolderEnum::Next(ULONG celt, LPITEMIDLIST *ppidl, ULONG *pceltFetched)
  1581. {
  1582.     HRESULT hr;
  1584.     if (_bUseAltEnum)
  1585.     {
  1586.        if (_penumAltFolder) 
  1587.        {
  1588.            hr = _penumAltFolder->Next(celt, ppidl, pceltFetched);
  1589.            if (S_OK == hr)
  1590.            {
  1591.                ULONG i, iCount = pceltFetched ? *pceltFetched : 1;
  1592.                for (i = 0; i < iCount; i++)
  1593.                    FS_MakeCommonItem(ppidl[i]);
  1594.            }
  1595.        }
  1596.        else
  1597.            hr = S_FALSE;
  1598.     } 
  1599.     else if (_penumFolder)
  1600.     {
  1601.        hr = _penumFolder->Next(celt, ppidl, pceltFetched);
  1602.        if (S_OK != hr) 
  1603.        {
  1604.            _bUseAltEnum = TRUE;
  1605.            hr = Next(celt, ppidl, pceltFetched);  // recurse
  1606.        }
  1607.     }
  1608.     else
  1609.     {
  1610.         hr = S_FALSE;
  1611.     }
  1613.     if (hr == S_FALSE)
  1614.     {
  1615.         *ppidl = NULL;
  1616.         if (pceltFetched)
  1617.             *pceltFetched = 0;
  1618.     }
  1620.     return hr;
  1621. }
  1624. STDMETHODIMP CDesktopFolderEnum::Skip(ULONG celt) 
  1625. {
  1626.     return E_NOTIMPL;
  1627. }
  1629. STDMETHODIMP CDesktopFolderEnum::Reset() 
  1630. {
  1631.     if (_penumFolder)
  1632.         _penumFolder->Reset();
  1634.     if (_penumAltFolder)
  1635.         _penumAltFolder->Reset();
  1637.     _bUseAltEnum = FALSE;
  1638.     return S_OK;
  1639. }
  1641. STDMETHODIMP CDesktopFolderEnum::Clone(IEnumIDList **ppenum) 
  1642. {
  1643.     *ppenum = NULL;
  1644.     return E_NOTIMPL;
  1645. }