reactos/dll/win32/shell32/shlfolder.cpp

   1 /*
   2  *    Shell Folder stuff
   3  *
   4  *    Copyright 1997            Marcus Meissner
   5  *    Copyright 1998, 1999, 2002    Juergen Schmied
   6  *
   7  *    IShellFolder2 and related interfaces
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  */
  23
  24 #include "precomp.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(shell);
  27
  28 /***************************************************************************
  29  *  SHELL32_GetCustomFolderAttributeFromPath (internal function)
  30  *
  31  * Gets a value from the folder's desktop.ini file, if one exists.
  32  *
  33  * PARAMETERS
  34  *  pwszFolderPath[I] Folder containing the desktop.ini file.
  35  *  pwszHeading   [I] Heading in .ini file.
  36  *  pwszAttribute [I] Attribute in .ini file.
  37  *  pwszValue     [O] Buffer to store value into.
  38  *  cchValue      [I] Size in characters including NULL of buffer pointed to
  39  *                    by pwszValue.
  40  *
  41  *  RETURNS
  42  *    TRUE if returned non-NULL value.
  43  *    FALSE otherwise.
  44  */
  45 static BOOL __inline SHELL32_GetCustomFolderAttributeFromPath(
  46     LPWSTR pwszFolderPath, LPCWSTR pwszHeading, LPCWSTR pwszAttribute,
  47     LPWSTR pwszValue, DWORD cchValue)
  48 {
  49     static const WCHAR wszDesktopIni[] =
  50             {'d','e','s','k','t','o','p','.','i','n','i',0};
  51     static const WCHAR wszDefault[] = {0};
  52
  53     PathAddBackslashW(pwszFolderPath);
  54     PathAppendW(pwszFolderPath, wszDesktopIni);
  55     return GetPrivateProfileStringW(pwszHeading, pwszAttribute, wszDefault,
  56                                     pwszValue, cchValue, pwszFolderPath);
  57 }
  58
  59 /***************************************************************************
  60  *  GetNextElement (internal function)
  61  *
  62  * Gets a part of a string till the first backslash.
  63  *
  64  * PARAMETERS
  65  *  pszNext [IN] string to get the element from
  66  *  pszOut  [IN] pointer to buffer which receives string
  67  *  dwOut   [IN] length of pszOut
  68  *
  69  *  RETURNS
  70  *    LPSTR pointer to first, not yet parsed char
  71  */
  72
  73 LPCWSTR GetNextElementW (LPCWSTR pszNext, LPWSTR pszOut, DWORD dwOut)
  74 {
  75     LPCWSTR pszTail = pszNext;
  76     DWORD dwCopy;
  77
  78     TRACE ("(%s %p 0x%08x)\n", debugstr_w (pszNext), pszOut, dwOut);
  79
  80     *pszOut = 0x0000;
  81
  82     if (!pszNext || !*pszNext)
  83         return NULL;
  84
  85     while (*pszTail && (*pszTail != (WCHAR) '\\'))
  86         pszTail++;
  87
  88     dwCopy = pszTail - pszNext + 1;
  89     lstrcpynW (pszOut, pszNext, (dwOut < dwCopy) ? dwOut : dwCopy);
  90
  91     if (*pszTail)
  92         pszTail++;
  93     else
  94         pszTail = NULL;
  95
  96     TRACE ("--(%s %s 0x%08x %p)\n", debugstr_w (pszNext), debugstr_w (pszOut), dwOut, pszTail);
  97     return pszTail;
  98 }
  99
 100 HRESULT SHELL32_ParseNextElement (IShellFolder2 * psf, HWND hwndOwner, LPBC pbc,
 101                   LPITEMIDLIST * pidlInOut, LPOLESTR szNext, DWORD * pEaten, DWORD * pdwAttributes)
 102 {
 103     HRESULT hr = E_INVALIDARG;
 104     LPITEMIDLIST pidlIn = pidlInOut ? *pidlInOut : NULL;
 105     LPITEMIDLIST pidlOut = NULL;
 106     LPITEMIDLIST pidlTemp = NULL;
 107     CComPtr<IShellFolder> psfChild;
 108
 109     TRACE ("(%p, %p, %p, %s)\n", psf, pbc, pidlIn, debugstr_w (szNext));
 110
 111     /* get the shellfolder for the child pidl and let it analyse further */
 112     hr = psf->BindToObject(pidlIn, pbc, IID_PPV_ARG(IShellFolder, &psfChild));
 113     if (FAILED(hr))
 114         return hr;
 115
 116     hr = psfChild->ParseDisplayName(hwndOwner, pbc, szNext, pEaten, &pidlOut, pdwAttributes);
 117     if (FAILED(hr))
 118         return hr;
 119
 120     pidlTemp = ILCombine (pidlIn, pidlOut);
 121     if (!pidlTemp)
 122     {
 123         hr = E_OUTOFMEMORY;
 124         if (pidlOut)
 125             ILFree(pidlOut);
 126         return hr;
 127     }
 128
 129     if (pidlOut)
 130         ILFree (pidlOut);
 131
 132     if (pidlIn)
 133         ILFree (pidlIn);
 134
 135     *pidlInOut = pidlTemp;
 136
 137     TRACE ("-- pidl=%p ret=0x%08x\n", pidlInOut ? *pidlInOut : NULL, hr);
 138     return S_OK;
 139 }
 140
 141 /***********************************************************************
 142  *    SHELL32_CoCreateInitSF
 143  *
 144  * Creates a shell folder and initializes it with a pidl and a root folder
 145  * via IPersistFolder3 or IPersistFolder.
 146  *
 147  * NOTES
 148  *   pathRoot can be NULL for Folders being a drive.
 149  *   In this case the absolute path is built from pidlChild (eg. C:)
 150  */
 151 HRESULT SHELL32_CoCreateInitSF (LPCITEMIDLIST pidlRoot, LPCWSTR pathRoot,
 152                 LPCITEMIDLIST pidlChild, const GUID* clsid, int csidl, REFIID riid, LPVOID *ppvOut)
 153 {
 154     HRESULT hr;
 155     CComPtr<IShellFolder> pShellFolder;
 156
 157     TRACE ("%p %s %p\n", pidlRoot, debugstr_w(pathRoot), pidlChild);
 158
 159     hr = SHCoCreateInstance(NULL, clsid, NULL, IID_PPV_ARG(IShellFolder, &pShellFolder));
 160     if (FAILED(hr))
 161         return hr;
 162
 163     LPITEMIDLIST pidlAbsolute = ILCombine (pidlRoot, pidlChild);
 164     CComPtr<IPersistFolder> ppf;
 165     CComPtr<IPersistFolder3> ppf3;
 166
 167     if (SUCCEEDED(pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder3, &ppf3))))
 168     {
 169         PERSIST_FOLDER_TARGET_INFO ppfti;
 170
 171         ZeroMemory (&ppfti, sizeof (ppfti));
 172
 173         /* fill the PERSIST_FOLDER_TARGET_INFO */
 174         ppfti.dwAttributes = -1;
 175         ppfti.csidl = csidl;
 176
 177         /* build path */
 178         if (pathRoot)
 179         {
 180             lstrcpynW (ppfti.szTargetParsingName, pathRoot, MAX_PATH - 1);
 181             PathAddBackslashW(ppfti.szTargetParsingName); /* FIXME: why have drives a backslash here ? */
 182         }
 183
 184         if (pidlChild)
 185         {
 186             int len = wcslen(ppfti.szTargetParsingName);
 187
 188             if (!_ILSimpleGetTextW(pidlChild, ppfti.szTargetParsingName + len, MAX_PATH - len))
 189                 hr = E_INVALIDARG;
 190         }
 191
 192         ppf3->InitializeEx(NULL, pidlAbsolute, &ppfti);
 193     }
 194     else if (SUCCEEDED(pShellFolder->QueryInterface(IID_PPV_ARG(IPersistFolder, &ppf))))
 195     {
 196         ppf->Initialize(pidlAbsolute);
 197     }
 198     ILFree (pidlAbsolute);
 199
 200     return pShellFolder->QueryInterface(riid, ppvOut);
 201 }
 202
 203 void SHELL32_GetCLSIDForDirectory(LPCWSTR pathRoot, LPCITEMIDLIST pidl, CLSID* pclsidFolder)
 204 {
 205     static const WCHAR wszDotShellClassInfo[] = {
 206         '.','S','h','e','l','l','C','l','a','s','s','I','n','f','o',0 };
 207     static const WCHAR wszCLSID[] = {'C','L','S','I','D',0};
 208     WCHAR wszCLSIDValue[CHARS_IN_GUID], wszFolderPath[MAX_PATH], *pwszPathTail = wszFolderPath;
 209
 210     /* see if folder CLSID should be overridden by desktop.ini file */
 211     if (pathRoot) {
 212         lstrcpynW(wszFolderPath, pathRoot, MAX_PATH);
 213         pwszPathTail = PathAddBackslashW(wszFolderPath);
 214     }
 215
 216     _ILSimpleGetTextW(pidl,pwszPathTail,MAX_PATH - (int)(pwszPathTail - wszFolderPath));
 217
 218     if (SHELL32_GetCustomFolderAttributeFromPath (wszFolderPath,
 219         wszDotShellClassInfo, wszCLSID, wszCLSIDValue, CHARS_IN_GUID))
 220         CLSIDFromString (wszCLSIDValue, pclsidFolder);
 221 }
 222
 223 /***********************************************************************
 224  *    SHELL32_BindToFS [Internal]
 225  *
 226  * Common code for IShellFolder_BindToObject.
 227  *
 228  * PARAMS
 229  *  pidlRoot     [I] The parent shell folder's absolute pidl.
 230  *  pathRoot     [I] Absolute dos path of the parent shell folder.
 231  *  pidlComplete [I] PIDL of the child. Relative to pidlRoot.
 232  *  riid         [I] GUID of the interface, which ppvOut shall be bound to.
 233  *  ppvOut       [O] A reference to the child's interface (riid).
 234  *
 235  * NOTES
 236  *  pidlComplete has to contain at least one non empty SHITEMID.
 237  *  This function makes special assumptions on the shell namespace, which
 238  *  means you probably can't use it for your IShellFolder implementation.
 239  */
 240 HRESULT SHELL32_BindToFS (LPCITEMIDLIST pidlRoot,
 241                              LPCWSTR pathRoot, LPCITEMIDLIST pidlComplete, REFIID riid, LPVOID * ppvOut)
 242 {
 243     CComPtr<IShellFolder> pSF;
 244     HRESULT hr;
 245     LPCITEMIDLIST pidlChild;
 246
 247     if (!pidlRoot || !ppvOut || !pidlComplete || !pidlComplete->mkid.cb)
 248         return E_INVALIDARG;
 249
 250     if (_ILIsValue(pidlComplete))
 251     {
 252         ERR("Binding to file is unimplemented\n");
 253         return HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND);
 254     }
 255     if (!_ILIsFolder(pidlComplete))
 256     {
 257         ERR("Got an unknown type of pidl!\n");
 258         return E_FAIL;
 259     }
 260
 261     *ppvOut = NULL;
 262
 263     pidlChild = (_ILIsPidlSimple (pidlComplete)) ? pidlComplete : ILCloneFirst (pidlComplete);
 264
 265     CLSID clsidFolder = CLSID_ShellFSFolder;
 266     DWORD attributes = _ILGetFileAttributes(ILFindLastID(pidlChild), NULL, 0);
 267     if ((attributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) != 0)
 268         SHELL32_GetCLSIDForDirectory(pathRoot, pidlChild, &clsidFolder);
 269
 270     hr = SHELL32_CoCreateInitSF (pidlRoot, pathRoot, pidlChild, &clsidFolder, -1, IID_PPV_ARG(IShellFolder, &pSF));
 271
 272     if (pidlChild != pidlComplete)
 273         ILFree ((LPITEMIDLIST)pidlChild);
 274
 275     if (SUCCEEDED (hr)) {
 276         if (_ILIsPidlSimple (pidlComplete)) {
 277             /* no sub folders */
 278             hr = pSF->QueryInterface(riid, ppvOut);
 279         } else {
 280             /* go deeper */
 281             hr = pSF->BindToObject(ILGetNext (pidlComplete), NULL, riid, ppvOut);
 282         }
 283     }
 284
 285     TRACE ("-- returning (%p) %08x\n", *ppvOut, hr);
 286
 287     return hr;
 288 }
 289
 290 /***********************************************************************
 291  *    SHELL32_GetDisplayNameOfChild
 292  *
 293  * Retrieves the display name of a child object of a shellfolder.
 294  *
 295  * For a pidl eg. [subpidl1][subpidl2][subpidl3]:
 296  * - it binds to the child shellfolder [subpidl1]
 297  * - asks it for the displayname of [subpidl2][subpidl3]
 298  *
 299  * Is possible the pidl is a simple pidl. In this case it asks the
 300  * subfolder for the displayname of an empty pidl. The subfolder
 301  * returns the own displayname eg. "::{guid}". This is used for
 302  * virtual folders with the registry key WantsFORPARSING set.
 303  */
 304 HRESULT SHELL32_GetDisplayNameOfChild (IShellFolder2 * psf,
 305                        LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
 306 {
 307     LPITEMIDLIST pidlFirst = ILCloneFirst(pidl);
 308     if (!pidlFirst)
 309         return E_OUTOFMEMORY;
 310
 311     CComPtr<IShellFolder> psfChild;
 312     HRESULT hr = psf->BindToObject(pidlFirst, NULL, IID_PPV_ARG(IShellFolder, &psfChild));
 313     if (SUCCEEDED (hr))
 314     {
 315         hr = psfChild->GetDisplayNameOf(ILGetNext (pidl), dwFlags, strRet);
 316     }
 317     ILFree (pidlFirst);
 318
 319     return hr;
 320 }
 321
 322 HRESULT HCR_GetClassName(REFIID riid, LPSTRRET strRet)
 323 {
 324     BOOL bRet;
 325     WCHAR wstrName[MAX_PATH+1];
 326     bRet = HCR_GetClassNameW(riid, wstrName, MAX_PATH);
 327     if (!bRet)
 328         return E_FAIL;
 329
 330     return SHSetStrRet(strRet, wstrName);
 331 }
 332
 333 /***********************************************************************
 334  *  SHELL32_GetItemAttributes
 335  *
 336  * NOTES
 337  * Observed values:
 338  *  folder:    0xE0000177    FILESYSTEM | HASSUBFOLDER | FOLDER
 339  *  file:    0x40000177    FILESYSTEM
 340  *  drive:    0xf0000144    FILESYSTEM | HASSUBFOLDER | FOLDER | FILESYSANCESTOR
 341  *  mycomputer:    0xb0000154    HASSUBFOLDER | FOLDER | FILESYSANCESTOR
 342  *  (seems to be default for shell extensions if no registry entry exists)
 343  *
 344  * win2k:
 345  *  folder:    0xF0400177      FILESYSTEM | HASSUBFOLDER | FOLDER | FILESYSANCESTOR | CANMONIKER
 346  *  file:      0x40400177      FILESYSTEM | CANMONIKER
 347  *  drive      0xF0400154      FILESYSTEM | HASSUBFOLDER | FOLDER | FILESYSANCESTOR | CANMONIKER | CANRENAME (LABEL)
 348  *
 349  * According to the MSDN documentation this function should not set flags. It claims only to reset flags when necessary.
 350  * However it turns out the native shell32.dll _sets_ flags in several cases - so do we.
 351  */
 352
 353 static const DWORD dwSupportedAttr=
 354                       SFGAO_CANCOPY |           /*0x00000001 */
 355                       SFGAO_CANMOVE |           /*0x00000002 */
 356                       SFGAO_CANLINK |           /*0x00000004 */
 357                       SFGAO_CANRENAME |         /*0x00000010 */
 358                       SFGAO_CANDELETE |         /*0x00000020 */
 359                       SFGAO_HASPROPSHEET |      /*0x00000040 */
 360                       SFGAO_DROPTARGET |        /*0x00000100 */
 361                       SFGAO_LINK |              /*0x00010000 */
 362                       SFGAO_READONLY |          /*0x00040000 */
 363                       SFGAO_HIDDEN |            /*0x00080000 */
 364                       SFGAO_FILESYSANCESTOR |   /*0x10000000 */
 365                       SFGAO_FOLDER |            /*0x20000000 */
 366                       SFGAO_FILESYSTEM |        /*0x40000000 */
 367                       SFGAO_HASSUBFOLDER;       /*0x80000000 */
 368
 369 HRESULT SHELL32_GetFSItemAttributes(IShellFolder * psf, LPCITEMIDLIST pidl, LPDWORD pdwAttributes)
 370 {
 371     DWORD dwFileAttributes, dwShellAttributes;
 372
 373     if (!_ILIsFolder(pidl) && !_ILIsValue(pidl))
 374     {
 375         ERR("Got wrong type of pidl!\n");
 376         *pdwAttributes &= SFGAO_CANLINK;
 377         return S_OK;
 378     }
 379
 380     if (*pdwAttributes & ~dwSupportedAttr)
 381     {
 382         WARN ("attributes 0x%08x not implemented\n", (*pdwAttributes & ~dwSupportedAttr));
 383         *pdwAttributes &= dwSupportedAttr;
 384     }
 385
 386     dwFileAttributes = _ILGetFileAttributes(pidl, NULL, 0);
 387
 388     /* Set common attributes */
 389     dwShellAttributes = *pdwAttributes;
 390     dwShellAttributes |= SFGAO_FILESYSTEM | SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANDELETE |
 391                          SFGAO_CANRENAME | SFGAO_CANLINK | SFGAO_CANMOVE | SFGAO_CANCOPY;
 392
 393     if (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
 394     {
 395         dwShellAttributes |=  (SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_FILESYSANCESTOR);
 396     }
 397     else
 398         dwShellAttributes &= ~(SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_FILESYSANCESTOR);
 399
 400     if (dwFileAttributes & FILE_ATTRIBUTE_HIDDEN)
 401         dwShellAttributes |=  SFGAO_HIDDEN;
 402     else
 403         dwShellAttributes &= ~SFGAO_HIDDEN;
 404
 405     if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
 406         dwShellAttributes |=  SFGAO_READONLY;
 407     else
 408         dwShellAttributes &= ~SFGAO_READONLY;
 409
 410     if (SFGAO_LINK & *pdwAttributes)
 411     {
 412         char ext[MAX_PATH];
 413
 414         if (!_ILGetExtension(pidl, ext, MAX_PATH) || lstrcmpiA(ext, "lnk"))
 415         dwShellAttributes &= ~SFGAO_LINK;
 416     }
 417
 418     if (SFGAO_HASSUBFOLDER & *pdwAttributes)
 419     {
 420         CComPtr<IShellFolder> psf2;
 421         if (SUCCEEDED(psf->BindToObject(pidl, 0, IID_PPV_ARG(IShellFolder, &psf2))))
 422         {
 423             CComPtr<IEnumIDList> pEnumIL;
 424             if (SUCCEEDED(psf2->EnumObjects(0, SHCONTF_FOLDERS, &pEnumIL)))
 425             {
 426                 if (pEnumIL->Skip(1) != S_OK)
 427                     dwShellAttributes &= ~SFGAO_HASSUBFOLDER;
 428             }
 429         }
 430     }
 431
 432     *pdwAttributes &= dwShellAttributes;
 433
 434     TRACE ("-- 0x%08x\n", *pdwAttributes);
 435     return S_OK;
 436 }
 437
 438 HRESULT SHELL32_CompareChildren(IShellFolder2* psf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 439 {
 440     PUIDLIST_RELATIVE nextpidl1 = ILGetNext (pidl1);
 441     PUIDLIST_RELATIVE nextpidl2 = ILGetNext (pidl2);
 442
 443     bool isEmpty1 = _ILIsDesktop(nextpidl1);
 444     bool isEmpty2 = _ILIsDesktop(nextpidl2);
 445     if (isEmpty1 || isEmpty2)
 446         return MAKE_COMPARE_HRESULT(isEmpty2 - isEmpty1);
 447
 448     PITEMID_CHILD firstpidl = ILCloneFirst (pidl1);
 449     if (!firstpidl)
 450         return E_OUTOFMEMORY;
 451
 452     CComPtr<IShellFolder> psf2;
 453     HRESULT hr = psf->BindToObject(firstpidl, 0, IID_PPV_ARG(IShellFolder, &psf2));
 454     ILFree(firstpidl);
 455     if (FAILED(hr))
 456         return MAKE_COMPARE_HRESULT(0);
 457
 458     return psf2->CompareIDs(lParam, nextpidl1, nextpidl2);
 459 }
 460
 461 HRESULT SHELL32_CompareDetails(IShellFolder2* isf, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 462 {
 463     SHELLDETAILS sd;
 464     WCHAR wszItem1[MAX_PATH], wszItem2[MAX_PATH];
 465     HRESULT hres;
 466
 467     hres = isf->GetDetailsOf(pidl1, lParam, &sd);
 468     if (FAILED(hres))
 469         return MAKE_COMPARE_HRESULT(1);
 470
 471     hres = StrRetToBufW(&sd.str, pidl1, wszItem1, MAX_PATH);
 472     if (FAILED(hres))
 473         return MAKE_COMPARE_HRESULT(1);
 474
 475     hres = isf->GetDetailsOf(pidl2, lParam, &sd);
 476     if (FAILED(hres))
 477         return MAKE_COMPARE_HRESULT(1);
 478
 479     hres = StrRetToBufW(&sd.str, pidl2, wszItem2, MAX_PATH);
 480     if (FAILED(hres))
 481         return MAKE_COMPARE_HRESULT(1);
 482
 483     int ret = wcsicmp(wszItem1, wszItem2);
 484     if (ret == 0)
 485         return SHELL32_CompareChildren(isf, lParam, pidl1, pidl2);
 486
 487     return MAKE_COMPARE_HRESULT(ret);
 488 }
 489
 490 void AddClassKeyToArray(const WCHAR * szClass, HKEY* array, UINT* cKeys)
 491 {
 492     if (*cKeys >= 16)
 493         return;
 494
 495     HKEY hkey;
 496     LSTATUS result = RegOpenKeyExW(HKEY_CLASSES_ROOT, szClass, 0, KEY_READ | KEY_QUERY_VALUE, &hkey);
 497     if (result != ERROR_SUCCESS)
 498         return;
 499
 500     array[*cKeys] = hkey;
 501     *cKeys += 1;
 502 }
 503
 504 void AddFSClassKeysToArray(PCUITEMID_CHILD pidl, HKEY* array, UINT* cKeys)
 505 {
 506     if (_ILIsValue(pidl))
 507     {
 508         FileStructW* pFileData = _ILGetFileStructW(pidl);
 509         LPWSTR extension = PathFindExtension(pFileData->wszName);
 510
 511         if (extension)
 512         {
 513             AddClassKeyToArray(extension, array, cKeys);
 514
 515             WCHAR wszClass[40], wszClass2[40];
 516             DWORD dwSize = sizeof(wszClass);
 517             if (RegGetValueW(HKEY_CLASSES_ROOT, extension, NULL, RRF_RT_REG_SZ, NULL, wszClass, &dwSize) == ERROR_SUCCESS)
 518             {
 519                 swprintf(wszClass2, L"%s//%s", extension, wszClass);
 520
 521                 AddClassKeyToArray(wszClass, array, cKeys);
 522                 AddClassKeyToArray(wszClass2, array, cKeys);
 523             }
 524
 525             swprintf(wszClass2, L"SystemFileAssociations//%s", extension);
 526             AddClassKeyToArray(wszClass2, array, cKeys);
 527
 528             if (RegGetValueW(HKEY_CLASSES_ROOT, extension, L"PerceivedType ", RRF_RT_REG_SZ, NULL, wszClass, &dwSize) == ERROR_SUCCESS)
 529             {
 530                 swprintf(wszClass2, L"SystemFileAssociations//%s", wszClass);
 531                 AddClassKeyToArray(wszClass2, array, cKeys);
 532             }
 533         }
 534
 535         AddClassKeyToArray(L"AllFilesystemObjects", array, cKeys);
 536         AddClassKeyToArray(L"*", array, cKeys);
 537     }
 538     else if (_ILIsFolder(pidl))
 539     {
 540         AddClassKeyToArray(L"AllFilesystemObjects", array, cKeys);
 541         AddClassKeyToArray(L"Directory", array, cKeys);
 542         AddClassKeyToArray(L"Folder", array, cKeys);
 543     }
 544     else
 545     {
 546         ERR("Got non FS pidl\n");
 547     }
 548 }
 549
 550 /***********************************************************************
 551  *  SHCreateLinks
 552  *
 553  *   Undocumented.
 554  */
 555 HRESULT WINAPI SHCreateLinks( HWND hWnd, LPCSTR lpszDir, IDataObject * lpDataObject,
 556                               UINT uFlags, LPITEMIDLIST *lppidlLinks)
 557 {
 558     FIXME("%p %s %p %08x %p\n", hWnd, lpszDir, lpDataObject, uFlags, lppidlLinks);
 559     return E_NOTIMPL;
 560 }
 561
 562 /***********************************************************************
 563  *  SHOpenFolderAndSelectItems
 564  *
 565  *   Unimplemented.
 566  */
 567 EXTERN_C HRESULT
 568 WINAPI
 569 SHOpenFolderAndSelectItems(LPITEMIDLIST pidlFolder,
 570                            UINT cidl,
 571                            PCUITEMID_CHILD_ARRAY apidl,
 572                            DWORD dwFlags)
 573 {
 574     ERR("SHOpenFolderAndSelectItems() is hackplemented\n");
 575     PCIDLIST_ABSOLUTE pidlItem;
 576     if (cidl)
 577     {
 578         /* Firefox sends a full pidl here dispite the fact it is a PCUITEMID_CHILD_ARRAY -_- */
 579         if (ILGetNext(apidl[0]) != NULL)
 580         {
 581             pidlItem = apidl[0];
 582         }
 583         else
 584         {
 585             pidlItem = ILCombine(pidlFolder, apidl[0]);
 586         }
 587     }
 588     else
 589     {
 590         pidlItem = pidlFolder;
 591     }
 592
 593     CComPtr<IShellFolder> psfDesktop;
 594
 595     HRESULT hr = SHGetDesktopFolder(&psfDesktop);
 596     if (FAILED_UNEXPECTEDLY(hr))
 597         return hr;
 598
 599     STRRET strret;
 600     hr = psfDesktop->GetDisplayNameOf(pidlItem, SHGDN_FORPARSING, &strret);
 601     if (FAILED_UNEXPECTEDLY(hr))
 602         return hr;
 603
 604     WCHAR wszBuf[MAX_PATH];
 605     hr = StrRetToBufW(&strret, pidlItem, wszBuf, _countof(wszBuf));
 606     if (FAILED_UNEXPECTEDLY(hr))
 607         return hr;
 608
 609     WCHAR wszParams[MAX_PATH];
 610     wcscpy(wszParams, L"/select,");
 611     wcscat(wszParams, wszBuf);
 612
 613     SHELLEXECUTEINFOW sei;
 614     memset(&sei, 0, sizeof sei);
 615     sei.cbSize = sizeof sei;
 616     sei.fMask = SEE_MASK_WAITFORINPUTIDLE;
 617     sei.lpFile = L"explorer.exe";
 618     sei.lpParameters = wszParams;
 619
 620     if (ShellExecuteExW(&sei))
 621         return S_OK;
 622     else
 623         return E_FAIL;
 624 }