reactos/dll/win32/shell32/folders/CDesktopFolder.cpp

   1 /*
   2  *    Virtual Desktop Folder
   3  *
   4  *    Copyright 1997                Marcus Meissner
   5  *    Copyright 1998, 1999, 2002    Juergen Schmied
   6  *    Copyright 2009                Andrew Hill
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <precomp.h>
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  26
  27 /*
  28 CDesktopFolder should create two file system folders internally, one representing the
  29 user's desktop folder, and the other representing the common desktop folder. It should
  30 also create a CRegFolder to represent the virtual items that exist only in the registry.
  31 The CRegFolder is aggregated by the CDesktopFolder, and queries for the CLSID_IShellFolder,
  32 CLSID_IShellFolder2, or CLSID_IShellIconOverlay interfaces prefer the CRegFolder
  33 implementation.
  34 The CDesktopFolderEnum class should create two enumerators, one for each of the file
  35 system folders, and enumerate the contents of each folder. Since the CRegFolder
  36 implementation of IShellFolder::EnumObjects enumerates the virtual items, the
  37 CDesktopFolderEnum is only responsible for returning the physical items.
  38 CDesktopFolderEnum is incorrect where it filters My Computer from the enumeration
  39 if the new start menu is used. The CDesktopViewCallback is responsible for filtering
  40 it from the view by handling the IncludeObject query to return S_FALSE. The enumerator
  41 always shows My Computer.
  42 */
  43
  44 /* Undocumented functions from shdocvw */
  45 extern "C" HRESULT WINAPI IEParseDisplayNameWithBCW(DWORD codepage, LPCWSTR lpszDisplayName, LPBC pbc, LPITEMIDLIST *ppidl);
  46
  47 class CDesktopFolderEnum :
  48     public CEnumIDListBase
  49 {
  50     private:
  51 //    CComPtr                                fDesktopEnumerator;
  52 //    CComPtr                                fCommonDesktopEnumerator;
  53     public:
  54         CDesktopFolderEnum();
  55         ~CDesktopFolderEnum();
  56         HRESULT WINAPI Initialize(CDesktopFolder *desktopFolder, HWND hwndOwner, DWORD dwFlags);
  57
  58         BEGIN_COM_MAP(CDesktopFolderEnum)
  59         COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
  60         END_COM_MAP()
  61 };
  62
  63 int SHELL_ConfirmMsgBox(HWND hWnd, LPWSTR lpszText, LPWSTR lpszCaption, HICON hIcon, BOOL bYesToAll);
  64
  65 static const shvheader DesktopSFHeader[] = {
  66     {IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 15},
  67     {IDS_SHV_COLUMN2, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
  68     {IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 10},
  69     {IDS_SHV_COLUMN4, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT, 12},
  70 };
  71
  72 #define DESKTOPSHELLVIEWCOLUMNS 4
  73
  74 static const DWORD dwDesktopAttributes =
  75     SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR |
  76     SFGAO_STORAGEANCESTOR | SFGAO_HASPROPSHEET | SFGAO_STORAGE | SFGAO_CANLINK;
  77 static const DWORD dwMyComputerAttributes =
  78     SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
  79     SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_CANLINK;
  80 static DWORD dwMyNetPlacesAttributes =
  81     SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
  82     SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_CANLINK;
  83
  84
  85 CDesktopFolderEnum::CDesktopFolderEnum()
  86 {
  87 }
  88
  89 CDesktopFolderEnum::~CDesktopFolderEnum()
  90 {
  91 }
  92
  93 static const WCHAR ClassicStartMenuW[] = L"SOFTWARE\\Microsoft\\Windows\\"
  94     L"CurrentVersion\\Explorer\\HideDesktopIcons\\ClassicStartMenu";
  95
  96 static INT
  97 IsNamespaceExtensionHidden(const WCHAR *iid)
  98 {
  99     DWORD Result, dwResult;
 100     dwResult = sizeof(DWORD);
 101
 102     if (RegGetValueW(HKEY_CURRENT_USER, /* FIXME use NewStartPanel when activated */
 103                      ClassicStartMenuW,
 104                      iid,
 105                      RRF_RT_DWORD,
 106                      NULL,
 107                      &Result,
 108                      &dwResult) != ERROR_SUCCESS)
 109     {
 110         return -1;
 111     }
 112
 113     return Result;
 114 }
 115
 116 /**************************************************************************
 117  *  CreateDesktopEnumList()
 118  */
 119
 120 HRESULT WINAPI CDesktopFolderEnum::Initialize(CDesktopFolder *desktopFolder, HWND hwndOwner, DWORD dwFlags)
 121 {
 122     BOOL ret = TRUE;
 123     WCHAR szPath[MAX_PATH];
 124
 125     static const WCHAR MyDocumentsClassString[] = L"{450D8FBA-AD25-11D0-98A8-0800361B1103}";
 126     static const WCHAR Desktop_NameSpaceW[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Desktop\\Namespace";
 127
 128     TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
 129
 130     /* enumerate the root folders */
 131     if (dwFlags & SHCONTF_FOLDERS)
 132     {
 133         HKEY hkey;
 134         UINT i;
 135         DWORD dwResult;
 136
 137         /* create the pidl for This item */
 138         if (IsNamespaceExtensionHidden(MyDocumentsClassString) < 1)
 139         {
 140             ret = AddToEnumList(_ILCreateMyDocuments());
 141         }
 142         ret = AddToEnumList(_ILCreateMyComputer());
 143
 144         for (i = 0; i < 2; i++)
 145         {
 146             if (i == 0)
 147                 dwResult = RegOpenKeyExW(HKEY_LOCAL_MACHINE, Desktop_NameSpaceW, 0, KEY_READ, &hkey);
 148             else
 149                 dwResult = RegOpenKeyExW(HKEY_CURRENT_USER, Desktop_NameSpaceW, 0, KEY_READ, &hkey);
 150
 151             if (dwResult == ERROR_SUCCESS)
 152             {
 153                 WCHAR iid[50];
 154                 LPITEMIDLIST pidl;
 155                 int i = 0;
 156
 157                 while (ret)
 158                 {
 159                     DWORD size;
 160                     LONG r;
 161
 162                     size = sizeof (iid) / sizeof (iid[0]);
 163                     r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
 164                     if (ERROR_SUCCESS == r)
 165                     {
 166                         if (IsNamespaceExtensionHidden(iid) < 1)
 167                         {
 168                             pidl = _ILCreateGuidFromStrW(iid);
 169                             if (pidl != NULL)
 170                             {
 171                                 if (!HasItemWithCLSID(pidl))
 172                                 {
 173                                     ret = AddToEnumList(pidl);
 174                                 }
 175                                 else
 176                                 {
 177                                     SHFree(pidl);
 178                                 }
 179                             }
 180                         }
 181                     }
 182                     else if (ERROR_NO_MORE_ITEMS == r)
 183                         break;
 184                     else
 185                         ret = FALSE;
 186                     i++;
 187                 }
 188                 RegCloseKey(hkey);
 189             }
 190         }
 191         for (i = 0; i < 2; i++)
 192         {
 193             if (i == 0)
 194                 dwResult = RegOpenKeyExW(HKEY_LOCAL_MACHINE, ClassicStartMenuW, 0, KEY_READ, &hkey);
 195             else
 196                 dwResult = RegOpenKeyExW(HKEY_CURRENT_USER, ClassicStartMenuW, 0, KEY_READ, &hkey);
 197
 198             if (dwResult == ERROR_SUCCESS)
 199             {
 200                 DWORD j = 0, dwVal, Val, dwType, dwIID;
 201                 LONG r;
 202                 WCHAR iid[50];
 203
 204                 while(ret)
 205                 {
 206                     dwVal = sizeof(Val);
 207                     dwIID = sizeof(iid) / sizeof(WCHAR);
 208
 209                     r = RegEnumValueW(hkey, j++, iid, &dwIID, NULL, &dwType, (LPBYTE)&Val, &dwVal);
 210                     if (r == ERROR_SUCCESS)
 211                     {
 212                         if (Val == 0 && dwType == REG_DWORD)
 213                         {
 214                             LPITEMIDLIST pidl = _ILCreateGuidFromStrW(iid);
 215                             if (pidl != NULL)
 216                             {
 217                                 if (!HasItemWithCLSID(pidl))
 218                                 {
 219                                     AddToEnumList(pidl);
 220                                 }
 221                                 else
 222                                 {
 223                                     SHFree(pidl);
 224                                 }
 225                             }
 226                         }
 227                     }
 228                     else if (ERROR_NO_MORE_ITEMS == r)
 229                         break;
 230                     else
 231                         ret = FALSE;
 232                 }
 233                 RegCloseKey(hkey);
 234             }
 235
 236         }
 237     }
 238
 239     /* enumerate the elements in %windir%\desktop */
 240     ret = ret && SHGetSpecialFolderPathW(0, szPath, CSIDL_DESKTOPDIRECTORY, FALSE);
 241     ret = ret && CreateFolderEnumList(szPath, dwFlags);
 242
 243     ret = ret && SHGetSpecialFolderPathW(0, szPath, CSIDL_COMMON_DESKTOPDIRECTORY, FALSE);
 244     ret = ret && CreateFolderEnumList(szPath, dwFlags);
 245
 246     return ret ? S_OK : E_FAIL;
 247 }
 248
 249 CDesktopFolder::CDesktopFolder() :
 250     sPathTarget(NULL),
 251     pidlRoot(NULL)
 252 {
 253 }
 254
 255 CDesktopFolder::~CDesktopFolder()
 256 {
 257 }
 258
 259 HRESULT WINAPI CDesktopFolder::FinalConstruct()
 260 {
 261     WCHAR szMyPath[MAX_PATH];
 262     HRESULT hr;
 263
 264     /* Create the root pidl */
 265     pidlRoot = _ILCreateDesktop();
 266     if (!pidlRoot)
 267         return E_OUTOFMEMORY;
 268
 269     /* Create the inner fs folder */
 270     hr = SHELL32_CoCreateInitSF(pidlRoot,
 271                                 NULL,
 272                                 NULL,
 273                                 &CLSID_ShellFSFolder,
 274                                 CSIDL_DESKTOPDIRECTORY,
 275                                 IID_PPV_ARG(IShellFolder2, &m_DesktopFSFolder));
 276     if (FAILED_UNEXPECTEDLY(hr))
 277         return hr;
 278
 279     /* Create the inner shared fs folder. Dont fail on failure. */
 280     hr = SHELL32_CoCreateInitSF(pidlRoot,
 281                                 NULL,
 282                                 NULL,
 283                                 &CLSID_ShellFSFolder,
 284                                 CSIDL_COMMON_DESKTOPDIRECTORY,
 285                                 IID_PPV_ARG(IShellFolder2, &m_SharedDesktopFSFolder));
 286     if (FAILED_UNEXPECTEDLY(hr))
 287         return hr;
 288
 289     /* Create the inner reg folder */
 290     hr = CRegFolder_CreateInstance(&CLSID_ShellDesktop,
 291                                    pidlRoot,
 292                                    L"",
 293                                    IID_PPV_ARG(IShellFolder2, &m_regFolder));
 294     if (FAILED_UNEXPECTEDLY(hr))
 295         return hr;
 296
 297     /* Cache the path to the user desktop directory */
 298     if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE ))
 299         return E_UNEXPECTED;
 300
 301     sPathTarget = (LPWSTR)SHAlloc((wcslen(szMyPath) + 1) * sizeof(WCHAR));
 302     if (!sPathTarget)
 303         return E_OUTOFMEMORY;
 304
 305     wcscpy(sPathTarget, szMyPath);
 306     return S_OK;
 307 }
 308
 309 HRESULT CDesktopFolder::_GetSFFromPidl(LPCITEMIDLIST pidl, IShellFolder2** psf)
 310 {
 311     WCHAR szFileName[MAX_PATH];
 312
 313     if (_ILIsSpecialFolder(pidl))
 314         return m_regFolder->QueryInterface(IID_PPV_ARG(IShellFolder2, psf));
 315
 316     lstrcpynW(szFileName, sPathTarget, MAX_PATH - 1);
 317     PathAddBackslashW(szFileName);
 318     int cLen = wcslen(szFileName);
 319
 320     if (!_ILSimpleGetTextW(pidl, szFileName + cLen, MAX_PATH - cLen))
 321         return E_FAIL;
 322
 323     if (GetFileAttributes(szFileName) == INVALID_FILE_ATTRIBUTES)
 324         return m_SharedDesktopFSFolder->QueryInterface(IID_PPV_ARG(IShellFolder2, psf));
 325     else
 326         return m_DesktopFSFolder->QueryInterface(IID_PPV_ARG(IShellFolder2, psf));
 327 }
 328
 329 /**************************************************************************
 330  *    CDesktopFolder::ParseDisplayName
 331  *
 332  * NOTES
 333  *    "::{20D04FE0-3AEA-1069-A2D8-08002B30309D}" and "" binds
 334  *    to MyComputer
 335  */
 336 HRESULT WINAPI CDesktopFolder::ParseDisplayName(
 337     HWND hwndOwner,
 338     LPBC pbc,
 339     LPOLESTR lpszDisplayName,
 340     DWORD *pchEaten,
 341     PIDLIST_RELATIVE *ppidl,
 342     DWORD *pdwAttributes)
 343 {
 344     LPCWSTR szNext = NULL;
 345     LPITEMIDLIST pidlTemp = NULL;
 346     PARSEDURLW urldata;
 347     HRESULT hr = S_OK;
 348
 349     TRACE ("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n",
 350            this, hwndOwner, pbc, lpszDisplayName, debugstr_w(lpszDisplayName),
 351            pchEaten, ppidl, pdwAttributes);
 352
 353     if (!ppidl)
 354         return E_INVALIDARG;
 355
 356     *ppidl = NULL;
 357
 358     if (!lpszDisplayName)
 359         return E_INVALIDARG;
 360
 361     if (pchEaten)
 362         *pchEaten = 0;        /* strange but like the original */
 363
 364     urldata.cbSize = sizeof(urldata);
 365
 366     if (lpszDisplayName[0] == ':' && lpszDisplayName[1] == ':')
 367     {
 368         return m_regFolder->ParseDisplayName(hwndOwner, pbc, lpszDisplayName, pchEaten, ppidl, pdwAttributes);
 369     }
 370     else if (PathGetDriveNumberW (lpszDisplayName) >= 0)
 371     {
 372         /* it's a filesystem path with a drive. Let MyComputer/UnixDosFolder parse it */
 373         pidlTemp = _ILCreateMyComputer ();
 374         szNext = lpszDisplayName;
 375     }
 376     else if (PathIsUNCW(lpszDisplayName))
 377     {
 378         pidlTemp = _ILCreateNetwork();
 379         szNext = lpszDisplayName;
 380     }
 381     else if( (pidlTemp = SHELL32_CreatePidlFromBindCtx(pbc, lpszDisplayName)) )
 382     {
 383         *ppidl = pidlTemp;
 384         return S_OK;
 385     }
 386     else if (SUCCEEDED(ParseURLW(lpszDisplayName, &urldata)))
 387     {
 388         if (urldata.nScheme == URL_SCHEME_SHELL) /* handle shell: urls */
 389         {
 390             TRACE ("-- shell url: %s\n", debugstr_w(urldata.pszSuffix));
 391             pidlTemp = _ILCreateGuidFromStrW(urldata.pszSuffix + 2);
 392         }
 393         else
 394             return IEParseDisplayNameWithBCW(CP_ACP, lpszDisplayName, pbc, ppidl);
 395     }
 396     else
 397     {
 398         if (*lpszDisplayName)
 399         {
 400             /* it's a filesystem path on the desktop. Let a FSFolder parse it */
 401             hr = m_DesktopFSFolder->ParseDisplayName(hwndOwner, pbc, lpszDisplayName, pchEaten, ppidl, pdwAttributes);
 402             if (SUCCEEDED(hr))
 403                 return hr;
 404
 405             return m_SharedDesktopFSFolder->ParseDisplayName(hwndOwner, pbc, lpszDisplayName, pchEaten, ppidl, pdwAttributes);
 406         }
 407         else
 408             pidlTemp = _ILCreateMyComputer();
 409
 410         szNext = NULL;
 411     }
 412
 413     if (SUCCEEDED(hr) && pidlTemp)
 414     {
 415         if (szNext && *szNext)
 416         {
 417             hr = SHELL32_ParseNextElement(this, hwndOwner, pbc,
 418                                           &pidlTemp, (LPOLESTR) szNext, pchEaten, pdwAttributes);
 419         }
 420         else
 421         {
 422             if (pdwAttributes && *pdwAttributes)
 423             {
 424                 GetAttributesOf(1, &pidlTemp, pdwAttributes);
 425             }
 426         }
 427     }
 428
 429     if (SUCCEEDED(hr))
 430         *ppidl = pidlTemp;
 431     else
 432         *ppidl = NULL;
 433
 434     TRACE ("(%p)->(-- ret=0x%08x)\n", this, hr);
 435
 436     return hr;
 437 }
 438
 439 /**************************************************************************
 440  *        CDesktopFolder::EnumObjects
 441  */
 442 HRESULT WINAPI CDesktopFolder::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 443 {
 444     return ShellObjectCreatorInit<CDesktopFolderEnum>(this, hwndOwner, dwFlags, IID_IEnumIDList, ppEnumIDList);
 445 }
 446
 447 /**************************************************************************
 448  *        CDesktopFolder::BindToObject
 449  */
 450 HRESULT WINAPI CDesktopFolder::BindToObject(
 451     PCUIDLIST_RELATIVE pidl,
 452     LPBC pbcReserved,
 453     REFIID riid,
 454     LPVOID *ppvOut)
 455 {
 456     if (!pidl)
 457         return E_INVALIDARG;
 458
 459     CComPtr<IShellFolder2> psf;
 460     HRESULT hr = _GetSFFromPidl(pidl, &psf);
 461     if (FAILED_UNEXPECTEDLY(hr))
 462         return hr;
 463
 464     return psf->BindToObject(pidl, pbcReserved, riid, ppvOut);
 465 }
 466
 467 /**************************************************************************
 468  *    CDesktopFolder::BindToStorage
 469  */
 470 HRESULT WINAPI CDesktopFolder::BindToStorage(
 471     PCUIDLIST_RELATIVE pidl,
 472     LPBC pbcReserved,
 473     REFIID riid,
 474     LPVOID *ppvOut)
 475 {
 476     FIXME ("(%p)->(pidl=%p,%p,%s,%p) stub\n",
 477            this, pidl, pbcReserved, shdebugstr_guid (&riid), ppvOut);
 478
 479     *ppvOut = NULL;
 480     return E_NOTIMPL;
 481 }
 482
 483 /**************************************************************************
 484  *     CDesktopFolder::CompareIDs
 485  */
 486 HRESULT WINAPI CDesktopFolder::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 487 {
 488     bool bIsDesktopFolder1, bIsDesktopFolder2;
 489
 490     if (!pidl1 || !pidl2)
 491     {
 492         ERR("Got null pidl pointer (%Ix %p %p)!\n", lParam, pidl1, pidl2);
 493         return E_INVALIDARG;
 494     }
 495
 496     bIsDesktopFolder1 = _ILIsDesktop(pidl1);
 497     bIsDesktopFolder2 = _ILIsDesktop(pidl2);
 498     if (bIsDesktopFolder1 || bIsDesktopFolder2)
 499         return MAKE_COMPARE_HRESULT(bIsDesktopFolder1 - bIsDesktopFolder2);
 500
 501     if (_ILIsSpecialFolder(pidl1) || _ILIsSpecialFolder(pidl2))
 502         return m_regFolder->CompareIDs(lParam, pidl1, pidl2);
 503
 504     return m_DesktopFSFolder->CompareIDs(lParam, pidl1, pidl2);
 505 }
 506
 507 /**************************************************************************
 508  *    CDesktopFolder::CreateViewObject
 509  */
 510 HRESULT WINAPI CDesktopFolder::CreateViewObject(
 511     HWND hwndOwner,
 512     REFIID riid,
 513     LPVOID *ppvOut)
 514 {
 515     CComPtr<IShellView> pShellView;
 516     HRESULT hr = E_INVALIDARG;
 517
 518     TRACE ("(%p)->(hwnd=%p,%s,%p)\n",
 519            this, hwndOwner, shdebugstr_guid (&riid), ppvOut);
 520
 521     if (!ppvOut)
 522         return hr;
 523
 524     *ppvOut = NULL;
 525
 526     if (IsEqualIID (riid, IID_IDropTarget))
 527     {
 528         hr = m_DesktopFSFolder->CreateViewObject(hwndOwner, riid, ppvOut);
 529     }
 530     else if (IsEqualIID (riid, IID_IContextMenu))
 531     {
 532         WARN ("IContextMenu not implemented\n");
 533         hr = E_NOTIMPL;
 534     }
 535     else if (IsEqualIID (riid, IID_IShellView))
 536     {
 537         hr = IShellView_Constructor((IShellFolder *)this, &pShellView);
 538         if (pShellView)
 539             hr = pShellView->QueryInterface(riid, ppvOut);
 540     }
 541     TRACE ("-- (%p)->(interface=%p)\n", this, ppvOut);
 542     return hr;
 543 }
 544
 545 /**************************************************************************
 546  *  CDesktopFolder::GetAttributesOf
 547  */
 548 HRESULT WINAPI CDesktopFolder::GetAttributesOf(
 549     UINT cidl,
 550     PCUITEMID_CHILD_ARRAY apidl,
 551     DWORD *rgfInOut)
 552 {
 553     HRESULT hr = S_OK;
 554
 555     TRACE("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
 556           this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
 557
 558     if (cidl && !apidl)
 559         return E_INVALIDARG;
 560
 561     if (*rgfInOut == 0)
 562         *rgfInOut = ~0;
 563
 564     if(cidl == 0)
 565         *rgfInOut &= dwDesktopAttributes;
 566     else
 567     {
 568         /* TODO: always add SFGAO_CANLINK */
 569         for (UINT i = 0; i < cidl; ++i)
 570         {
 571             pdump(*apidl);
 572             if (_ILIsDesktop(*apidl))
 573                 *rgfInOut &= dwDesktopAttributes;
 574             else if (_ILIsMyComputer(apidl[i]))
 575                 *rgfInOut &= dwMyComputerAttributes;
 576             else if (_ILIsNetHood(apidl[i]))
 577                 *rgfInOut &= dwMyNetPlacesAttributes;
 578             else if (_ILIsFolder(apidl[i]) || _ILIsValue(apidl[i]) || _ILIsSpecialFolder(apidl[i]))
 579             {
 580                 CComPtr<IShellFolder2> psf;
 581                 HRESULT hr = _GetSFFromPidl(apidl[i], &psf);
 582                 if (FAILED_UNEXPECTEDLY(hr))
 583                     continue;
 584
 585                 psf->GetAttributesOf(1, &apidl[i], rgfInOut);
 586             }
 587             else
 588                 ERR("Got an unknown pidl type!!!\n");
 589         }
 590     }
 591     /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
 592     *rgfInOut &= ~SFGAO_VALIDATE;
 593
 594     TRACE("-- result=0x%08x\n", *rgfInOut);
 595
 596     return hr;
 597 }
 598
 599 /**************************************************************************
 600  *    CDesktopFolder::GetUIObjectOf
 601  *
 602  * PARAMETERS
 603  *  HWND           hwndOwner, //[in ] Parent window for any output
 604  *  UINT           cidl,      //[in ] array size
 605  *  LPCITEMIDLIST* apidl,     //[in ] simple pidl array
 606  *  REFIID         riid,      //[in ] Requested Interface
 607  *  UINT*          prgfInOut, //[   ] reserved
 608  *  LPVOID*        ppvObject) //[out] Resulting Interface
 609  *
 610  */
 611 HRESULT WINAPI CDesktopFolder::GetUIObjectOf(
 612     HWND hwndOwner,
 613     UINT cidl,
 614     PCUITEMID_CHILD_ARRAY apidl,
 615     REFIID riid,
 616     UINT *prgfInOut,
 617     LPVOID *ppvOut)
 618 {
 619     LPVOID pObj = NULL;
 620     HRESULT hr = E_INVALIDARG;
 621
 622     TRACE ("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n",
 623            this, hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
 624
 625     if (!ppvOut)
 626         return hr;
 627
 628     *ppvOut = NULL;
 629
 630     if (cidl == 1 && !_ILIsSpecialFolder(apidl[0]))
 631     {
 632         CComPtr<IShellFolder2> psf;
 633         HRESULT hr = _GetSFFromPidl(apidl[0], &psf);
 634         if (FAILED_UNEXPECTEDLY(hr))
 635             return hr;
 636
 637         return psf->GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, ppvOut);
 638     }
 639
 640     if (IsEqualIID (riid, IID_IContextMenu))
 641     {
 642         if (_ILIsSpecialFolder(apidl[0]))
 643         {
 644             hr = m_regFolder->GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, &pObj);
 645         }
 646         else
 647         {
 648             /* Do not use the context menu of the CFSFolder here. */
 649             /* We need to pass a pointer of the CDesktopFolder  so as the data object that the context menu gets is rooted to the desktop */
 650             /* Otherwise operations like that involve items from both user and shared desktop will not work */
 651             IContextMenu  * pCm = NULL;
 652             HKEY hKeys[16];
 653             UINT cKeys = 0;
 654             AddFSClassKeysToArray(apidl[0], hKeys, &cKeys);
 655             hr = CDefFolderMenu_Create2(pidlRoot, hwndOwner, cidl, apidl, static_cast<IShellFolder*>(this), NULL, cKeys, hKeys, &pCm);
 656         }
 657     }
 658     else if (IsEqualIID (riid, IID_IDataObject) && (cidl >= 1))
 659     {
 660         hr = IDataObject_Constructor( hwndOwner, pidlRoot, apidl, cidl, (IDataObject **)&pObj);
 661     }
 662     else if ((IsEqualIID (riid, IID_IExtractIconA) || IsEqualIID (riid, IID_IExtractIconW)) && (cidl == 1))
 663     {
 664         hr = m_regFolder->GetUIObjectOf(hwndOwner, cidl, apidl, riid, prgfInOut, &pObj);
 665     }
 666     else
 667         hr = E_NOINTERFACE;
 668
 669     if (SUCCEEDED(hr) && !pObj)
 670         hr = E_OUTOFMEMORY;
 671
 672     *ppvOut = pObj;
 673     TRACE ("(%p)->hr=0x%08x\n", this, hr);
 674     return hr;
 675 }
 676
 677 /**************************************************************************
 678  *    CDesktopFolder::GetDisplayNameOf
 679  *
 680  * NOTES
 681  *    special case: pidl = null gives desktop-name back
 682  */
 683 HRESULT WINAPI CDesktopFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
 684 {
 685     TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
 686     pdump (pidl);
 687
 688     if (!strRet)
 689         return E_INVALIDARG;
 690
 691     if (!_ILIsPidlSimple (pidl))
 692     {
 693         return SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, strRet);
 694     }
 695     else if (_ILIsDesktop(pidl))
 696     {
 697         if ((GET_SHGDN_RELATION(dwFlags) == SHGDN_NORMAL) && (GET_SHGDN_FOR(dwFlags) & SHGDN_FORPARSING))
 698             return SHSetStrRet(strRet, sPathTarget);
 699         else
 700             return m_regFolder->GetDisplayNameOf(pidl, dwFlags, strRet);
 701     }
 702
 703     /* file system folder or file rooted at the desktop */
 704     CComPtr<IShellFolder2> psf;
 705     HRESULT hr = _GetSFFromPidl(pidl, &psf);
 706     if (FAILED_UNEXPECTEDLY(hr))
 707         return hr;
 708
 709     return psf->GetDisplayNameOf(pidl, dwFlags, strRet);
 710 }
 711
 712 /**************************************************************************
 713  *  CDesktopFolder::SetNameOf
 714  *  Changes the name of a file object or subfolder, possibly changing its item
 715  *  identifier in the process.
 716  *
 717  * PARAMETERS
 718  *  HWND          hwndOwner,  //[in ] Owner window for output
 719  *  LPCITEMIDLIST pidl,       //[in ] simple pidl of item to change
 720  *  LPCOLESTR     lpszName,   //[in ] the items new display name
 721  *  DWORD         dwFlags,    //[in ] SHGNO formatting flags
 722  *  LPITEMIDLIST* ppidlOut)   //[out] simple pidl returned
 723  */
 724 HRESULT WINAPI CDesktopFolder::SetNameOf(
 725     HWND hwndOwner,
 726     PCUITEMID_CHILD pidl,    /* simple pidl */
 727     LPCOLESTR lpName,
 728     DWORD dwFlags,
 729     PITEMID_CHILD *pPidlOut)
 730 {
 731     CComPtr<IShellFolder2> psf;
 732     HRESULT hr = _GetSFFromPidl(pidl, &psf);
 733     if (FAILED_UNEXPECTEDLY(hr))
 734         return hr;
 735
 736     return psf->SetNameOf(hwndOwner, pidl, lpName, dwFlags, pPidlOut);
 737 }
 738
 739 HRESULT WINAPI CDesktopFolder::GetDefaultSearchGUID(GUID *pguid)
 740 {
 741     FIXME ("(%p)\n", this);
 742     return E_NOTIMPL;
 743 }
 744
 745 HRESULT WINAPI CDesktopFolder::EnumSearches(IEnumExtraSearch **ppenum)
 746 {
 747     FIXME ("(%p)\n", this);
 748     return E_NOTIMPL;
 749 }
 750
 751 HRESULT WINAPI CDesktopFolder::GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
 752 {
 753     TRACE ("(%p)\n", this);
 754
 755     if (pSort)
 756         *pSort = 0;
 757     if (pDisplay)
 758         *pDisplay = 0;
 759
 760     return S_OK;
 761 }
 762
 763 HRESULT WINAPI CDesktopFolder::GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
 764 {
 765     TRACE ("(%p)\n", this);
 766
 767     if (!pcsFlags || iColumn >= DESKTOPSHELLVIEWCOLUMNS)
 768         return E_INVALIDARG;
 769
 770     *pcsFlags = DesktopSFHeader[iColumn].pcsFlags;
 771
 772     return S_OK;
 773 }
 774
 775 HRESULT WINAPI CDesktopFolder::GetDetailsEx(
 776     PCUITEMID_CHILD pidl,
 777     const SHCOLUMNID *pscid,
 778     VARIANT *pv)
 779 {
 780     FIXME ("(%p)\n", this);
 781
 782     return E_NOTIMPL;
 783 }
 784
 785 HRESULT WINAPI CDesktopFolder::GetDetailsOf(
 786     PCUITEMID_CHILD pidl,
 787     UINT iColumn,
 788     SHELLDETAILS *psd)
 789 {
 790     if (!psd || iColumn >= DESKTOPSHELLVIEWCOLUMNS)
 791         return E_INVALIDARG;
 792
 793     if (!pidl)
 794     {
 795         psd->fmt = DesktopSFHeader[iColumn].fmt;
 796         psd->cxChar = DesktopSFHeader[iColumn].cxChar;
 797         return SHSetStrRet(&psd->str, DesktopSFHeader[iColumn].colnameid);
 798     }
 799
 800     CComPtr<IShellFolder2> psf;
 801     HRESULT hr = _GetSFFromPidl(pidl, &psf);
 802     if (FAILED_UNEXPECTEDLY(hr))
 803         return hr;
 804
 805     hr =  psf->GetDetailsOf(pidl, iColumn, psd);
 806     if (FAILED_UNEXPECTEDLY(hr))
 807         return hr;
 808
 809     return hr;
 810 }
 811
 812 HRESULT WINAPI CDesktopFolder::MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
 813 {
 814     FIXME ("(%p)\n", this);
 815     return E_NOTIMPL;
 816 }
 817
 818 HRESULT WINAPI CDesktopFolder::GetClassID(CLSID *lpClassId)
 819 {
 820     TRACE ("(%p)\n", this);
 821
 822     if (!lpClassId)
 823         return E_POINTER;
 824
 825     *lpClassId = CLSID_ShellDesktop;
 826
 827     return S_OK;
 828 }
 829
 830 HRESULT WINAPI CDesktopFolder::Initialize(LPCITEMIDLIST pidl)
 831 {
 832     TRACE ("(%p)->(%p)\n", this, pidl);
 833
 834     return E_INVALIDARG;
 835 }
 836
 837 HRESULT WINAPI CDesktopFolder::GetCurFolder(LPITEMIDLIST * pidl)
 838 {
 839     TRACE ("(%p)->(%p)\n", this, pidl);
 840
 841     if (!pidl)
 842         return E_INVALIDARG; /* xp doesn't have this check and crashes on NULL */
 843     *pidl = ILClone (pidlRoot);
 844     return S_OK;
 845 }
 846
 847 /*************************************************************************
 848  * SHGetDesktopFolder            [SHELL32.@]
 849  */
 850 HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
 851 {
 852     HRESULT    hres = S_OK;
 853     TRACE("\n");
 854
 855     if(!psf) return E_INVALIDARG;
 856     *psf = NULL;
 857     hres = CDesktopFolder::_CreatorClass::CreateInstance(NULL, IID_PPV_ARG(IShellFolder, psf));
 858
 859     TRACE("-- %p->(%p)\n",psf, *psf);
 860     return hres;
 861 }