Category

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

Windows Kernel

Development Platform:

Visual C++

folder.cpp：Code Content
  1. #include "pch.h"
  2. #include "iids.h"
  3. #pragma hdrstop
  6. /*-----------------------------------------------------------------------------
  7. / Column information used by the shell to Detail view mode.
  8. /----------------------------------------------------------------------------*/
  10. //
  11. // column information
  12. //
  14. const struct
  15. {
  16.     UINT idString;              // resource ID for the column title
  17.     INT  fmt;                   // formatting flags of the column
  18.     INT  cxChar;                // average char with of this column
  19. }
  20. columns[] =
  21. {
  22.     IDS_OBJECTNAME, LVCFMT_LEFT, 64,                // DSVMID_ARRANGEBYNAME
  23.     IDS_TYPE,       LVCFMT_LEFT, 32,                // DSVMID_ARRANGEBYCLASS
  24. };
  26. //
  27. // CDsFolder
  28. //
  30. #define NAMESPACE_ATTRIBUTES (SFGAO_FOLDER|SFGAO_FILESYSANCESTOR|SFGAO_HASSUBFOLDER|SFGAO_CANLINK)
  32. class CDsFolder : public IDsFolderInternalAPI, IPersistFolder2, IDelegateFolder, IShellFolder, CUnknown
  33. {
  34.     friend HRESULT _GetDetailsOf(CDsFolder *pdf, PDETAILSINFO pDetails, UINT iColumn);
  35.     friend HRESULT _MergeArrangeMenu(CDsFolder *pdf, LPARAM arrangeParam, LPQCMINFO pInfo);
  37.     private:
  38.         CLSID             _clsidNamespace;          // where in the registry to look for our configuration
  40.         LPITEMIDLIST      _pidl;                    // absolute IDLIST to our object
  41.         INT               _cbOffset;                // offset to start of ds elements
  42.         LPTSTR            _pPrettyPath;             // prettified version of the folder path
  44.         LPWSTR            _pAttribPrefix;           // attribute prefix (set via internal API)
  45.         DWORD             _dwProviderAND;           // extra AND for the provider flags
  46.         DWORD             _dwProviderXOR;           // extra XOR for the provider flags
  48.         LPWSTR            _pServer;                 // server
  49.         LPWSTR            _pUserName;               // user name 
  50.         LPWSTR            _pPassword;               // password
  52.         HRESULT           _hresCoInit;              // did we do a CoInitialize?
  53.         IADsPathname      *_padp;                   // IADsPathname iface for name cracking
  54.         IDsDisplaySpecifier *_pdds;                 // IDsDisplaySpecifier for DsXXX APIs
  55.         IMalloc           *_pm;                     // IMalloc used for delegate folder support
  57.     private:
  58.         HRESULT _RealInitialize(LPCITEMIDLIST pidlRoot, LPCITEMIDLIST pidlBindTo, INT cbOffset);
  59.         BOOL    _InitCOM(void);
  60.         HRESULT _GetPathname(void);
  61.         HRESULT _GetDsDisplaySpecifier(void);
  62.         HRESULT _GetJunction(LPITEMIDLIST pidl, LPITEMIDLIST *ppidlRight, IDLISTDATA *pData);
  63.         HRESULT _GetJunctionSF(LPITEMIDLIST pidlFull, IBindCtx *pbc, IDLISTDATA *pData, LPITEMIDLIST *ppidlRight, IShellFolder **ppsf);
  64.         HRESULT _TryToParsePath(LPITEMIDLIST* ppidl, IADsPathname *padp, LPWSTR pObjectClass, LPDOMAINTREE pDomainTree);
  65.         HRESULT _SetDispSpecOptions(IDataObject *pdo);
  67.     public:
  68.         CDsFolder();
  69.         ~CDsFolder();
  71.         // IUnknown
  72.         STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
  73.         STDMETHOD_(ULONG, AddRef)();
  74.         STDMETHOD_(ULONG, Release)();
  76.         // IDsFolderInternalAPI
  77.         STDMETHOD(SetAttributePrefix)(LPWSTR pAttributePrefix);
  78.         STDMETHOD(SetProviderFlags)(DWORD dwAND, DWORD dwXOR);
  79.         STDMETHOD(SetComputer)(LPCWSTR pszComputerName, LPCWSTR pszUserName, LPCWSTR pszPassword);
  81.         // IPersistFolder
  82.         STDMETHOD(GetClassID)(LPCLSID pClassID);
  83.         STDMETHOD(Initialize)(LPCITEMIDLIST pidl);
  85.         // IPersistFolder2
  86.         STDMETHOD(GetCurFolder)(LPITEMIDLIST *ppidl);
  88.         // IDelegateFolder
  89.         STDMETHOD(SetItemAlloc)(IMalloc *pm);
  91.         // IShellFolder
  92.         STDMETHOD(ParseDisplayName)(HWND hwndOwner, LPBC pbc, LPOLESTR pDisplayName, 
  93.                                       ULONG * pchEaten, LPITEMIDLIST * ppidl, ULONG *pdwAttributes);
  95.         STDMETHOD(EnumObjects)(HWND hwndOwner, DWORD grfFlags, LPENUMIDLIST * ppEnumIDList);
  96.         STDMETHOD(BindToObject)(LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppv);
  97.         STDMETHOD(BindToStorage)(LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppv);
  98.         STDMETHOD(CompareIDs)(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2);
  99.         STDMETHOD(CreateViewObject)(HWND hwndOwner, REFIID riid, void **ppv);
  100.         STDMETHOD(GetAttributesOf)(UINT cidl, LPCITEMIDLIST * apidl, ULONG * rgfInOut);
  101.         STDMETHOD(GetUIObjectOf)(HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid, UINT * prgfInOut, void **ppv);
  102.         STDMETHOD(GetDisplayNameOf)(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET pName);
  103.         STDMETHOD(SetNameOf)(HWND hwndOwner, LPCITEMIDLIST pidl, LPCOLESTR pszName, DWORD uFlags, LPITEMIDLIST* ppidlOut);
  104. };
  107. //
  108. // CDsExtractIcon 
  109. //
  111. class CDsExtractIcon : public IExtractIcon, CUnknown
  112. {
  113.     private:
  114.         LPITEMIDLIST _pidl;     
  115.         IDsDisplaySpecifier *_pdds;
  117.     public:
  118.         CDsExtractIcon(IDsDisplaySpecifier *pdds, LPCITEMIDLIST pidl);
  119.         ~CDsExtractIcon();
  121.         // IUnknown
  122.         STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
  123.         STDMETHOD_(ULONG, AddRef)();
  124.         STDMETHOD_(ULONG, Release)();
  126.         // IExtractIcon
  127.         STDMETHOD(GetIconLocation)(UINT uFlags, LPTSTR szIconFile, UINT cchMax, int* pIndex, UINT* pwFlags);
  128.         STDMETHOD(Extract)(LPCTSTR pszFile, UINT nIconIndex, HICON* pLargeIcon, HICON* pSmallIcon, UINT nIconSize);
  129. };
  132. //
  133. // CDsFolderProperties
  134. //
  136. class CDsFolderProperties : public IDsFolderProperties, CUnknown
  137. {
  138.     public:
  139.         // IUnknown
  140.         STDMETHOD(QueryInterface)(REFIID riid, void **ppv);
  141.         STDMETHOD_(ULONG, AddRef)();
  142.         STDMETHOD_(ULONG, Release)();
  144.         // IDsFolderProperties
  145.         STDMETHOD(ShowProperties)(HWND hwndParent, IDataObject *pDataObject);
  146. };
  149. /*-----------------------------------------------------------------------------
  150. / Callback functions used by this IShellFolder implementation
  151. /----------------------------------------------------------------------------*/
  153. /*-----------------------------------------------------------------------------
  154. / _StrRetFromString
  155. / -----------------
  156. /   Package a WIDE string into a LPSTRRET structure.
  157. /
  158. / In:
  159. /   pStrRet -> receieves the newly allocate string
  160. /   pString -> string to be copied.
  161. /
  162. / Out:
  163. /   -
  164. /----------------------------------------------------------------------------*/
  166. HRESULT _StrRetFromString(LPSTRRET lpStrRet, LPCTSTR pString)
  167. {
  168.     HRESULT hres;
  170.     TraceEnter(TRACE_FOLDER, "_StrRetFromString");
  171.     Trace(TEXT("pStrRet %08x, lpszString -%s-"), lpStrRet, pString);
  173.     TraceAssert(lpStrRet);
  174.     TraceAssert(pString);
  176. #ifdef UNICODE
  177.     lpStrRet->pOleStr = (LPWSTR)SHAlloc(StringByteSize(pString));
  179.     if ( !lpStrRet->pOleStr )
  180.         ExitGracefully(hres, E_OUTOFMEMORY, "Failed to allocate buffer for string");
  182.     lpStrRet->uType = STRRET_OLESTR;
  183.     StrCpy(lpStrRet->pOleStr, pString);                
  184. #else
  185.     if ( lstrlen(pString) > (MAX_PATH-1) )
  186.         ExitGracefully(hres, E_OUTOFMEMORY, "Buffer too small for string");
  188.     lpStrRet->uType = STRRET_CSTR;
  189.     StrCpy(lpStrRet->cStr, pString);
  190. #endif
  192.     hres = S_OK;                              // success
  194. exit_gracefully:
  196.     TraceLeaveResult(hres);
  197. }
  200. /*-----------------------------------------------------------------------------
  201. / _GetDetailsOf
  202. / -------------
  203. /   Handle the GetDetailsOf call back for this view.  If PIDL is NULL on
  204. /   entry then just return the column heading, otherwise get that information
  205. /   for the IDLIST and column combination.
  206. /
  207. / In:
  208. /   pDetails -> structure to fill
  209. /   iColumn -> column being invoked on
  210. /
  211. / Out:
  212. /   HRESULT
  213. /----------------------------------------------------------------------------*/
  214. HRESULT _GetDetailsOf(CDsFolder *pdf, PDETAILSINFO pDetails, UINT iColumn)
  215. {
  216.     HRESULT hres;
  217.     IDLISTDATA data;
  218.     USES_CONVERSION;
  220.     TraceEnter(TRACE_FOLDER, "_GetDetailsOf");
  221.     TraceAssert(pdf != NULL);
  223.     if ( iColumn > ARRAYSIZE(columns) )
  224.         ExitGracefully(hres, E_INVALIDARG, "Bad column index");
  226.     // Fill out the structure with the formatting information,
  227.     // and a dummy string incase we fail.
  229.     pDetails->fmt = columns[iColumn].fmt;
  230.     pDetails->cxChar = columns[iColumn].cxChar;
  231.     pDetails->str.uType = STRRET_CSTR;
  232.     pDetails->str.cStr[0] = TEXT('');
  234.     if ( !pDetails->pidl )
  235.     {
  236.         TCHAR szBuffer[MAX_PATH];
  238.         if ( !LoadString(GLOBAL_HINSTANCE, columns[iColumn].idString, szBuffer, ARRAYSIZE(szBuffer)) )
  239.             ExitGracefully(hres, E_FAIL, "Failed to load column heading");
  241.         hres = _StrRetFromString(&pDetails->str, szBuffer);
  242.         FailGracefully(hres, "Failed making a StrRet from the column heading");
  243.     }
  244.     else
  245.     {
  246.         hres = UnpackIdList(pDetails->pidl, DSIDL_HASCLASS, &data);
  247.         FailGracefully(hres, "Failed to unpack the IDLIST");
  249.         if ( iColumn == DSVMID_ARRANGEBYCLASS )
  250.         {
  251.             WCHAR szBuffer[MAX_PATH];
  253.             if ( SUCCEEDED(pdf->_GetDsDisplaySpecifier()) )
  254.                 pdf->_pdds->GetFriendlyClassName(data.pObjectClass, szBuffer, ARRAYSIZE(szBuffer));
  255.             else
  256.                 StrCpyW(szBuffer, data.pObjectClass);
  258.             hres = _StrRetFromString(&pDetails->str, W2CT(szBuffer));
  259.             FailGracefully(hres, "Failed to make StrRet from class name");
  260.         }
  261.         else
  262.         {
  263.             TraceAssert(FALSE);
  264.             ExitGracefully(hres, E_FAIL, "Bad column specified");
  265.         }
  266.     }
  268.     // hres = S_OK;
  270. exit_gracefully:
  272.     TraceLeaveResult(hres);
  273. }
  276. /*-----------------------------------------------------------------------------
  277. / _MergeArrangeMenu
  278. / -----------------
  279. /   Merge our verbs into the view menu
  280. /
  281. / In:
  282. /   arrangeParam = current sort parameter
  283. /   pInfo -> QCMINFO structure
  284. /
  285. / Out:
  286. /   HRESULT
  287. /----------------------------------------------------------------------------*/
  288. HRESULT _MergeArrangeMenu(CDsFolder *pdf, LPARAM arrangeParam, LPQCMINFO pInfo)
  289. {
  290.     HRESULT hres;
  291.     MENUITEMINFO mii = { SIZEOF(MENUITEMINFO), MIIM_SUBMENU };
  292.     UINT idCmdFirst = pInfo->idCmdFirst;
  293.     HMENU hMyArrangeMenu;
  295.     TraceEnter(TRACE_FOLDER, "_MergeArrangeMenu");
  296.     TraceAssert(pdf != NULL);
  297.     Trace(TEXT("arrangeParam %08x, pInfo->idCmdFirst %08x"), arrangeParam, pInfo->idCmdFirst);
  299.     if ( GetMenuItemInfo(pInfo->hmenu, SFVIDM_MENU_ARRANGE, FALSE, &mii) )
  300.     {
  301.         hMyArrangeMenu = LoadMenu(GLOBAL_HINSTANCE, MAKEINTRESOURCE(IDR_ARRANGE));
  303.         if ( hMyArrangeMenu )
  304.         {
  305.             pInfo->idCmdFirst = Shell_MergeMenus(mii.hSubMenu,
  306.                                                  GetSubMenu(hMyArrangeMenu, 0), 
  307.                                                  0, 
  308.                                                  pInfo->idCmdFirst, pInfo->idCmdLast,
  309.                                                  0);                    
  310.             DestroyMenu(hMyArrangeMenu);
  311.         }
  312.     } 
  314.     TraceLeaveResult(S_OK);
  315. }
  318. /*-----------------------------------------------------------------------------
  319. / _FolderCallBack
  320. / ---------------
  321. /   Handles callbacks from the shell for the view object we are the parent of.
  322. /
  323. / In:
  324. /   psvView -> view object
  325. /   psf -> shell folder (our object)
  326. /   hwndMain = window handle for a dialog parent
  327. /   uMsg, wParam, lParam = message specific information
  328. /
  329. / Out:
  330. /   -
  331. /----------------------------------------------------------------------------*/
  332. HRESULT CALLBACK _FolderCallBack(LPSHELLVIEW psvOuter, LPSHELLFOLDER psf, HWND hwndView, UINT uMsg, WPARAM wParam, LPARAM lParam)
  333. {
  334.     HRESULT hres = NOERROR;
  335.     CDsFolder *pdf;
  337.     psf->QueryInterface(CLSID_DsFolderSF, (void **)&pdf);
  339.     switch (uMsg)
  340.     {
  341.         case SFVM_INITMENUPOPUP:
  342.             break;
  344.         case SFVM_MERGEMENU:
  345.             hres = _MergeArrangeMenu(pdf, ShellFolderView_GetArrangeParam(hwndView), (LPQCMINFO)lParam);
  346.             break;
  348.         case SFVM_INVOKECOMMAND:
  349.         {
  350.             UINT idCmd = (UINT)wParam;
  352.             switch ( idCmd )
  353.             {
  354.                 case DSVMID_ARRANGEBYNAME:
  355.                 case DSVMID_ARRANGEBYCLASS:
  356.                     ShellFolderView_ReArrange(hwndView, idCmd);
  357.                     break;
  359.                 default:
  360.                     hres = S_FALSE;
  361.                     break;
  362.             }
  364.             break;
  365.         }
  367.         case SFVM_GETHELPTEXT:
  368.         {
  369.             hres = S_OK;
  370.         
  371.             switch ( LOWORD(wParam) )
  372.             {
  373.                 case DSVMID_ARRANGEBYNAME:
  374.                     LoadString(GLOBAL_HINSTANCE, IDS_BYOBJECTNAME, (LPTSTR)lParam, HIWORD(wParam));
  375.                     break;
  377.                 case DSVMID_ARRANGEBYCLASS:
  378.                     LoadString(GLOBAL_HINSTANCE, IDS_BYTYPE, (LPTSTR)lParam, HIWORD(wParam));
  379.                     break;
  381.                 default:
  382.                     hres = S_FALSE;
  383.                     break;
  384.             }
  385.         }
  387.         case SFVM_GETDETAILSOF:
  388.             hres = _GetDetailsOf(pdf, (PDETAILSINFO)lParam, (UINT)wParam);
  389.             break;
  391.         case SFVM_COLUMNCLICK:
  392.             ShellFolderView_ReArrange(hwndView, (UINT)wParam);
  393.             break;
  395.         case SFVM_BACKGROUNDENUM:
  396.             hres = S_OK;
  397.             break;
  399.         default:
  400.             hres = E_NOTIMPL;
  401.             break;
  402.     }
  404.     return hres;
  405. }
  408. /*-----------------------------------------------------------------------------
  409. / _FolderCFMCallBack
  410. / ------------------
  411. /   Handles callbacks for the context menu which is displayed when the user
  412. /   right clicks on objects within the view.
  413. /
  414. / In:
  415. /   psf -> shell folder (our object)
  416. /   hwndView = window handle for a dialog parent
  417. /   pDataObject -> data object for the menu
  418. /   uMsg, wParam, lParam = message specific information
  419. /
  420. / Out:
  421. /   -
  422. /----------------------------------------------------------------------------*/
  423. HRESULT CALLBACK _FolderCFMCallback(LPSHELLFOLDER psf, HWND hwndView, LPDATAOBJECT pDataObject, UINT uMsg, WPARAM wParam, LPARAM lParam)
  424. {
  425.     HRESULT hres = NOERROR;
  426.     CDsFolder* pdf;
  428.     TraceEnter(TRACE_FOLDER, "_FolderCFMCallback");
  429.     Trace(TEXT("psf %08x, hwndView %08x, pDataObject %08x"), psf, hwndView, pDataObject);
  430.     Trace(TEXT("uMsg %08x, wParam %08x, lParam %08x"), uMsg, wParam, lParam);
  432.     psf->QueryInterface(CLSID_DsFolderSF, (void **)&pdf);
  434.     switch ( uMsg )
  435.     {
  436.         case DFM_MERGECONTEXTMENU:
  437.             hres = _MergeArrangeMenu(pdf, ShellFolderView_GetArrangeParam(hwndView), (LPQCMINFO)lParam);
  438.             break;
  440.         case DFM_GETHELPTEXTW:
  441.         {
  442.             hres = S_OK;
  443.         
  444.             switch ( LOWORD(wParam) )
  445.             {
  446.                 case DSVMID_ARRANGEBYNAME:
  447.                     LoadString(GLOBAL_HINSTANCE, IDS_BYOBJECTNAME, (LPTSTR)lParam, HIWORD(wParam));
  448.                     break;
  450.                 case DSVMID_ARRANGEBYCLASS:
  451.                     LoadString(GLOBAL_HINSTANCE, IDS_BYTYPE, (LPTSTR)lParam, HIWORD(wParam));
  452.                     break;
  454.                 default:
  455.                     hres = S_FALSE;
  456.                     break;
  457.             }
  458.         }
  460.         case DFM_INVOKECOMMAND:
  461.         {
  462.             UINT idCmd = (UINT)wParam;
  464.             switch ( idCmd )
  465.             {
  466.                 case (UINT)DFM_CMD_PROPERTIES:
  467.                     hres = ShowObjectProperties(hwndView, pDataObject);
  468.                     break;
  470.                 case DSVMID_ARRANGEBYNAME:
  471.                 case DSVMID_ARRANGEBYCLASS:
  472.                     ShellFolderView_ReArrange(hwndView, idCmd);
  473.                     break;
  475.                 default:
  476.                     hres = S_FALSE;
  477.                     break;
  478.             }
  480.             break;
  481.         }
  483.         case DFM_GETDEFSTATICID:
  484.         {
  485.             *((UINT*)lParam) = (UINT)DFM_CMD_PROPERTIES;
  486.             break;
  487.         }
  489.         default:
  490.             hres = E_NOTIMPL;
  491.             break;
  492.     }
  494.     TraceLeaveResult(hres);
  495. }
  498. /*-----------------------------------------------------------------------------
  499. / CDsFolder
  500. /   This is our DS IShellFolder implementation, it provides a mapping from
  501. /   the shell namespace down to Active Directory.
  502. /----------------------------------------------------------------------------*/
  504. CDsFolder::CDsFolder() :
  505.     _dwProviderAND(0xffffffff),
  506.     _hresCoInit(E_FAIL)
  507. {
  508. }
  510. CDsFolder::~CDsFolder()
  511. {
  512.     DoILFree(_pidl);
  514.     LocalFreeString(&_pPrettyPath);
  515.     LocalFreeStringW(&_pAttribPrefix);
  517.     LocalFreeStringW(&_pServer);
  518.     LocalFreeStringW(&_pUserName);
  519.     LocalFreeStringW(&_pPassword);
  521.     DoRelease(_padp);
  522.     DoRelease(_pdds);
  523.     DoRelease(_pm);
  524. }
  526. #undef CLASS_NAME
  527. #define CLASS_NAME CDsFolder
  528. #include "unknown.inc"
  530. STDMETHODIMP CDsFolder::QueryInterface( REFIID riid, void **ppv)
  531. {
  532.     INTERFACES iface[] =
  533.     {
  534.         &IID_IDsFolderInternalAPI, (IDsFolderInternalAPI*)this,
  535.         &IID_IShellFolder, (LPSHELLFOLDER)this,
  536.         &IID_IPersistFolder, (LPPERSISTFOLDER)this,
  537.         &IID_IPersistFolder2, (IPersistFolder2*)this,
  538.         &IID_IDelegateFolder, (IDelegateFolder*)this,
  539.     };
  541.     // requesting CLSID_DsFolder gets the CDsFolder object without a reference
  542.     // count.
  544.     if ( IsEqualIID(CLSID_DsFolderSF, riid) )
  545.     {
  546.         *ppv = this;
  547.         return S_OK;
  548.     }
  550.    return HandleQueryInterface(riid, ppv, iface, ARRAYSIZE(iface));
  551. }
  553. //
  554. // handle create instance of the CDsFolder object
  555. //
  557. STDAPI CDsFolder_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
  558. {
  559.     CDsFolder *pdf = new CDsFolder();
  560.     if ( !pdf )
  561.         return E_OUTOFMEMORY;
  563.     HRESULT hres = pdf->QueryInterface(IID_IUnknown, (void **)ppunk);
  564.     pdf->Release();
  565.     return hres;
  566. }
  569. //-----------------------------------------------------------------------------
  570. // Helper functions
  571. //-----------------------------------------------------------------------------
  573. //
  574. // ensure we have COM alive...
  575. //
  577. BOOL CDsFolder::_InitCOM(void)
  578. {
  579.     TraceEnter(TRACE_FOLDER, "CDsFolder::_InitCOM");
  581.     if ( FAILED(_hresCoInit) )
  582.     {
  583.         TraceMsg("Calling CoInitialize");
  584.         _hresCoInit = CoInitialize(NULL);
  585.     }
  587.     TraceLeaveValue(SUCCEEDED(_hresCoInit));
  588. }
  590. //
  591. // ensure we have the IADsPathname object
  592. //
  594. HRESULT CDsFolder::_GetPathname(void)
  595. {
  596.     HRESULT hres;
  598.     TraceEnter(TRACE_FOLDER, "CDsFolder::_GetPathname");
  600.     if ( _InitCOM() && !_padp )
  601.     {
  602.         hres = CoCreateInstance(CLSID_Pathname, NULL, CLSCTX_INPROC_SERVER, IID_IADsPathname, (void **)&_padp);
  603.         FailGracefully(hres, "Failed to get the IADsPathname interface");
  604.     }
  606.     hres = S_OK;
  608. exit_gracefully:
  610.     if ( SUCCEEDED(hres) )
  611.         _padp->SetDisplayType(ADS_DISPLAY_FULL);
  613.     TraceLeaveResult(hres);
  614. }
  616. //
  617. // ensure we have the IDsDisplaySpecifier object
  618. //
  620. HRESULT CDsFolder::_GetDsDisplaySpecifier(void)
  621. {
  622.     HRESULT hres = S_OK;
  624.     TraceEnter(TRACE_FOLDER, "CDsFolder::_GetDsDisplaySpecifier");
  626.     if ( _InitCOM() && !_pdds )
  627.     {
  628.         hres = CoCreateInstance(CLSID_DsDisplaySpecifier, NULL, CLSCTX_INPROC_SERVER, IID_IDsDisplaySpecifier, (void **)&_pdds);
  629.         if ( SUCCEEDED(hres) )
  630.             _pdds->SetServer(_pServer, _pUserName, _pPassword, 0x0);
  631.     }
  633.     TraceLeaveResult(hres);
  634. }
  637. /*-----------------------------------------------------------------------------
  638. / IDsFolderInternalAPI
  639. /----------------------------------------------------------------------------*/
  641. STDMETHODIMP CDsFolder::SetAttributePrefix(LPWSTR pAttributePrefix)
  642. {
  643.     HRESULT hres;
  644.     USES_CONVERSION;
  645.         
  646.     TraceEnter(TRACE_FOLDER, "CDsFolder::SetAttributePrefix");
  648.     LocalFreeStringW(&_pAttribPrefix);
  650.     hres = LocalAllocStringW(&_pAttribPrefix, pAttributePrefix);
  651.     FailGracefully(hres, "Failed to store attribute prefix");
  653.     Trace(TEXT("Setting attribute prefix to: %s"), W2T(pAttributePrefix));
  654.     
  655. exit_gracefully:
  657.     TraceLeaveResult(hres);
  658. }
  660. //-----------------------------------------------------------------------------
  662. STDMETHODIMP CDsFolder::SetProviderFlags(DWORD dwAND, DWORD dwXOR)
  663. {
  664.     TraceEnter(TRACE_FOLDER, "CDsFolder::SetProviderFlags");
  665.     Trace(TEXT("dwAND %08x, dwXOR %08x"), dwAND, dwXOR);
  667.     _dwProviderAND = dwAND;
  668.     _dwProviderXOR = dwXOR;
  670.     TraceLeaveResult(S_OK);
  671. }
  673. STDMETHODIMP CDsFolder::SetComputer(LPCWSTR pszComputerName, LPCWSTR pszUserName, LPCWSTR pszPassword)
  674. {
  675.     HRESULT hres;
  677.     TraceEnter(TRACE_FOLDER, "CDsFolder::SetComputer");
  679.     LocalFreeStringW(&_pServer);
  680.     LocalFreeStringW(&_pUserName);
  681.     LocalFreeStringW(&_pPassword);
  683.     hres = LocalAllocStringW(&_pServer, pszComputerName);
  684.     if ( SUCCEEDED(hres) )
  685.         hres = LocalAllocStringW(&_pUserName, pszUserName);
  686.     if ( SUCCEEDED(hres) )
  687.         hres = LocalAllocStringW(&_pPassword, pszPassword);
  689.     if ( FAILED(hres) )
  690.     {
  691.         LocalFreeStringW(&_pServer);
  692.         LocalFreeStringW(&_pUserName);
  693.         LocalFreeStringW(&_pPassword);
  694.     }
  696.     TraceLeaveResult(hres);
  697. }
  700. /*-----------------------------------------------------------------------------
  701. / IPersistFolder methods
  702. /----------------------------------------------------------------------------*/
  704. STDMETHODIMP CDsFolder::GetClassID(LPCLSID pClassID)
  705. {
  706.     TraceEnter(TRACE_FOLDER, "CDsFolder::GetClassID");
  708.     TraceAssert(pClassID);
  709.     *pClassID = CLSID_MicrosoftDS;
  711.     TraceLeaveResult(S_OK);
  712. }
  714. /*---------------------------------------------------------------------------*/
  716. // Initialization we handle in two ways.  We assume that IPersistFolder::Initialize
  717. // is called with an absolute IDLIST to the start of our name space, further to
  718. // that (eg. when we bind to an object) we call an internal version.
  719. //
  720. // We assume this because we need to have an idea of how much to skip to get
  721. // to the DS specific parts of an absolute IDLIST.
  723. STDMETHODIMP CDsFolder::Initialize(LPCITEMIDLIST pidl)
  724. {
  725.     HRESULT hres;
  727.     TraceEnter(TRACE_FOLDER, "CDsFolder::Initialize");
  729.     hres = _RealInitialize(pidl, NULL, ILGetSize(pidl)-SIZEOF(SHORT));
  730.     FailGracefully(hres, "Failed when calling CDsFolder::_RealInitialize");
  732. exit_gracefully:
  734.     TraceLeaveResult(hres);
  735. }
  737. HRESULT CDsFolder::_RealInitialize(LPCITEMIDLIST pidlRoot, LPCITEMIDLIST pidlBindTo, INT cbOffset)
  738. {
  739.     HRESULT hres;
  740.     LPITEMIDLIST pidl;
  742.     TraceEnter(TRACE_FOLDER, "CDsFolder::_RealInitialize");
  744.     if ( !pidlRoot )
  745.         ExitGracefully(hres, E_FAIL, "Failed due to no pidlRoot");
  747.     _cbOffset = cbOffset;
  749.     if ( !pidlBindTo )
  750.     {
  751.         _pidl = ILClone(pidlRoot);
  752.     }
  753.     else
  754.     {
  755.         _pidl = ILCombine(pidlRoot, pidlBindTo);
  756.     }
  758.     if ( !_pidl )
  759.         ExitGracefully(hres, E_OUTOFMEMORY, "Failed to create root IDLIST");
  761.     hres = S_OK;                  // success
  763. exit_gracefully:
  765.     TraceLeaveResult(hres);
  766. }
  769. /*-----------------------------------------------------------------------------
  770. / IPersistFolder2 methods
  771. /----------------------------------------------------------------------------*/
  773. STDMETHODIMP CDsFolder::GetCurFolder(LPITEMIDLIST *ppidl)
  774. {
  775.     HRESULT hres;
  777.     TraceEnter(TRACE_FOLDER, "CDsFolder::GetCurFolder");
  779.     if ( !ppidl || !_pidl )
  780.         ExitGracefully(hres, E_INVALIDARG, "Bad ppidl pointer, or perhaps no PIDL");
  782.     *ppidl = ILClone(_pidl);
  783.     TraceAssert(*ppidl);
  785.     if ( !*ppidl )
  786.         ExitGracefully(hres, E_OUTOFMEMORY, "Failed to clone our current folder pidl");
  788.     hres = S_OK;
  790. exit_gracefully:
  792.     TraceLeaveResult(hres);
  793. }
  796. /*-----------------------------------------------------------------------------
  797. / IDelegateFolder methods
  798. /----------------------------------------------------------------------------*/
  800. STDMETHODIMP CDsFolder::SetItemAlloc(IMalloc *pm)
  801. {
  802.     TraceEnter(TRACE_FOLDER, "CDsFolder::SetItemAlloc");
  804.     DoRelease(_pm);
  805.     
  806.     if ( pm )
  807.     {
  808.         pm->AddRef();
  809.         _pm = pm;
  810.     }
  812.     TraceLeaveResult(S_OK);
  813. }
  816. /*-----------------------------------------------------------------------------
  817. / IShellFolder methods
  818. /----------------------------------------------------------------------------*/
  820. #define SKIP_PREFIX 7 // 'LDAP://'
  822. HRESULT CDsFolder::_TryToParsePath(LPITEMIDLIST* ppidl, IADsPathname *padp, LPWSTR pObjectClass, LPDOMAINTREE pDomainTree)
  823. {
  824.     HRESULT hres;
  825.     LPDOMAINDESC pDomainDesc;
  826.     BSTR bstrPath = NULL;
  827.     BSTR bstrPathWithServer = NULL;
  828.     LONG lElements;
  829.     BOOL fDomainRoot = FALSE;
  830.     LPITEMIDLIST pidl = NULL;
  831.     LPITEMIDLIST pidlCombined = NULL;
  832.     DWORD i;
  833.     USES_CONVERSION;
  835.     TraceEnter(TRACE_PARSE, "_TryToParsePath");
  837.     hres = padp->Retrieve(ADS_FORMAT_X500_NO_SERVER, &bstrPath);
  838.     FailGracefully(hres, "Failed to retrieve the path (without server reference)");
  840.     hres = padp->Retrieve(ADS_FORMAT_X500, &bstrPathWithServer);
  841.     FailGracefully(hres, "Failed to retrieve the path");
  843.     // Get the path we are parsing, is it a domain root, if so then we
  844.     // don't want to look any deeper.  
  846.     Trace(TEXT("Path is %s"), W2T(bstrPath+SKIP_PREFIX));
  848.     for ( pDomainDesc = pDomainTree->aDomains ; pDomainDesc ; pDomainDesc = pDomainDesc->pdNextSibling )
  849.     {
  850.         Trace(TEXT("Comparing to domain %s"), W2T(pDomainDesc->pszNCName));
  851.         if ( !StrCmpIW(bstrPath+SKIP_PREFIX, pDomainDesc->pszNCName) )
  852.         {
  853.             TraceMsg("Found root domain object");
  854.             fDomainRoot = TRUE;
  855.             break;
  856.         }
  857.     }
  859.     // if this is the domain root then lets pack the PIDL for it.
  861.     if ( !fDomainRoot ) 
  862.     {
  863.         hres = padp->RemoveLeafElement();                                     // remove the leaf element
  864.         FailGracefully(hres, "Failed to remove the leaf element");
  866.         padp->GetNumElements(&lElements);
  867.         Trace(TEXT("lElements %08x"), lElements);
  869.         if ( !lElements )        
  870.             ExitGracefully(hres, E_INVALIDARG, "Bad pathname passed");
  872.         hres = _TryToParsePath(ppidl, padp, NULL, pDomainTree);     // we don't know the class
  873.         FailGracefully(hres, "Failed recursing into the names");
  874.     }
  876.     // now convert this into an IDLIST and append it to the one we 
  877.     // already have to return to the caller.
  879.     hres = _GetDsDisplaySpecifier();
  880.     FailGracefully(hres, "Failed to get the IDsDisplaySpecifier object");
  882.     hres = CreateIdListFromPath(&pidl, NULL, bstrPathWithServer, pObjectClass, NULL, _pm, _pdds);
  883.     FailGracefully(hres, "Failed to create an IDLIST");
  885.     if ( *ppidl )
  886.     {
  887.         pidlCombined = ILCombine(*ppidl, pidl);
  888.         TraceAssert(pidlCombined);
  890.         if ( !pidlCombined )
  891.             ExitGracefully(hres, E_OUTOFMEMORY, "Failed to combine the pidl");
  893.         *ppidl = pidlCombined;
  894.         pidlCombined = NULL;
  895.     }
  896.     else
  897.     {
  898.         *ppidl = pidl;
  899.         pidl = NULL;
  900.     }
  901.     
  902.     hres = S_OK;    
  904. exit_gracefully:
  906.     SysFreeString(bstrPath);
  907.     SysFreeString(bstrPathWithServer);
  909.     DoILFree(pidl);
  910.     DoILFree(pidlCombined);
  912.     TraceLeaveResult(hres);
  913. }
  915. //
  916. // parse display name for IShellFolder 
  917. // BUGBUG: fix to cope with the NTDS scheme
  918. //
  920. STDMETHODIMP CDsFolder::ParseDisplayName(HWND hwndOwner, 
  921.                                          LPBC pbc, 
  922.                                          LPOLESTR pDisplayName,
  923.                                          ULONG* pchEaten, 
  924.                                          LPITEMIDLIST* ppidl, 
  925.                                          ULONG *pdwAttributes)
  926. {
  927.     HRESULT hres = E_INVALIDARG;
  928.     BSTR bstrObjectClass = NULL;
  929.     IPropertyBag* pPropertyBag = NULL;
  930.     IDsBrowseDomainTree* pdbdt = NULL;
  931.     LPDOMAINTREE pDomainTree = NULL;
  932.     VARIANT variant;    
  933.     USES_CONVERSION;
  935.     TraceEnter(TRACE_FOLDER, "CDsFolder::ParseDisplayName");
  936.     Trace(TEXT("pDisplayName: %s"), W2T(pDisplayName));
  938.     *ppidl = NULL;
  940.     VariantInit(&variant);
  942.     if ( !*pDisplayName )
  943.         ExitGracefully(hres, S_OK, "Name is NULL, nothing to parse");
  945.     // Look and see if we have the DS property bag, if we do then
  946.     // we can check to see if we have an object class property
  947.     // within that.
  949.     if ( pbc && SUCCEEDED(pbc->GetObjectParam(DS_PDN_PROPERTYBAG, (IUnknown**)&pPropertyBag)) )
  950.     {
  951.         hres = pPropertyBag->Read(DS_PDN_OBJECTLCASS, &variant, NULL);
  952.         if ( SUCCEEDED(hres) )
  953.         {
  954.             if ( V_VT(&variant) != VT_BSTR )
  955.                 ExitGracefully(hres, E_UNEXPECTED, "Failed to get the object class");
  957.             bstrObjectClass = V_BSTR(&variant);
  958.             Trace(TEXT("ObjectClass from property bag is: %s"), W2T(bstrObjectClass));
  959.         }
  960.    }
  962.     // ensure we have the IADsPathname interface then lets call the parser,
  963.     // this can be quite a quick process although it does eat quite alot
  964.     // of stack.  The resulting IDLIST is allocated using the malloc
  965.     // interface to we give.
  967.     hres = _GetPathname();        
  968.     FailGracefully(hres, "Failed to get the IADsPathname object");
  970.     hres = _padp->Set(pDisplayName, ADS_SETTYPE_FULL);
  971.     FailGracefully(hres, "Failed to set the path of the name");
  973.     _padp->SetDisplayType(ADS_DISPLAY_FULL);
  975.     // get the domain list, we use this to determine the domain root and
  976.     // therefore the point where parsing is no long needed.
  978.     if ( !_InitCOM() )
  979.         TraceMsg("Failed to initialize COM");
  981.     hres = CoCreateInstance(CLSID_DsDomainTreeBrowser, NULL, CLSCTX_INPROC_SERVER, IID_IDsBrowseDomainTree, (void **)&pdbdt);
  982.     FailGracefully(hres, "Failed to get the domain tree interface");
  984.     hres = pdbdt->SetComputer(_pServer, _pUserName, _pPassword);
  985.     FailGracefully(hres, "Failed to set browsing attributes");
  987.     hres = pdbdt->GetDomains(&pDomainTree, DBDTF_RETURNFQDN);
  988.     FailGracefully(hres, "Failed when getting domain tree information");  
  990.     // now build a set of IDLISTs using this information, the pPathname contains a structure
  992.     hres = _TryToParsePath(ppidl, _padp, bstrObjectClass, pDomainTree);
  993.     FailGracefully(hres, "Failed when calling recursive parser");
  995.     hres = S_OK;          // successs
  997. exit_gracefully:        
  999.     if ( pdbdt )
  1000.         pdbdt->FreeDomains(&pDomainTree);
  1002.     DoRelease(pPropertyBag);
  1003.     DoRelease(pdbdt);
  1005.     VariantClear(&variant);
  1007.     if ( hres == E_ADS_BAD_PATHNAME )
  1008.     {
  1009.         TraceMsg("Name was not an ADSI one, therefore making the result E_INVALIDARG");
  1010.         hres = E_INVALIDARG;
  1011.     }
  1013.     TraceLeaveResult(hres);
  1014. }
  1016. /*---------------------------------------------------------------------------*/
  1018. STDMETHODIMP CDsFolder::EnumObjects(HWND hwndOwner, DWORD grfFlags, LPENUMIDLIST* ppEnumIdList)
  1019. {
  1020.     if ( !_InitCOM() )
  1021.         return E_FAIL;
  1023.     return CDsEnum_CreateInstance(_ILSkip(_pidl, _cbOffset), hwndOwner, grfFlags, _pm, ppEnumIdList);
  1024. }
  1026. /*---------------------------------------------------------------------------*/
  1028. HRESULT CDsFolder::_GetJunction(LPITEMIDLIST pidl, LPITEMIDLIST *ppidlRight, IDLISTDATA *pData)
  1029. {
  1030.     HRESULT hres;
  1032.     TraceEnter(TRACE_FOLDER, "CDsFolder::_GetJunction");
  1034.     // walk the pidl attempting to find the junction point, if we find one then we return both
  1035.     // the pidl data to the right and the main pidl.
  1037.     *ppidlRight = NULL;
  1039.     if (ILIsEmpty(pidl))
  1040.     {
  1041.         ExitGracefully(hres, E_INVALIDARG, "pidl is empty");
  1042.     }
  1044.     while ( !ILIsEmpty(pidl) )
  1045.     {
  1046.         hres = UnpackIdList(pidl, 0x0, pData);
  1047.         FailGracefully(hres, "Failed to unpack pidl");
  1049.         pidl = _ILNext(pidl);
  1051.         if ( pData->pUNC )
  1052.         {
  1053.             if ( !ILIsEmpty(pidl) )
  1054.             {
  1055.                 *ppidlRight = ILClone(pidl);
  1056.                 TraceAssert(*ppidlRight);
  1058.                 if ( !*ppidlRight )
  1059.                     ExitGracefully(hres, E_OUTOFMEMORY, "Failed to clone the rest of the pidl");
  1060.             }
  1062.             pidl->mkid.cb = 0;       // truncate the pidl we have
  1063.             break;
  1064.         }
  1065.     }
  1067.     hres = S_OK;
  1069. exit_gracefully:
  1071.     TraceLeaveResult(hres);
  1072. }
  1074. HRESULT CDsFolder::_GetJunctionSF(LPITEMIDLIST pidlFull, IBindCtx *pbc, 
  1075.                                     IDLISTDATA *pData, LPITEMIDLIST *ppidlRight, IShellFolder **ppsf)
  1076. {
  1077.     HRESULT hres;
  1078.     IShellFolder *psf = NULL;
  1079.     IPersistFolder3 *ppf3 = NULL;
  1080.     IShellFolder* psfDesktop = NULL;
  1081.     IDLISTDATA data = { 0 };
  1082.     PERSIST_FOLDER_TARGET_INFO pfti = {0};
  1083.     LPITEMIDLIST pidl = NULL;
  1085.     TraceEnter(TRACE_FOLDER, "CDsFolder::_GetJunctionSF");
  1087.     if ( !pData )
  1088.         pData = &data;
  1090.     //
  1091.     // get the junction information from the object, if we have a UNC then we must
  1092.     // create the IShellFolder that represents it.
  1093.     //
  1095.     hres = _GetJunction(_ILSkip(pidlFull, _cbOffset), ppidlRight, pData);
  1096.     FailGracefully(hres, "Failed to bind to junction object");
  1098.     if ( !pData->pUNC )
  1099.         ExitGracefully(hres, S_FALSE, "Object is not a junction");
  1101.     if ( !_InitCOM() )
  1102.         TraceMsg("Failed to initialize COM");
  1104.     hres = CoCreateInstance(CLSID_ShellDesktop, NULL, CLSCTX_INPROC_SERVER, IID_IShellFolder, (LPVOID*)&psfDesktop);
  1105.     FailGracefully(hres, "Failed to get IShellFolder for the desktop object");
  1107.     hres = psfDesktop->ParseDisplayName(NULL, NULL, pData->pUNC, NULL, &pidl, NULL);
  1108.     FailGracefully(hres, "Failed to parse the UNC to a PIDL");
  1109.     
  1110.     //
  1111.     // In this case lets create the FS folder and initializeit accordingly with a PIDL.
  1112.     //
  1114.     hres = CoCreateInstance(CLSID_ShellFSFolder, NULL, CLSCTX_INPROC_SERVER, IID_IShellFolder, (void **)&psf);
  1115.     FailGracefully(hres, "Failed to get ShellFsFolder");
  1117.     hres = psf->QueryInterface(IID_IPersistFolder3, (void **)&ppf3);
  1118.     FailGracefully(hres, "Failed to get the IPersistFolderAlias");
  1120.     pfti.pidlTargetFolder = pidl;            
  1121.     pfti.dwAttributes = -1;        
  1122.     pfti.csidl = -1;
  1124.     hres = ppf3->InitializeEx(pbc, pidlFull, &pfti);
  1125.     if ( SUCCEEDED(hres) )
  1126.         psf->QueryInterface(IID_IShellFolder, (void **)ppsf);
  1128. exit_gracefully:
  1130.     DoRelease(psf);
  1131.     DoRelease(ppf3);
  1132.     DoRelease(psfDesktop);
  1134.     if ( pidl )
  1135.         ILFree(pidl);
  1137.     TraceLeaveResult(hres);
  1138. }
  1140. STDMETHODIMP CDsFolder::BindToObject(LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
  1141. {
  1142.     HRESULT hres = E_FAIL;
  1143.     IShellFolder *psf = NULL;
  1144.     LPITEMIDLIST pidlFull = NULL;
  1145.     LPITEMIDLIST pidlRight = NULL;
  1146.     USES_CONVERSION;
  1148.     TraceEnter(TRACE_FOLDER, "CDsFolder::BindToObject");
  1149.     Trace(TEXT("Entry IDLIST is %08x"), pidl);
  1150.     TraceGUID("Interface being requested", riid);
  1152.     pidlFull = ILCombine(_pidl, pidl);
  1154.     if ( !pidlFull )
  1155.         ExitGracefully(hres, E_OUTOFMEMORY, "Failed to alloc temporary pidl");
  1157.     // attempt to get the sf that has junction.  this call can return S_FALSE
  1158.     // indicating there is no junction, therefore we create a new instance
  1159.     // of CDsFolder.
  1160.     //
  1161.     // if it was a junction then continue the bind process through the
  1162.     // junction to the real namespace.
  1164.     hres = _GetJunctionSF(pidlFull, pbc, NULL, &pidlRight, &psf);
  1165.     if ( SUCCEEDED(hres) )
  1166.     {
  1167.         if ( hres == S_FALSE )
  1168.         {
  1169.             // Create a new CDsFolder object, pass on the IMalloc interface we have
  1170.             // etc.
  1172.             CDsFolder *pDsFolder = new CDsFolder();
  1173.             TraceAssert(pDsFolder);
  1175.             if ( !pDsFolder )
  1176.                 ExitGracefully(hres, E_OUTOFMEMORY, "Failed to allocate new CDsFolder");
  1178.             hres = pDsFolder->_RealInitialize(_pidl, pidl, _cbOffset);     
  1180.             if ( SUCCEEDED(hres) )
  1181.                 hres = pDsFolder->SetItemAlloc(_pm);
  1183.             if ( SUCCEEDED(hres) )
  1184.                 hres = pDsFolder->QueryInterface(riid, ppv);
  1186.             pDsFolder->Release();
  1187.         }
  1188.         else
  1189.         {
  1190.             // pidlRight?  if not then we are at the right point in the namespace,
  1191.             // otherwise we must continue the bind.
  1193.             if ( pidlRight )
  1194.                 hres = psf->BindToObject(pidlRight, pbc, riid, ppv);
  1195.             else
  1196.                 hres = psf->QueryInterface(riid, ppv);
  1197.         }
  1198.     }
  1200. exit_gracefully:
  1202.     DoILFree(pidlFull);
  1203.     DoILFree(pidlRight);
  1205.     DoRelease(psf);
  1207.     TraceLeaveResult(hres);
  1208. }
  1210. /*---------------------------------------------------------------------------*/
  1212. STDMETHODIMP CDsFolder::BindToStorage(LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, void **ppv)
  1213. {
  1214.     TraceEnter(TRACE_FOLDER, "CDsFolder::BindToStorage");
  1215.     TraceLeaveResult(E_NOTIMPL);
  1216. }
  1218. /*---------------------------------------------------------------------------*/
  1220. STDMETHODIMP CDsFolder::CompareIDs(LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
  1221. {
  1222.     IDLISTDATA data1, data2;
  1223.     HRESULT hres = E_INVALIDARG;
  1224.     INT iResult = 0;
  1225.     LPITEMIDLIST pidlT1, pidlT2;
  1226.     LPITEMIDLIST pidlT = NULL;
  1227.     WCHAR szName1[MAX_PATH];
  1228.     WCHAR szName2[MAX_PATH];
  1229.     IShellFolder *pShellFolder = NULL;
  1230.     USES_CONVERSION;
  1232.     TraceEnter(TRACE_COMPARE, "CDsFolder::CompareIDs");
  1234.     hres = UnpackIdList(pidl1, DSIDL_HASCLASS, &data1);
  1235.     FailGracefully(hres, "Failed to unpack pidl1");
  1237.     hres = UnpackIdList(pidl2, DSIDL_HASCLASS, &data2);
  1238.     FailGracefully(hres, "Failed to unpack pidl2");
  1240.     // Ensure that containers end up at the top of the list
  1242.     if ( (data1.dwFlags & DSIDL_ISCONTAINER) != (data2.dwFlags & DSIDL_ISCONTAINER) )
  1243.     {
  1244.         iResult = (data1.dwFlags & DSIDL_ISCONTAINER) ? -1:+1;
  1245.         goto exit_result;
  1246.     }
  1248.     // lParam indicates which column we are sorting on, therefore using that compare
  1249.     // the values we have just unpacked from IDLISTs.
  1251.     switch ( lParam & SHCIDS_COLUMNMASK )
  1252.     {
  1253.         case DSVMID_ARRANGEBYNAME:
  1254.         {
  1255.             _GetPathname();
  1257.             if ( SUCCEEDED(NameFromIdList(pidl1, _ILSkip(_pidl, _cbOffset), szName1, ARRAYSIZE(szName1), _padp)) &&
  1258.                     SUCCEEDED(NameFromIdList(pidl2, _ILSkip(_pidl, _cbOffset), szName2, ARRAYSIZE(szName2), _padp)) )
  1259.             {
  1260.                 Trace(TEXT("Comparing -%s-, -%s-"), W2T(szName1), W2T(szName2));
  1261.                 iResult = StrCmpIW(szName1, szName2);
  1262.             }
  1264.             break;
  1265.         }
  1267.         case DSVMID_ARRANGEBYCLASS:
  1268.             Trace(TEXT("Classes -%s-, -%s-"), W2T(data1.pObjectClass), W2T(data2.pObjectClass));
  1269.             iResult = StrCmpIW(data1.pObjectClass, data2.pObjectClass);
  1270.             break;
  1272.         default:
  1273.             TraceAssert(FALSE);
  1274.             ExitGracefully(hres, E_INVALIDARG, "Bad sort column");
  1275.             break;
  1276.     }
  1278.     // If they match then check that they are absolutely identical, if that is
  1279.     // the case then continue down the IDLISTs if more elements present.
  1280.    
  1281.     if ( iResult == 0 )
  1282.     {
  1283.         iResult = memcmp(pidl1, pidl2, ILGetSize(pidl1));
  1284.         Trace(TEXT("memcmp of pidl1, pidl2 yeilds %d"), iResult);
  1286.         if ( iResult != 0 )
  1287.             goto exit_result;
  1289.         pidlT1 = _ILNext(pidl1);
  1290.         pidlT2 = _ILNext(pidl2);
  1292.         if ( ILIsEmpty(pidlT1) )
  1293.         {
  1294.             if ( ILIsEmpty(pidlT2) )
  1295.             {
  1296.                 iResult = 0;
  1297.             }
  1298.             else
  1299.             {
  1300.                 iResult = -1;
  1301.             }
  1303.             goto exit_result;
  1304.         }
  1305.         else if ( ILIsEmpty(pidlT2) )
  1306.         {
  1307.             iResult = 1;
  1308.             goto exit_result;
  1309.         }
  1311.         // Both IDLISTs have more elements, therefore continue down them
  1312.         // binding to the next element in 1st IDLIST and then calling its
  1313.         // compare method.
  1315.         pidlT = ILClone(pidl1);
  1317.         if ( !pidlT )
  1318.             ExitGracefully(hres, E_OUTOFMEMORY, "Failed to clone IDLIST for binding");
  1320.         _ILNext(pidlT)->mkid.cb = 0;
  1322.         hres = BindToObject(pidlT, NULL, IID_IShellFolder, (void **)&pShellFolder);
  1323.         FailGracefully(hres, "Failed to get the IShellFolder implementation from pidl1");
  1325.         hres = pShellFolder->CompareIDs(lParam, pidlT1, pidlT2);
  1326.         Trace(TEXT("CompareIDs returned %08x"), ShortFromResult(hres));
  1328.         goto exit_gracefully;
  1329.     }
  1331. exit_result:
  1333.     Trace(TEXT("Exiting with iResult %d"), iResult);
  1334.     hres = ResultFromShort(iResult);
  1336. exit_gracefully:
  1338.     DoRelease(pShellFolder);
  1339.     DoILFree(pidlT);
  1341.     TraceLeaveResult(hres);
  1342. }
  1344. /*---------------------------------------------------------------------------*/
  1346. STDMETHODIMP CDsFolder::CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv)
  1347. {
  1348.     HRESULT hres;
  1350.     TraceEnter(TRACE_FOLDER, "CDsFolder::CreateViewObject");
  1351.     TraceGUID("View object requested", riid);
  1353.     TraceAssert(ppv);
  1355.     if ( IsEqualIID(riid, IID_IShellView) )
  1356.     {
  1357.         CSFV csfv;
  1359.         csfv.cbSize = SIZEOF(csfv);
  1360.         csfv.pshf = (LPSHELLFOLDER)this;
  1361.         csfv.psvOuter = NULL;
  1362.         csfv.pidl = _pidl;
  1363.         csfv.lEvents = 0;
  1364.         csfv.pfnCallback = _FolderCallBack;
  1365.         csfv.fvm = FVM_ICON;
  1367.         hres = SHCreateShellFolderViewEx(&csfv, (LPSHELLVIEW*)ppv);
  1368.         FailGracefully(hres, "SHCreateShellFolderViewEx failed");
  1369.     }
  1370.     else if ( IsEqualIID(riid, IID_IContextMenu) )
  1371.     {
  1372.         hres = CDefFolderMenu_Create2(_pidl, 
  1373.                                     hwndOwner,
  1374.                                     NULL, 0,
  1375.                                     (LPSHELLFOLDER)this,
  1376.                                     _FolderCFMCallback,
  1377.                                     NULL, 
  1378.                                     0, 
  1379.                                     (LPCONTEXTMENU*)ppv);        
  1380.     }
  1381.     else
  1382.     {
  1383.         ExitGracefully(hres, E_NOINTERFACE, "View object not supported");
  1384.     }
  1386. exit_gracefully:
  1388.     TraceLeaveResult(hres);
  1389. }
  1391. /*---------------------------------------------------------------------------*/
  1393. STDMETHODIMP CDsFolder::GetAttributesOf(UINT cidl, LPCITEMIDLIST* apidl, ULONG* rgfInOut)
  1394. {
  1395.     HRESULT hres;
  1396.     IDLISTDATA data;
  1397.     UINT i;
  1399.     TraceEnter(TRACE_FOLDER, "CDsFolder::GetAttributesOf");
  1400.     Trace(TEXT("cidl = %d"), cidl);
  1402.     if ( !rgfInOut )
  1403.         ExitGracefully(hres, E_INVALIDARG, "Bad rgfInOut value");
  1405.     *rgfInOut = 0;
  1407.     if ( cidl == 0 )
  1408.     {
  1409.         // get the namespace attributes we want to invoke for this namespace
  1410.         // checking the policy to see if we should be hiding this object
  1412.         *rgfInOut = NAMESPACE_ATTRIBUTES;
  1414.         if ( CheckDsPolicy(NULL, c_szHideNamespace) || !ShowDirectoryUI() )
  1415.         {
  1416.             TraceMsg("Namespace being marked as hidden");
  1417.             *rgfInOut |= SFGAO_NONENUMERATED;
  1418.         }           
  1419.     }
  1420.     else if ( cidl >= 1 )
  1421.     {
  1422.         // cidl > 1 && rgfInOut != NULL
  1423.         //  - walk all the IDLISTs we were given and get their attributes, and compose
  1424.         //    a mask containing the bits
  1426.         TraceAssert(apidl);
  1427.         TraceAssert(rgfInOut);
  1429.         for ( i = 0; i != cidl; i++ )
  1430.         {
  1431.             hres = UnpackIdList(apidl[i], DSIDL_HASCLASS, &data);
  1432.             FailGracefully(hres, "Failed to unpack IDLIST");
  1434.             *rgfInOut |= AttributesFromIdList(&data);
  1435.         }
  1436.     }
  1438.     hres = S_OK;
  1440. exit_gracefully:
  1442.     TraceLeaveResult(hres);
  1443. }
  1445. /*---------------------------------------------------------------------------*/
  1447. HRESULT CDsFolder::_SetDispSpecOptions(IDataObject *pdo)
  1448. {
  1449.     HRESULT hres;
  1450.     CLIPFORMAT cfDsDispSpecOptions = (CLIPFORMAT)RegisterClipboardFormat(CFSTR_DSDISPLAYSPECOPTIONS);
  1451.     FORMATETC fmte = {cfDsDispSpecOptions, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  1452.     STGMEDIUM medium = { TYMED_NULL, NULL, NULL };
  1453.     DSDISPLAYSPECOPTIONS *pddso = NULL;;
  1454.     DWORD cbStruct = SIZEOF(DSDISPLAYSPECOPTIONS);
  1455.     DWORD offsetStrings = SIZEOF(DSDISPLAYSPECOPTIONS);
  1456.     LPWSTR pAttribPrefix = _pAttribPrefix;
  1458.     TraceEnter(TRACE_FOLDER, "CDsFolder::_SetAttribPrefix");
  1460.     if ( !pAttribPrefix )
  1461.         pAttribPrefix = DS_PROP_SHELL_PREFIX;        
  1463.     cbStruct += StringByteSizeW(pAttribPrefix);
  1464.     cbStruct += StringByteSizeW(_pUserName);
  1465.     cbStruct += StringByteSizeW(_pPassword);
  1466.     cbStruct += StringByteSizeW(_pServer);
  1468.     // allocate and fill the structure
  1470.     hres = AllocStorageMedium(&fmte, &medium, cbStruct, (void **)&pddso);
  1471.     FailGracefully(hres, "Failed to allocate STGMEDIUM for data");
  1473.     pddso->dwSize = SIZEOF(DSDISPLAYSPECOPTIONS);
  1474.     pddso->dwFlags = DSDSOF_HASUSERANDSERVERINFO|DSDSOF_DSAVAILABLE;
  1476.     //pddso->offsetAttribPrefix = 0x0;
  1477.     //pddso->offsetUserName = 0x0;
  1478.     //pddso->offsetPassword = 0x0;
  1479.     //pddso->offsetServer = 0x0;
  1480.     //pddso->offsetServerConfigPath = 0x0;
  1482.     pddso->offsetAttribPrefix = offsetStrings;
  1483.     StringByteCopyW(pddso, offsetStrings, pAttribPrefix);
  1484.     offsetStrings += StringByteSizeW(pAttribPrefix);
  1486.     if ( _pUserName )
  1487.     {
  1488.         pddso->offsetUserName = offsetStrings;
  1489.         StringByteCopyW(pddso, offsetStrings, _pUserName);
  1490.         offsetStrings += StringByteSizeW(_pUserName);
  1491.     }
  1493.     if ( _pPassword )
  1494.     {
  1495.         pddso->offsetPassword = offsetStrings;
  1496.         StringByteCopyW(pddso, offsetStrings, _pPassword);
  1497.         offsetStrings += StringByteSizeW(_pPassword);
  1498.     }
  1500.     if ( _pServer )
  1501.     {
  1502.         pddso->offsetServer = offsetStrings;
  1503.         StringByteCopyW(pddso, offsetStrings, _pServer);
  1504.         offsetStrings += StringByteSizeW(_pServer);
  1505.     }
  1507.     // lets set into the IDataObject
  1509.     TraceMsg("Setting CF_DSDISPLAYSPECOPTIONS into the IDataObject");
  1511.     hres = pdo->SetData(&fmte, &medium, TRUE);
  1512.     FailGracefully(hres, "Failed to set the DSDISPLAYSPECOPTIONS into the IDataObject");
  1514. exit_gracefully:
  1516.     ReleaseStgMedium(&medium);
  1518.     TraceLeaveResult(hres);
  1519. }
  1521. STDMETHODIMP CDsFolder::GetUIObjectOf(HWND hwndOwner, UINT cidl, LPCITEMIDLIST* aidl, REFIID riid, UINT* prgfReserved, void **ppv)
  1522. {
  1523.     HRESULT hres;
  1524.     LPITEMIDLIST pidlAbs = NULL;
  1525.     HKEY aKeys[UIKEY_MAX];
  1526.     LPITEMIDLIST pidl = NULL;
  1527.     INT i;
  1529.     TraceEnter(TRACE_FOLDER, "CDsFolder::GetUIObjectOf");
  1530.     TraceGUID("UI object requested", riid);
  1532.     TraceAssert(cidl > 0);
  1533.     TraceAssert(aidl);
  1534.     TraceAssert(ppv);
  1536.     ZeroMemory(aKeys, SIZEOF(aKeys));
  1538.     if ( IsEqualIID(riid, IID_IContextMenu) )
  1539.     {
  1540.         // IContextMenu requested, therefore lets use the shell to construct one for us,
  1541.         // then we can provide verbs on the namespace
  1543.         if ( cidl )
  1544.         {
  1545.             hres = GetKeysForIdList(*aidl, NULL, ARRAYSIZE(aKeys), aKeys);
  1546.             FailGracefully(hres, "Failed to get object keys");
  1547.         }
  1549.         hres = CDefFolderMenu_Create2(_pidl, hwndOwner,
  1550.                                     cidl, aidl,
  1551.                                     this,
  1552.                                     _FolderCFMCallback,
  1553.                                     ARRAYSIZE(aKeys), aKeys,
  1554.                                     (LPCONTEXTMENU*)ppv);
  1556.         FailGracefully(hres, "Failed to create context menu");
  1557.     }
  1558.     else if ( IsEqualIID(riid, IID_IDataObject) )
  1559.     {
  1560.         DSDATAOBJINIT ddoi = { 0 };
  1561.         IDataObject *pdo = NULL;
  1563.         ddoi.hwnd = hwndOwner;
  1564.         ddoi.pidlRoot = _pidl;
  1565.         ddoi.cbOffset = _cbOffset;
  1566.         ddoi.cidl = cidl;
  1567.         ddoi.aidl = aidl;
  1568.         ddoi.dwProviderAND = _dwProviderAND;
  1569.         ddoi.dwProviderXOR = _dwProviderXOR;
  1571.         hres = CDsDataObject_CreateInstance(&ddoi, IID_IDataObject, (void **)&pdo);
  1572.         FailGracefully(hres, "Failed to create the IDataObject");
  1574.         hres = _SetDispSpecOptions(pdo);
  1575.         FailGracefully(hres, "Failed to set the display spec options");
  1577.         hres = pdo->QueryInterface(riid, ppv);
  1578.         pdo->Release();
  1579.     }
  1580.     else if ( IsEqualIID(riid, IID_IExtractIcon) )
  1581.     {
  1582.         // IExtractIcon is used to support our object extraction, we can only cope
  1583.         // with extracting a single object at a time.  First however we must
  1584.         // build an IDLIST that represents the object we want to extract
  1585.         // and get the icon for it.
  1587.         if ( cidl != 1 )
  1588.             ExitGracefully(hres, E_FAIL, "Bad number of objects to get icon from");
  1590.         pidl = ILCombine(_pidl, *aidl);
  1591.         TraceAssert(pidl);
  1593.         Trace(TEXT("_pidl %08x, *aidl %08x, _cbOffset %d"), _pidl, *aidl, _cbOffset);
  1595.         if ( !pidl )
  1596.             ExitGracefully(hres, E_OUTOFMEMORY, "Failed to combine the IDLISTs");
  1598.         hres = _GetDsDisplaySpecifier();
  1599.         FailGracefully(hres, "Failed to get the IDsDisplaySpecifier object");
  1601.         CDsExtractIcon* pExtractIcon = new CDsExtractIcon(_pdds, _ILSkip(pidl, _cbOffset));
  1602.         TraceAssert(pExtractIcon);
  1604.         if ( !pExtractIcon )
  1605.             ExitGracefully(hres, E_OUTOFMEMORY, "Failed to create CDsExtractIcon");
  1607.         hres = pExtractIcon->QueryInterface(riid, ppv);
  1608.         pExtractIcon->Release();
  1609.     }
  1610.     else
  1611.     {
  1612.         ExitGracefully(hres, E_NOINTERFACE, "UI object not supported");
  1613.     }
  1615. exit_gracefully:
  1617.     TidyKeys(ARRAYSIZE(aKeys), aKeys);
  1619.     DoILFree(pidl);
  1620.         
  1621.     TraceLeaveResult(hres);
  1622. }
  1624. /*---------------------------------------------------------------------------*/
  1626. STDMETHODIMP CDsFolder::GetDisplayNameOf(LPCITEMIDLIST pidl, DWORD uFlags, LPSTRRET pName)
  1627. {
  1628.     HRESULT hres = E_FAIL;
  1629.     LPITEMIDLIST pidlFull = NULL;
  1630.     LPITEMIDLIST pidlRight = NULL;
  1631.     IDLISTDATA data =  {0};
  1632.     IShellFolder *psf = NULL;
  1633.     LPWSTR pPath = NULL;
  1634.     BSTR bstrName = NULL;
  1635.     USES_CONVERSION;
  1636.     DECLAREWAITCURSOR = GetCursor();
  1638.     TraceEnter(TRACE_FOLDER, "CDsFolder::GetDisplayName");
  1640.     pidlFull = ILCombine(_pidl, pidl);
  1641.     TraceAssert(pidlFull);
  1642.          
  1643.     if ( !pidlFull )
  1644.         ExitGracefully(hres, E_OUTOFMEMORY, "Failed to combine PIDLs");
  1646.     // attempt to get the junction namespace, if not then we must convert the name,
  1647.     // if it is a junction the handle accordingly.
  1649.     hres = _GetJunctionSF(pidlFull, NULL, &data, &pidlRight, &psf);
  1650.     if ( SUCCEEDED(hres))
  1651.     {
  1652.         hres = _GetPathname();
  1653.         FailGracefully(hres, "Failed to get the IADsPathname interface");
  1655.         if ( (hres == S_FALSE) || !pidlRight || ILIsEmpty(pidlRight) )
  1656.         {
  1657.             TraceMsg("We don't have a trailing pidl, and its not a junction");
  1659.             // check to see if the name is the junction, and if we are requesting the 
  1660.             // for parsing && !in folder.  if that is valid then return the
  1661.             // junction name.
  1663.             if ( data.pUNC && (uFlags & SHGDN_FORPARSING) && !(uFlags & SHGDN_INFOLDER) )
  1664.             {
  1665.                 TraceMsg("Return the full parsing name of the junction");
  1667.                 // the junction is hit, pidlRight is NULL but the caller wants
  1668.                 // the for parsing version of the name which is not-infolder (phew).
  1670.                 hres = _StrRetFromString(pName, W2T(data.pUNC));
  1671.                 FailGracefully(hres, "Failed to get parsing juntion name");
  1672.             }
  1673.             else
  1674.             {
  1675.                 TraceMsg("Return path/name of DS object");
  1677.                 // pre-populate the IADsPathname object with a path to be
  1678.                 // worked on.
  1680.                 hres = PathFromIdList(_ILSkip(pidlFull, _cbOffset), &pPath, _padp);
  1681.                 FailGracefully(hres, "Failed to get the DS path");
  1683.                 hres = _padp->Set(pPath, ADS_SETTYPE_FULL);
  1684.                 FailGracefully(hres, "Failed to set the path of the name");
  1686.                 if ( uFlags & SHGDN_INFOLDER )
  1687.                 {
  1688.                     //
  1689.                     // get the in folder name, including removing all the crap if we can
  1690.                     //
  1692.                     if ( !(uFlags & SHGDN_FORPARSING) && data.pName )
  1693.                     {
  1694.                         hres = _StrRetFromString(pName, W2T(data.pName));
  1695.                     }
  1696.                     else
  1697.                     {
  1698.                         if ( !(uFlags & SHGDN_FORPARSING) )
  1699.                             _padp->SetDisplayType(ADS_DISPLAY_VALUE_ONLY);
  1701.                         hres = _padp->Retrieve(ADS_FORMAT_LEAF, &bstrName);
  1702.                         FailGracefully(hres, "Failed to get the pretty name");
  1704.                         hres = _StrRetFromString(pName, W2T(bstrName));
  1705.                     }
  1706.                 }
  1707.                 else
  1708.                 {
  1709.                     //
  1710.                     // get the display name from the ADsPath we have - convert to conanical format
  1711.                     // for displaying in the title / wbe view
  1712.                     //
  1714.                     WCHAR szBuffer[MAX_PATH];
  1716.                     hres = GetDisplayNameFromADsPath(NULL, szBuffer, ARRAYSIZE(szBuffer), _padp, TRUE);
  1717.                     FailGracefully(hres, "Failed to get display name from ADsPath");
  1719.                     hres = _StrRetFromString(pName, W2T(szBuffer));
  1720.                 }
  1722.                 FailGracefully(hres, "Failed to convert to BSTR");
  1723.             }
  1724.         }
  1725.         else
  1726.         {
  1727.             TraceMsg("Requesting name from junction object");
  1729.             // the pidlRight is non-null (therefore we must delegate) so 
  1730.             // lets call the psf we have to get the DisplayName of the object.
  1732.             hres = psf->GetDisplayNameOf(pidlRight, uFlags, pName);
  1733.         }
  1734.     }
  1736. exit_gracefully:
  1738.     DoRelease(psf);
  1740.     DoILFree(pidlFull);
  1741.     DoILFree(pidlRight);
  1743.     LocalFreeStringW(&pPath);
  1744.     SysFreeString(bstrName);
  1746.     ResetWaitCursor();
  1748.     TraceLeaveResult(hres);
  1749. }
  1751. /*---------------------------------------------------------------------------*/
  1753. STDMETHODIMP CDsFolder::SetNameOf(HWND hwndOwner, LPCITEMIDLIST pidl, LPCOLESTR pName, DWORD uFlags, LPITEMIDLIST * ppidlOut)
  1754. {
  1755.     TraceEnter(TRACE_FOLDER, "CDsFolder::SetDisplayNameOf");
  1756.     TraceLeaveResult(E_NOTIMPL);
  1757. }
  1760. /*-----------------------------------------------------------------------------
  1761. / CDsExtractIcon
  1762. /----------------------------------------------------------------------------*/
  1764. CDsExtractIcon::CDsExtractIcon(IDsDisplaySpecifier *pdds, LPCITEMIDLIST pidl) :
  1765.     _pdds(pdds)
  1766. {
  1767.     TraceEnter(TRACE_UI, "CDsExtractIcon::CDsExtractIcon");
  1768.     
  1769.     _pidl = ILClone(pidl);
  1770.     _pdds->AddRef();
  1771.     
  1772.     TraceLeaveVoid();
  1773. }
  1775. CDsExtractIcon::~CDsExtractIcon()
  1776. {
  1777.     TraceEnter(TRACE_UI, "CDsExtractIcon::~CDsExtractIcon");
  1779.     DoILFree(_pidl);
  1780.     DoRelease(_pdds);
  1782.     TraceLeaveVoid();
  1783. }
  1785. // IUnknown bits
  1787. #undef CLASS_NAME
  1788. #define CLASS_NAME CDsExtractIcon
  1789. #include "unknown.inc"
  1791. STDMETHODIMP CDsExtractIcon::QueryInterface(REFIID riid, void **ppv)
  1792. {
  1793.     INTERFACES iface[] =
  1794.     {
  1795.         &IID_IExtractIcon, (LPEXTRACTICON)this,
  1796.     };
  1798.     return HandleQueryInterface(riid, ppv, iface, ARRAYSIZE(iface));
  1799. }
  1802. /*-----------------------------------------------------------------------------
  1803. / IExtractIcon methods
  1804. /----------------------------------------------------------------------------*/
  1806. STDMETHODIMP CDsExtractIcon::GetIconLocation(UINT uFlags, LPTSTR szIconFile, UINT cchMax, INT* pIndex, UINT* pwFlags)
  1807. {
  1808.     HRESULT hres;
  1809.     LPTSTR pLocation = NULL;
  1810.     IDLISTDATA data;
  1811.     DWORD dwFlags = 0;
  1812. #ifndef UNICODE
  1813.     WCHAR szIconLocation[MAX_PATH];
  1814. #endif
  1815.     USES_CONVERSION;
  1817.     TraceEnter(TRACE_UI, "CDsExtractIcon::GetIconLocation");
  1819.     if ( !_pidl || ILIsEmpty(_pidl) )
  1820.         ExitGracefully(hres, E_INVALIDARG, "No IDLIST to extract icon from");
  1822.     // If we have an empty IDLIST then lets ensure that we get the the icon location
  1823.     // for the namespace root.  Otherwise unpack the IDLIST and get the icon location
  1824.     // from the cache.
  1826.     hres = UnpackIdList(ILFindLastID(_pidl), DSIDL_HASCLASS, &data);
  1827.     FailGracefully(hres, "Failed to unpack IDLIST");
  1829.     dwFlags |= (uFlags & GIL_OPENICON) ?  DSGIF_ISOPEN:DSGIF_ISNORMAL;
  1831. #ifdef UNICODE
  1832.     hres = _pdds->GetIconLocation(data.pObjectClass, dwFlags, szIconFile, cchMax, pIndex);
  1833.     FailGracefully(hres, "Failed to get the icon location");            
  1834. #else
  1835.     // when building ANSI we must call the DsGetIcon location to get the icon
  1836.     // we are interested in, this API is ANSI only and therefore we must
  1837.     // thunk the call back as required.
  1839.     hres = _pdds->GetIconLocation(data.pObjectClass, dwFlags, szIconLocation, ARRAYSIZE(szIconLocation), pIndex);
  1840.     FailGracefully(hres, "Failed to get the icon location");            
  1842.     if ( hres != S_FALSE )
  1843.     {
  1844.         WideCharToMultiByte(CP_ACP, 0, szIconLocation, -1, szIconFile, cchMax, 0, FALSE);
  1845.         Trace(TEXT("Thunked icon location: %s"), szIconFile);
  1846.     }
  1847. #endif    
  1849. exit_gracefully:
  1851.     LocalFreeString(&pLocation);
  1853.     TraceLeaveResult(hres);
  1854. }
  1856. /*---------------------------------------------------------------------------*/
  1858. STDMETHODIMP CDsExtractIcon::Extract(LPCTSTR pszIconFile, UINT nIconIndex, HICON* pLargeIcon, HICON* pSmallIcon, UINT nIconSize)
  1859. {
  1860.     return S_FALSE;         // let the shell extract the image
  1861. }
  1864. /*----------------------------------------------------------------------------
  1865. / PropertyUI iface for the query UI to invoke use with
  1866. /----------------------------------------------------------------------------*/
  1868. // IUnknown handlers
  1870. #undef CLASS_NAME
  1871. #define CLASS_NAME CDsFolderProperties
  1872. #include "unknown.inc"
  1874. STDMETHODIMP CDsFolderProperties::QueryInterface( REFIID riid, void **ppv)
  1875. {
  1876.     INTERFACES iface[] =
  1877.     {
  1878.         &IID_IDsFolderProperties, (IDsFolderProperties*)this,
  1879.     };
  1881.    return HandleQueryInterface(riid, ppv, iface, ARRAYSIZE(iface));
  1882. }
  1884. //
  1885. // handle create instance of the CDsFolder object
  1886. //
  1888. STDAPI CDsFolderProperties_CreateInstance(IUnknown* punkOuter, IUnknown** ppunk, LPCOBJECTINFO poi)
  1889. {
  1890.     CDsFolderProperties *pdfp = new CDsFolderProperties();
  1891.     if ( !pdfp )
  1892.         return E_OUTOFMEMORY;
  1894.     HRESULT hres = pdfp->QueryInterface(IID_IUnknown, (void **)ppunk);
  1895.     pdfp->Release();
  1896.     return hres;
  1897. }
  1900. /*----------------------------------------------------------------------------
  1901. / IDsFolderProperties
  1902. /----------------------------------------------------------------------------*/
  1904. /*-----------------------------------------------------------------------------
  1905. / IDsFolderProperties::ShowProperties
  1906. / -----------------------------------
  1907. /   Display the property page set that relates to the given IDataObject, it is
  1908. /   assumed that the caller is passing a IDataObject containing a valid DS
  1909. /   clipboard data blob.
  1910. /
  1911. / In:
  1912. /   hwndParent = parent window for the dialog
  1913. /   pDataObject -> data object containing the sleection data
  1914. /
  1915. / Out:
  1916. /   HRESULT
  1917. /----------------------------------------------------------------------------*/
  1918. STDMETHODIMP CDsFolderProperties::ShowProperties(HWND hwndParent, IDataObject *pDataObject)
  1919. {
  1920.     HRESULT hres;
  1922.     TraceEnter(TRACE_API, "CDsFolderProperties::ShowProperties");
  1924.     if ( !pDataObject )  
  1925.         ExitGracefully(hres, E_INVALIDARG, "No pDataObject given");
  1927.     CoInitialize(NULL);            // ensure we have COM
  1929.     hres = ShowObjectProperties(hwndParent, pDataObject);
  1930.     FailGracefully(hres, "Failed to open property pages");
  1932.     // hres = S_OK;               // success
  1934. exit_gracefully:
  1936.     TraceLeaveResult(hres);        
  1937. }