dll/win32/shell32/folders/CDrivesFolder.cpp

   1 /*
   2  *    Virtual Workplace 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 CDrivesFolder should create a CRegFolder to represent the virtual items that exist only in
  29 the registry. The CRegFolder is aggregated by the CDrivesFolder.
  30 The CDrivesFolderEnum class should enumerate only drives on the system. Since the CRegFolder
  31 implementation of IShellFolder::EnumObjects enumerates the virtual items, the
  32 CDrivesFolderEnum is only responsible for returning the physical items.
  33
  34 2. At least on my XP system, the drive pidls returned are of type PT_DRIVE1, not PT_DRIVE
  35 3. The parsing name returned for my computer is incorrect. It should be "My Computer"
  36 */
  37
  38 /***********************************************************************
  39 *   IShellFolder implementation
  40 */
  41
  42 class CDrivesFolderEnum :
  43     public CEnumIDListBase
  44 {
  45     public:
  46         CDrivesFolderEnum();
  47         ~CDrivesFolderEnum();
  48         HRESULT WINAPI Initialize(HWND hwndOwner, DWORD dwFlags);
  49         BOOL CreateMyCompEnumList(DWORD dwFlags);
  50
  51         BEGIN_COM_MAP(CDrivesFolderEnum)
  52         COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
  53         END_COM_MAP()
  54 };
  55
  56 /***********************************************************************
  57 *   IShellFolder [MyComputer] implementation
  58 */
  59
  60 static const shvheader MyComputerSFHeader[] = {
  61     {IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15},
  62     {IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
  63     {IDS_SHV_COLUMN6, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
  64     {IDS_SHV_COLUMN7, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10},
  65 };
  66
  67 #define MYCOMPUTERSHELLVIEWCOLUMNS 4
  68
  69 CDrivesFolderEnum::CDrivesFolderEnum()
  70 {
  71 }
  72
  73 CDrivesFolderEnum::~CDrivesFolderEnum()
  74 {
  75 }
  76
  77 HRESULT WINAPI CDrivesFolderEnum::Initialize(HWND hwndOwner, DWORD dwFlags)
  78 {
  79     if (CreateMyCompEnumList(dwFlags) == FALSE)
  80         return E_FAIL;
  81
  82     return S_OK;
  83 }
  84
  85 /**************************************************************************
  86  *  CDrivesFolderEnum::CreateMyCompEnumList()
  87  */
  88
  89 BOOL CDrivesFolderEnum::CreateMyCompEnumList(DWORD dwFlags)
  90 {
  91     BOOL bRet = TRUE;
  92     static const WCHAR MyComputer_NameSpaceW[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\Namespace";
  93
  94     TRACE("(%p)->(flags=0x%08x)\n", this, dwFlags);
  95
  96     /* enumerate the folders */
  97     if (dwFlags & SHCONTF_FOLDERS)
  98     {
  99         WCHAR wszDriveName[] = {'A', ':', '\\', '\0'};
 100         DWORD dwDrivemap = GetLogicalDrives();
 101         HKEY hKey;
 102         UINT i;
 103
 104         while (bRet && wszDriveName[0] <= 'Z')
 105         {
 106             if(dwDrivemap & 0x00000001L)
 107                 bRet = AddToEnumList(_ILCreateDrive(wszDriveName));
 108             wszDriveName[0]++;
 109             dwDrivemap = dwDrivemap >> 1;
 110         }
 111
 112         TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n", this);
 113         for (i = 0; i < 2; i++)
 114         {
 115             if (bRet && ERROR_SUCCESS == RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
 116                     MyComputer_NameSpaceW, 0, KEY_READ, &hKey))
 117             {
 118                 WCHAR wszBuf[50];
 119                 DWORD dwSize, j = 0;
 120                 LONG ErrorCode;
 121                 LPITEMIDLIST pidl;
 122
 123                 while (bRet)
 124                 {
 125                     dwSize = sizeof(wszBuf) / sizeof(wszBuf[0]);
 126                     ErrorCode = RegEnumKeyExW(hKey, j, wszBuf, &dwSize, 0, NULL, NULL, NULL);
 127                     if (ERROR_SUCCESS == ErrorCode)
 128                     {
 129                         if (wszBuf[0] != L'{')
 130                         {
 131                             dwSize = sizeof(wszBuf);
 132                             RegGetValueW(hKey, wszBuf, NULL, RRF_RT_REG_SZ, NULL, wszBuf, &dwSize);
 133                         }
 134
 135                         /* FIXME: shell extensions - the type should be PT_SHELLEXT (tested) */
 136                         pidl = _ILCreateGuidFromStrW(wszBuf);
 137                         if (pidl != NULL)
 138                             bRet = AddToEnumList(pidl);
 139                         else
 140                             ERR("Invalid MyComputer namespace extesion: %s\n", wszBuf);
 141                         j++;
 142                     }
 143                     else if (ERROR_NO_MORE_ITEMS == ErrorCode)
 144                         break;
 145                     else
 146                         bRet = FALSE;
 147                 }
 148                 RegCloseKey(hKey);
 149             }
 150         }
 151     }
 152     return bRet;
 153 }
 154
 155 CDrivesFolder::CDrivesFolder()
 156 {
 157     pidlRoot = NULL;
 158     sName = NULL;
 159 }
 160
 161 CDrivesFolder::~CDrivesFolder()
 162 {
 163     TRACE ("-- destroying IShellFolder(%p)\n", this);
 164     SHFree(pidlRoot);
 165 }
 166
 167 HRESULT WINAPI CDrivesFolder::FinalConstruct()
 168 {
 169     DWORD dwSize;
 170     WCHAR szName[MAX_PATH];
 171     WCHAR wszMyCompKey[256];
 172     INT i;
 173
 174     pidlRoot = _ILCreateMyComputer();    /* my qualified pidl */
 175     if (pidlRoot == NULL)
 176         return E_OUTOFMEMORY;
 177
 178     i = swprintf(wszMyCompKey, L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\");
 179     StringFromGUID2(CLSID_MyComputer, wszMyCompKey + i, sizeof(wszMyCompKey) / sizeof(wszMyCompKey[0]) - i);
 180     dwSize = sizeof(szName);
 181     if (RegGetValueW(HKEY_CURRENT_USER, wszMyCompKey,
 182                      NULL, RRF_RT_REG_SZ, NULL, szName, &dwSize) == ERROR_SUCCESS)
 183     {
 184         sName = (LPWSTR)SHAlloc((wcslen(szName) + 1) * sizeof(WCHAR));
 185         if (sName)
 186             wcscpy(sName, szName);
 187         TRACE("sName %s\n", debugstr_w(sName));
 188     }
 189     return S_OK;
 190 }
 191
 192 /**************************************************************************
 193 *    CDrivesFolder::ParseDisplayName
 194 */
 195 HRESULT WINAPI CDrivesFolder::ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName,
 196         DWORD * pchEaten, PIDLIST_RELATIVE * ppidl, DWORD * pdwAttributes)
 197 {
 198     HRESULT hr = E_INVALIDARG;
 199     LPCWSTR szNext = NULL;
 200     WCHAR szElement[MAX_PATH];
 201     LPITEMIDLIST pidlTemp = NULL;
 202     CLSID clsid;
 203
 204     TRACE("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n", this,
 205           hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
 206           pchEaten, ppidl, pdwAttributes);
 207
 208     *ppidl = 0;
 209     if (pchEaten)
 210         *pchEaten = 0;        /* strange but like the original */
 211
 212     /* handle CLSID paths */
 213     if (lpszDisplayName[0] == ':' && lpszDisplayName[1] == ':')
 214     {
 215         szNext = GetNextElementW (lpszDisplayName, szElement, MAX_PATH);
 216         TRACE ("-- element: %s\n", debugstr_w (szElement));
 217         CLSIDFromString (szElement + 2, &clsid);
 218         pidlTemp = _ILCreateGuid (PT_GUID, clsid);
 219     }
 220     /* do we have an absolute path name ? */
 221     else if (PathGetDriveNumberW (lpszDisplayName) >= 0 &&
 222              lpszDisplayName[2] == (WCHAR) '\\')
 223     {
 224         szNext = GetNextElementW (lpszDisplayName, szElement, MAX_PATH);
 225         /* make drive letter uppercase to enable PIDL comparison */
 226         szElement[0] = toupper(szElement[0]);
 227         pidlTemp = _ILCreateDrive (szElement);
 228     }
 229
 230     if (szNext && *szNext)
 231     {
 232         hr = SHELL32_ParseNextElement (this, hwndOwner, pbc, &pidlTemp,
 233                                        (LPOLESTR) szNext, pchEaten, pdwAttributes);
 234     }
 235     else
 236     {
 237         if (pdwAttributes && *pdwAttributes)
 238             SHELL32_GetItemAttributes (this,
 239                                        pidlTemp, pdwAttributes);
 240         hr = S_OK;
 241     }
 242
 243     *ppidl = pidlTemp;
 244
 245     TRACE ("(%p)->(-- ret=0x%08x)\n", this, hr);
 246
 247     return hr;
 248 }
 249
 250 /**************************************************************************
 251 *        CDrivesFolder::EnumObjects
 252 */
 253 HRESULT WINAPI CDrivesFolder::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 254 {
 255     return ShellObjectCreatorInit<CDrivesFolderEnum>(hwndOwner, dwFlags, IID_IEnumIDList, ppEnumIDList);
 256 }
 257
 258 /**************************************************************************
 259 *        CDrivesFolder::BindToObject
 260 */
 261 HRESULT WINAPI CDrivesFolder::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 262 {
 263     TRACE("(%p)->(pidl=%p,%p,%s,%p)\n", this,
 264           pidl, pbcReserved, shdebugstr_guid(&riid), ppvOut);
 265
 266     return SHELL32_BindToChild(pidlRoot, NULL, pidl, riid, ppvOut);
 267 }
 268
 269 /**************************************************************************
 270 *    CDrivesFolder::BindToStorage
 271 */
 272 HRESULT WINAPI CDrivesFolder::BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 273 {
 274     FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", this,
 275           pidl, pbcReserved, shdebugstr_guid (&riid), ppvOut);
 276
 277     *ppvOut = NULL;
 278     return E_NOTIMPL;
 279 }
 280
 281 /**************************************************************************
 282 *     CDrivesFolder::CompareIDs
 283 */
 284
 285 HRESULT WINAPI CDrivesFolder::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 286 {
 287     int nReturn;
 288
 289     TRACE("(%p)->(0x%08lx,pidl1=%p,pidl2=%p)\n", this, lParam, pidl1, pidl2);
 290     nReturn = SHELL32_CompareIDs (this, lParam, pidl1, pidl2);
 291     TRACE("-- %i\n", nReturn);
 292     return nReturn;
 293 }
 294
 295 /**************************************************************************
 296 *    CDrivesFolder::CreateViewObject
 297 */
 298 HRESULT WINAPI CDrivesFolder::CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID * ppvOut)
 299 {
 300     CComPtr<IShellView> pShellView;
 301     HRESULT hr = E_INVALIDARG;
 302
 303     TRACE("(%p)->(hwnd=%p,%s,%p)\n", this,
 304           hwndOwner, shdebugstr_guid (&riid), ppvOut);
 305
 306     if (!ppvOut)
 307         return hr;
 308
 309     *ppvOut = NULL;
 310
 311     if (IsEqualIID(riid, IID_IDropTarget))
 312     {
 313         WARN("IDropTarget not implemented\n");
 314         hr = E_NOTIMPL;
 315     }
 316     else if (IsEqualIID(riid, IID_IContextMenu))
 317     {
 318         WARN("IContextMenu not implemented\n");
 319         hr = E_NOTIMPL;
 320     }
 321     else if (IsEqualIID(riid, IID_IShellView))
 322     {
 323         hr = IShellView_Constructor ((IShellFolder *)this, &pShellView);
 324         if (pShellView)
 325         {
 326             hr = pShellView->QueryInterface(riid, ppvOut);
 327         }
 328     }
 329     TRACE ("-- (%p)->(interface=%p)\n", this, ppvOut);
 330     return hr;
 331 }
 332
 333 /**************************************************************************
 334 *  CDrivesFolder::GetAttributesOf
 335 */
 336 HRESULT WINAPI CDrivesFolder::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD * rgfInOut)
 337 {
 338     static const DWORD dwComputerAttributes =
 339         SFGAO_CANRENAME | SFGAO_CANDELETE | SFGAO_HASPROPSHEET | SFGAO_DROPTARGET |
 340         SFGAO_FILESYSANCESTOR | SFGAO_FOLDER | SFGAO_HASSUBFOLDER | SFGAO_CANLINK;
 341     static const DWORD dwControlPanelAttributes =
 342         SFGAO_HASSUBFOLDER | SFGAO_FOLDER | SFGAO_CANLINK;
 343     static const DWORD dwDriveAttributes =
 344         SFGAO_HASSUBFOLDER | SFGAO_FILESYSTEM | SFGAO_FOLDER | SFGAO_FILESYSANCESTOR |
 345         SFGAO_DROPTARGET | SFGAO_HASPROPSHEET | SFGAO_CANRENAME | SFGAO_CANLINK;
 346
 347     TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08x))\n",
 348            this, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
 349
 350     if (cidl && !apidl)
 351         return E_INVALIDARG;
 352
 353     if (*rgfInOut == 0)
 354         *rgfInOut = ~0;
 355
 356     /* FIXME: always add SFGAO_CANLINK */
 357     if(cidl == 0)
 358         *rgfInOut &= dwComputerAttributes;
 359     else
 360     {
 361         for (UINT i = 0; i < cidl; ++i)
 362         {
 363             if (_ILIsDrive(apidl[i]))
 364                 *rgfInOut &= dwDriveAttributes;
 365             else if (_ILIsControlPanel(apidl[i]))
 366                 *rgfInOut &= dwControlPanelAttributes;
 367             else
 368             {
 369                 pdump(apidl[i]);
 370                 SHELL32_GetItemAttributes(this, apidl[i], rgfInOut);
 371             }
 372         }
 373     }
 374
 375     /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
 376     *rgfInOut &= ~SFGAO_VALIDATE;
 377
 378     TRACE ("-- result=0x%08x\n", *rgfInOut);
 379     return S_OK;
 380 }
 381
 382 /**************************************************************************
 383 *    CDrivesFolder::GetUIObjectOf
 384 *
 385 * PARAMETERS
 386 *  hwndOwner [in]  Parent window for any output
 387 *  cidl      [in]  array size
 388 *  apidl     [in]  simple pidl array
 389 *  riid      [in]  Requested Interface
 390 *  prgfInOut [   ] reserved
 391 *  ppvObject [out] Resulting Interface
 392 *
 393 */
 394 HRESULT WINAPI CDrivesFolder::GetUIObjectOf(HWND hwndOwner,
 395     UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 396     REFIID riid, UINT *prgfInOut, LPVOID *ppvOut)
 397 {
 398     LPITEMIDLIST pidl;
 399     IUnknown *pObj = NULL;
 400     HRESULT hr = E_INVALIDARG;
 401
 402     TRACE("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n", this,
 403           hwndOwner, cidl, apidl, shdebugstr_guid (&riid), prgfInOut, ppvOut);
 404
 405     if (!ppvOut)
 406         return hr;
 407
 408     *ppvOut = NULL;
 409
 410     if (IsEqualIID (riid, IID_IContextMenu) && (cidl >= 1))
 411     {
 412         hr = CDefFolderMenu_Create2(pidlRoot, hwndOwner, cidl, apidl, (IShellFolder*)this, NULL, 0, NULL, (IContextMenu**)&pObj);
 413     }
 414     else if (IsEqualIID (riid, IID_IDataObject) && (cidl >= 1))
 415     {
 416         hr = IDataObject_Constructor (hwndOwner,
 417                                       pidlRoot, apidl, cidl, (IDataObject **)&pObj);
 418     }
 419     else if (IsEqualIID (riid, IID_IExtractIconA) && (cidl == 1))
 420     {
 421         pidl = ILCombine (pidlRoot, apidl[0]);
 422         pObj = IExtractIconA_Constructor (pidl);
 423         SHFree (pidl);
 424         hr = S_OK;
 425     }
 426     else if (IsEqualIID (riid, IID_IExtractIconW) && (cidl == 1))
 427     {
 428         pidl = ILCombine (pidlRoot, apidl[0]);
 429         pObj = IExtractIconW_Constructor (pidl);
 430         SHFree (pidl);
 431         hr = S_OK;
 432     }
 433     else if (IsEqualIID (riid, IID_IDropTarget) && (cidl >= 1))
 434     {
 435         IDropTarget * pDt = NULL;
 436         hr = this->QueryInterface(IID_PPV_ARG(IDropTarget, &pDt));
 437         pObj = pDt;
 438     }
 439     else if ((IsEqualIID(riid, IID_IShellLinkW) ||
 440               IsEqualIID(riid, IID_IShellLinkA)) && (cidl == 1))
 441     {
 442         pidl = ILCombine (pidlRoot, apidl[0]);
 443         hr = IShellLink_ConstructFromFile(NULL, riid, pidl, (LPVOID*) &pObj);
 444         SHFree (pidl);
 445     }
 446     else
 447         hr = E_NOINTERFACE;
 448
 449     if (SUCCEEDED(hr) && !pObj)
 450         hr = E_OUTOFMEMORY;
 451
 452     *ppvOut = pObj;
 453     TRACE ("(%p)->hr=0x%08x\n", this, hr);
 454     return hr;
 455 }
 456
 457 /**************************************************************************
 458 *    CDrivesFolder::GetDisplayNameOf
 459 */
 460 HRESULT WINAPI CDrivesFolder::GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
 461 {
 462     LPWSTR pszPath;
 463     HRESULT hr = S_OK;
 464
 465     TRACE ("(%p)->(pidl=%p,0x%08x,%p)\n", this, pidl, dwFlags, strRet);
 466     pdump (pidl);
 467
 468     if (!strRet)
 469         return E_INVALIDARG;
 470
 471     pszPath = (LPWSTR)CoTaskMemAlloc((MAX_PATH + 1) * sizeof(WCHAR));
 472     if (!pszPath)
 473         return E_OUTOFMEMORY;
 474
 475     pszPath[0] = 0;
 476
 477     if (!pidl->mkid.cb)
 478     {
 479         /* parsing name like ::{...} */
 480         pszPath[0] = ':';
 481         pszPath[1] = ':';
 482         SHELL32_GUIDToStringW(CLSID_MyComputer, &pszPath[2]);
 483     }
 484     else if (_ILIsPidlSimple(pidl))
 485     {
 486         /* take names of special folders only if its only this folder */
 487         if (_ILIsSpecialFolder(pidl))
 488         {
 489             GUID const *clsid;
 490
 491             clsid = _ILGetGUIDPointer (pidl);
 492             if (clsid)
 493             {
 494                 if (GET_SHGDN_FOR (dwFlags) == SHGDN_FORPARSING)
 495                 {
 496                     static const WCHAR clsidW[] = L"CLSID\\";
 497                     static const WCHAR shellfolderW[] = L"\\shellfolder";
 498                     static const WCHAR wantsForParsingW[] = L"WantsForParsing";
 499                     BOOL bWantsForParsing = FALSE;
 500                     WCHAR szRegPath[100];
 501                     LONG r;
 502
 503                     /*
 504                      * We can only get a filesystem path from a shellfolder
 505                      * if the value WantsFORPARSING exists in
 506                      *      CLSID\\{...}\\shellfolder
 507                      * exception: the MyComputer folder has this keys not
 508                      *            but like any filesystem backed
 509                      *            folder it needs these behaviour
 510                      *
 511                      * Get the "WantsFORPARSING" flag from the registry
 512                      */
 513
 514                     wcscpy(szRegPath, clsidW);
 515                     SHELL32_GUIDToStringW(*clsid, &szRegPath[6]);
 516                     wcscat(szRegPath, shellfolderW);
 517                     r = SHGetValueW(HKEY_CLASSES_ROOT, szRegPath,
 518                                     wantsForParsingW, NULL, NULL, NULL);
 519                     if (r == ERROR_SUCCESS)
 520                         bWantsForParsing = TRUE;
 521
 522                     if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
 523                             bWantsForParsing)
 524                     {
 525                         /*
 526                          * We need the filesystem path to the destination folder
 527                          * Only the folder itself can know it
 528                          */
 529                         hr = SHELL32_GetDisplayNameOfChild (this, pidl,
 530                                                             dwFlags, pszPath, MAX_PATH);
 531                     }
 532                     else
 533                     {
 534                         LPWSTR p = pszPath;
 535
 536                         /* parsing name like ::{...} */
 537                         p[0] = ':';
 538                         p[1] = ':';
 539                         p += 2;
 540                         p += SHELL32_GUIDToStringW(CLSID_MyComputer, p);
 541
 542                         /* \:: */
 543                         p[0] = '\\';
 544                         p[1] = ':';
 545                         p[2] = ':';
 546                         p += 3;
 547                         SHELL32_GUIDToStringW(*clsid, p);
 548                     }
 549                 }
 550                 else
 551                 {
 552                     /* user friendly name */
 553
 554                     if (_ILIsMyComputer(pidl) && sName)
 555                         wcscpy(pszPath, sName);
 556                     else
 557                         HCR_GetClassNameW (*clsid, pszPath, MAX_PATH);
 558
 559                     TRACE("pszPath %s\n", debugstr_w(pszPath));
 560                 }
 561             }
 562             else
 563             {
 564                 /* append my own path */
 565                 _ILSimpleGetTextW(pidl, pszPath, MAX_PATH);
 566             }
 567         }
 568         else if (_ILIsDrive(pidl))
 569         {
 570
 571             _ILSimpleGetTextW(pidl, pszPath, MAX_PATH);    /* append my own path */
 572             /* long view "lw_name (C:)" */
 573             if (!(dwFlags & SHGDN_FORPARSING))
 574             {
 575                 WCHAR wszDrive[18] = {0};
 576                 DWORD dwVolumeSerialNumber, dwMaximumComponentLength, dwFileSystemFlags;
 577                 static const WCHAR wszOpenBracket[] = {' ', '(', 0};
 578                 static const WCHAR wszCloseBracket[] = {')', 0};
 579
 580                 lstrcpynW(wszDrive, pszPath, 4);
 581                 pszPath[0] = L'\0';
 582                 GetVolumeInformationW(wszDrive, pszPath,
 583                                       MAX_PATH - 7,
 584                                       &dwVolumeSerialNumber,
 585                                       &dwMaximumComponentLength, &dwFileSystemFlags, NULL, 0);
 586                 pszPath[MAX_PATH-1] = L'\0';
 587                 if (!wcslen(pszPath))
 588                 {
 589                     UINT DriveType, ResourceId;
 590                     DriveType = GetDriveTypeW(wszDrive);
 591                     switch(DriveType)
 592                     {
 593                         case DRIVE_FIXED:
 594                             ResourceId = IDS_DRIVE_FIXED;
 595                             break;
 596                         case DRIVE_REMOTE:
 597                             ResourceId = IDS_DRIVE_NETWORK;
 598                             break;
 599                         case DRIVE_CDROM:
 600                             ResourceId = IDS_DRIVE_CDROM;
 601                             break;
 602                         default:
 603                             ResourceId = 0;
 604                     }
 605                     if (ResourceId)
 606                     {
 607                         dwFileSystemFlags = LoadStringW(shell32_hInstance, ResourceId, pszPath, MAX_PATH);
 608                         if (dwFileSystemFlags > MAX_PATH - 7)
 609                             pszPath[MAX_PATH-7] = L'\0';
 610                     }
 611                 }
 612                 wcscat (pszPath, wszOpenBracket);
 613                 wszDrive[2] = L'\0';
 614                 wcscat (pszPath, wszDrive);
 615                 wcscat (pszPath, wszCloseBracket);
 616             }
 617         }
 618         else
 619         {
 620             /* Neither a shell namespace extension nor a drive letter. */
 621             ERR("Wrong pidl type\n");
 622             CoTaskMemFree(pszPath);
 623             return E_INVALIDARG;
 624         }
 625     }
 626     else
 627     {
 628         /* Complex pidl. Let the child folder do the work */
 629         hr = SHELL32_GetDisplayNameOfChild(this, pidl, dwFlags, pszPath, MAX_PATH);
 630     }
 631
 632     if (SUCCEEDED(hr))
 633     {
 634         strRet->uType = STRRET_WSTR;
 635         strRet->pOleStr = pszPath;
 636     }
 637     else
 638         CoTaskMemFree(pszPath);
 639
 640     TRACE("-- (%p)->(%s)\n", this, strRet->uType == STRRET_CSTR ? strRet->cStr : debugstr_w(strRet->pOleStr));
 641     return hr;
 642 }
 643
 644 /**************************************************************************
 645 *  CDrivesFolder::SetNameOf
 646 *  Changes the name of a file object or subfolder, possibly changing its item
 647 *  identifier in the process.
 648 *
 649 * PARAMETERS
 650 *  hwndOwner  [in]   Owner window for output
 651 *  pidl       [in]   simple pidl of item to change
 652 *  lpszName   [in]   the items new display name
 653 *  dwFlags    [in]   SHGNO formatting flags
 654 *  ppidlOut   [out]  simple pidl returned
 655 */
 656 HRESULT WINAPI CDrivesFolder::SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl,
 657                                         LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
 658 {
 659     LPWSTR sName;
 660     HKEY hKey;
 661     UINT length;
 662     WCHAR szName[30];
 663
 664     TRACE("(%p)->(%p,pidl=%p,%s,%u,%p)\n", this,
 665           hwndOwner, pidl, debugstr_w (lpName), dwFlags, pPidlOut);
 666
 667     if (_ILIsDrive(pidl))
 668     {
 669         if (_ILSimpleGetTextW(pidl, szName, _countof(szName)))
 670             SetVolumeLabelW(szName, lpName);
 671         if (pPidlOut)
 672             *pPidlOut = _ILCreateDrive(szName);
 673         return S_OK;
 674     }
 675
 676
 677     if (pPidlOut != NULL)
 678         *pPidlOut = _ILCreateMyComputer();
 679
 680     length = (wcslen(lpName) + 1) * sizeof(WCHAR);
 681     sName = (LPWSTR)SHAlloc(length);
 682
 683     if (!sName)
 684         return E_OUTOFMEMORY;
 685
 686     if (RegOpenKeyExW(HKEY_CURRENT_USER,
 687                       L"Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\CLSID\\{20D04FE0-3AEA-1069-A2D8-08002B30309D}",
 688                       0,
 689                       KEY_WRITE,
 690                       &hKey) != ERROR_SUCCESS)
 691     {
 692         WARN("Error: failed to open registry key\n");
 693     }
 694     else
 695     {
 696         RegSetValueExW(hKey, NULL, 0, REG_SZ, (const LPBYTE)lpName, length);
 697         RegCloseKey(hKey);
 698     }
 699
 700     wcscpy(sName, lpName);
 701     SHFree(this->sName);
 702     this->sName = sName;
 703     TRACE("result %s\n", debugstr_w(sName));
 704     return S_OK;
 705 }
 706
 707 HRESULT WINAPI CDrivesFolder::GetDefaultSearchGUID(GUID * pguid)
 708 {
 709     FIXME ("(%p)\n", this);
 710     return E_NOTIMPL;
 711 }
 712
 713 HRESULT WINAPI CDrivesFolder::EnumSearches(IEnumExtraSearch ** ppenum)
 714 {
 715     FIXME ("(%p)\n", this);
 716     return E_NOTIMPL;
 717 }
 718
 719 HRESULT WINAPI CDrivesFolder::GetDefaultColumn (DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
 720 {
 721     TRACE ("(%p)\n", this);
 722
 723     if (pSort)
 724         *pSort = 0;
 725     if (pDisplay)
 726         *pDisplay = 0;
 727     return S_OK;
 728 }
 729
 730 HRESULT WINAPI CDrivesFolder::GetDefaultColumnState(UINT iColumn, DWORD * pcsFlags)
 731 {
 732     TRACE ("(%p)\n", this);
 733
 734     if (!pcsFlags || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS)
 735         return E_INVALIDARG;
 736     *pcsFlags = MyComputerSFHeader[iColumn].pcsFlags;
 737     return S_OK;
 738 }
 739
 740 HRESULT WINAPI CDrivesFolder::GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID * pscid, VARIANT * pv)
 741 {
 742     FIXME ("(%p)\n", this);
 743     return E_NOTIMPL;
 744 }
 745
 746 /* FIXME: drive size >4GB is rolling over */
 747 HRESULT WINAPI CDrivesFolder::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
 748 {
 749     HRESULT hr;
 750
 751     TRACE ("(%p)->(%p %i %p)\n", this, pidl, iColumn, psd);
 752
 753     if (!psd || iColumn >= MYCOMPUTERSHELLVIEWCOLUMNS)
 754         return E_INVALIDARG;
 755
 756     if (!pidl)
 757     {
 758         psd->fmt = MyComputerSFHeader[iColumn].fmt;
 759         psd->cxChar = MyComputerSFHeader[iColumn].cxChar;
 760         psd->str.uType = STRRET_CSTR;
 761         LoadStringA(shell32_hInstance, MyComputerSFHeader[iColumn].colnameid,
 762                     psd->str.cStr, MAX_PATH);
 763         return S_OK;
 764     }
 765     else
 766     {
 767         char szPath[MAX_PATH];
 768         ULARGE_INTEGER ulBytes;
 769
 770         psd->str.cStr[0] = 0x00;
 771         psd->str.uType = STRRET_CSTR;
 772         switch (iColumn)
 773         {
 774             case 0:        /* name */
 775                 hr = GetDisplayNameOf(pidl,
 776                                       SHGDN_NORMAL | SHGDN_INFOLDER, &psd->str);
 777                 break;
 778             case 1:        /* type */
 779                 _ILGetFileType(pidl, psd->str.cStr, MAX_PATH);
 780                 break;
 781             case 2:        /* total size */
 782                 if (_ILIsDrive(pidl))
 783                 {
 784                     _ILSimpleGetText (pidl, szPath, MAX_PATH);
 785                     GetDiskFreeSpaceExA (szPath, NULL, &ulBytes, NULL);
 786                     StrFormatByteSizeA (ulBytes.LowPart, psd->str.cStr, MAX_PATH);
 787                 }
 788                 break;
 789             case 3:        /* free size */
 790                 if (_ILIsDrive(pidl))
 791                 {
 792                     _ILSimpleGetText (pidl, szPath, MAX_PATH);
 793                     GetDiskFreeSpaceExA (szPath, &ulBytes, NULL, NULL);
 794                     StrFormatByteSizeA (ulBytes.LowPart, psd->str.cStr, MAX_PATH);
 795                 }
 796                 break;
 797         }
 798         hr = S_OK;
 799     }
 800
 801     return hr;
 802 }
 803
 804 HRESULT WINAPI CDrivesFolder::MapColumnToSCID(UINT column, SHCOLUMNID * pscid)
 805 {
 806     FIXME("(%p)\n", this);
 807     return E_NOTIMPL;
 808 }
 809
 810 /************************************************************************
 811  *    CDrivesFolder::GetClassID
 812  */
 813 HRESULT WINAPI CDrivesFolder::GetClassID(CLSID *lpClassId)
 814 {
 815     TRACE ("(%p)\n", this);
 816
 817     if (!lpClassId)
 818         return E_POINTER;
 819
 820     *lpClassId = CLSID_MyComputer;
 821     return S_OK;
 822 }
 823
 824 /************************************************************************
 825  *    CDrivesFolder::Initialize
 826  *
 827  * NOTES: it makes no sense to change the pidl
 828  */
 829 HRESULT WINAPI CDrivesFolder::Initialize(LPCITEMIDLIST pidl)
 830 {
 831     TRACE ("(%p)->(%p)\n", this, pidl);
 832
 833     if (pidlRoot)
 834         SHFree((LPVOID)pidlRoot);
 835
 836     pidlRoot = ILClone(pidl);
 837     return S_OK;
 838 }
 839
 840 /**************************************************************************
 841  *    CDrivesFolder::GetCurFolder
 842  */
 843 HRESULT WINAPI CDrivesFolder::GetCurFolder(LPITEMIDLIST *pidl)
 844 {
 845     TRACE("(%p)->(%p)\n", this, pidl);
 846
 847     if (!pidl)
 848         return E_POINTER;
 849
 850     *pidl = ILClone(pidlRoot);
 851     return S_OK;
 852 }