dlls/shell32/shfldr_mycomp.c

   1 /*
   2  *    Virtual Workplace folder
   3  *
   4  *    Copyright 1997            Marcus Meissner
   5  *    Copyright 1998, 1999, 2002    Juergen Schmied
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26
  27 #define COBJMACROS
  28 #define NONAMELESSUNION
  29
  30 #include "winerror.h"
  31 #include "windef.h"
  32 #include "winbase.h"
  33 #include "winreg.h"
  34
  35 #include "wingdi.h"
  36 #include "pidl.h"
  37 #include "shlguid.h"
  38 #include "shell32_main.h"
  39 #include "shresdef.h"
  40 #include "shlwapi.h"
  41 #include "wine/debug.h"
  42 #include "debughlp.h"
  43 #include "shfldr.h"
  44
  45 WINE_DEFAULT_DEBUG_CHANNEL (shell);
  46
  47 /***********************************************************************
  48 *   IShellFolder implementation
  49 */
  50
  51 typedef struct {
  52     IShellFolder2   IShellFolder2_iface;
  53     IPersistFolder2 IPersistFolder2_iface;
  54     LONG            ref;
  55
  56     /* both paths are parsible from the desktop */
  57     LPITEMIDLIST pidlRoot;    /* absolute pidl */
  58 } IMyComputerFolderImpl;
  59
  60 static const IShellFolder2Vtbl vt_ShellFolder2;
  61 static const IPersistFolder2Vtbl vt_PersistFolder2;
  62
  63 static inline IMyComputerFolderImpl *impl_from_IShellFolder2(IShellFolder2 *iface)
  64 {
  65     return CONTAINING_RECORD(iface, IMyComputerFolderImpl, IShellFolder2_iface);
  66 }
  67
  68 static inline IMyComputerFolderImpl *impl_from_IPersistFolder2(IPersistFolder2 *iface)
  69 {
  70     return CONTAINING_RECORD(iface, IMyComputerFolderImpl, IPersistFolder2_iface);
  71 }
  72
  73
  74 /***********************************************************************
  75 *   IShellFolder [MyComputer] implementation
  76 */
  77
  78 static const shvheader mycomputer_header[] =
  79 {
  80     { &FMTID_Storage, PID_STG_NAME, IDS_SHV_COLUMN1, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 15 },
  81     { &FMTID_Storage, PID_STG_STORAGETYPE, IDS_SHV_COLUMN3, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
  82     { NULL, 0, IDS_SHV_COLUMN6, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
  83     { NULL, 0, IDS_SHV_COLUMN7, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT, LVCFMT_RIGHT, 10 },
  84 };
  85
  86 /**************************************************************************
  87 *    ISF_MyComputer_Constructor
  88 */
  89 HRESULT WINAPI ISF_MyComputer_Constructor (IUnknown * pUnkOuter, REFIID riid, LPVOID * ppv)
  90 {
  91     IMyComputerFolderImpl *sf;
  92
  93     TRACE ("unkOut=%p %s\n", pUnkOuter, shdebugstr_guid (riid));
  94
  95     if (!ppv)
  96         return E_POINTER;
  97     if (pUnkOuter)
  98         return CLASS_E_NOAGGREGATION;
  99
 100     sf = LocalAlloc (LMEM_ZEROINIT, sizeof (IMyComputerFolderImpl));
 101     if (!sf)
 102         return E_OUTOFMEMORY;
 103
 104     sf->ref = 0;
 105     sf->IShellFolder2_iface.lpVtbl = &vt_ShellFolder2;
 106     sf->IPersistFolder2_iface.lpVtbl = &vt_PersistFolder2;
 107     sf->pidlRoot = _ILCreateMyComputer ();    /* my qualified pidl */
 108
 109     if (FAILED (IShellFolder2_QueryInterface (&sf->IShellFolder2_iface, riid, ppv)))
 110     {
 111         IShellFolder2_Release (&sf->IShellFolder2_iface);
 112         return E_NOINTERFACE;
 113     }
 114
 115     TRACE ("--(%p)\n", sf);
 116     return S_OK;
 117 }
 118
 119 /**************************************************************************
 120  *    ISF_MyComputer_fnQueryInterface
 121  *
 122  * NOTES supports not IPersist/IPersistFolder
 123  */
 124 static HRESULT WINAPI ISF_MyComputer_fnQueryInterface (IShellFolder2 *iface,
 125                REFIID riid, LPVOID *ppvObj)
 126 {
 127     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 128
 129     TRACE ("(%p)->(%s,%p)\n", This, shdebugstr_guid (riid), ppvObj);
 130
 131     *ppvObj = NULL;
 132
 133     if (IsEqualIID (riid, &IID_IUnknown) ||
 134         IsEqualIID (riid, &IID_IShellFolder) ||
 135         IsEqualIID (riid, &IID_IShellFolder2))
 136     {
 137         *ppvObj = &This->IShellFolder2_iface;
 138     }
 139     else if (IsEqualIID (riid, &IID_IPersist) ||
 140              IsEqualIID (riid, &IID_IPersistFolder) ||
 141              IsEqualIID (riid, &IID_IPersistFolder2))
 142     {
 143         *ppvObj = &This->IPersistFolder2_iface;
 144     }
 145
 146     if (*ppvObj)
 147     {
 148         IUnknown_AddRef ((IUnknown *) (*ppvObj));
 149         TRACE ("-- Interface: (%p)->(%p)\n", ppvObj, *ppvObj);
 150         return S_OK;
 151     }
 152     TRACE ("-- Interface: E_NOINTERFACE\n");
 153     return E_NOINTERFACE;
 154 }
 155
 156 static ULONG WINAPI ISF_MyComputer_fnAddRef (IShellFolder2 * iface)
 157 {
 158     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 159     ULONG refCount = InterlockedIncrement(&This->ref);
 160
 161     TRACE ("(%p)->(count=%lu)\n", This, refCount - 1);
 162
 163     return refCount;
 164 }
 165
 166 static ULONG WINAPI ISF_MyComputer_fnRelease (IShellFolder2 * iface)
 167 {
 168     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 169     ULONG refCount = InterlockedDecrement(&This->ref);
 170
 171     TRACE ("(%p)->(count=%lu)\n", This, refCount + 1);
 172
 173     if (!refCount)
 174     {
 175         TRACE ("-- destroying IShellFolder(%p)\n", This);
 176         SHFree (This->pidlRoot);
 177         LocalFree (This);
 178     }
 179     return refCount;
 180 }
 181
 182 /**************************************************************************
 183 *    ISF_MyComputer_fnParseDisplayName
 184 */
 185 static HRESULT WINAPI ISF_MyComputer_fnParseDisplayName (IShellFolder2 *iface,
 186                HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName,
 187                DWORD * pchEaten, LPITEMIDLIST * ppidl, DWORD * pdwAttributes)
 188 {
 189     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 190     HRESULT hr = E_INVALIDARG;
 191     LPCWSTR szNext = NULL;
 192     WCHAR c, szElement[MAX_PATH];
 193     LPITEMIDLIST pidlTemp = NULL;
 194     CLSID clsid;
 195
 196     TRACE("(%p)->(HWND=%p,%p,%p=%s,%p,pidl=%p,%p)\n", This,
 197           hwndOwner, pbc, lpszDisplayName, debugstr_w (lpszDisplayName),
 198           pchEaten, ppidl, pdwAttributes);
 199
 200     *ppidl = 0;
 201     if (pchEaten)
 202         *pchEaten = 0;        /* strange but like the original */
 203
 204     /* handle CLSID paths */
 205     if (lpszDisplayName[0] == ':' && lpszDisplayName[1] == ':')
 206     {
 207         szNext = GetNextElementW (lpszDisplayName, szElement, MAX_PATH);
 208         TRACE ("-- element: %s\n", debugstr_w (szElement));
 209         SHCLSIDFromStringW (szElement + 2, &clsid);
 210         pidlTemp = _ILCreateGuid (PT_GUID, &clsid);
 211     }
 212     /* we can't use PathGetDriveNumberW because we can't have the \\?\ prefix */
 213     else if ((c = towupper(lpszDisplayName[0])) >= 'A' && c <= 'Z' &&
 214              lpszDisplayName[1] == ':' &&
 215              (lpszDisplayName[2] == '\\' || lpszDisplayName[2] == '\0'))
 216     {
 217         /* drive letter has to be uppercase to enable PIDL comparison */
 218         szElement[0] = c;
 219         szElement[1] = ':';
 220         szElement[2] = '\\';
 221         szElement[3] = '\0';
 222         szNext = &lpszDisplayName[2] + (lpszDisplayName[2] == '\\');
 223         pidlTemp = _ILCreateDrive (szElement);
 224     }
 225
 226     if (szNext && *szNext)
 227     {
 228         hr = SHELL32_ParseNextElement (iface, hwndOwner, pbc, &pidlTemp,
 229                               (LPOLESTR) szNext, pchEaten, pdwAttributes);
 230     }
 231     else if (pidlTemp)
 232     {
 233         if (pdwAttributes && *pdwAttributes)
 234             SHELL32_GetItemAttributes (&This->IShellFolder2_iface, pidlTemp, pdwAttributes);
 235         hr = S_OK;
 236     }
 237
 238     *ppidl = pidlTemp;
 239
 240     TRACE ("(%p)->(-- ret=0x%08lx)\n", This, hr);
 241
 242     return hr;
 243 }
 244
 245 /* retrieve a map of drives that should be displayed */
 246 static DWORD get_drive_map(void)
 247 {
 248     static DWORD drive_mask;
 249     static BOOL init_done = FALSE;
 250
 251     if (!init_done)
 252     {
 253         DWORD type, size, data, mask = 0;
 254         HKEY hkey;
 255
 256         if (!RegOpenKeyW( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", &hkey ))
 257         {
 258             size = sizeof(data);
 259             if (!RegQueryValueExW( hkey, L"NoDrives", NULL, &type, (LPBYTE)&data, &size ) && type == REG_DWORD)
 260                 mask |= data;
 261             RegCloseKey( hkey );
 262         }
 263         if (!RegOpenKeyW( HKEY_CURRENT_USER, L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies\\Explorer", &hkey ))
 264         {
 265             size = sizeof(data);
 266             if (!RegQueryValueExW( hkey, L"NoDrives", NULL, &type, (LPBYTE)&data, &size ) && type == REG_DWORD)
 267                 mask |= data;
 268             RegCloseKey( hkey );
 269         }
 270         drive_mask = mask;
 271         init_done = TRUE;
 272     }
 273
 274     return GetLogicalDrives() & ~drive_mask;
 275 }
 276
 277 /**************************************************************************
 278  *  CreateMyCompEnumList()
 279  */
 280 static BOOL CreateMyCompEnumList(IEnumIDListImpl *list, DWORD dwFlags)
 281 {
 282     BOOL ret = TRUE;
 283
 284     TRACE("(%p)->(flags=0x%08lx)\n", list, dwFlags);
 285
 286     /* enumerate the folders */
 287     if (dwFlags & SHCONTF_FOLDERS)
 288     {
 289         WCHAR wszDriveName[] = L"A:\\";
 290         DWORD dwDrivemap = get_drive_map();
 291         HKEY hkey;
 292         UINT i;
 293
 294         while (ret && wszDriveName[0]<='Z')
 295         {
 296             if(dwDrivemap & 0x00000001L)
 297                 ret = AddToEnumList(list, _ILCreateDrive(wszDriveName));
 298             wszDriveName[0]++;
 299             dwDrivemap = dwDrivemap >> 1;
 300         }
 301
 302         TRACE("-- (%p)-> enumerate (mycomputer shell extensions)\n",list);
 303         for (i=0; i<2; i++) {
 304             if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
 305                                       L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\MyComputer\\Namespace",
 306                                       0, KEY_READ, &hkey))
 307             {
 308                 WCHAR iid[50];
 309                 int i=0;
 310
 311                 while (ret)
 312                 {
 313                     DWORD size;
 314                     LONG r;
 315
 316                     size = ARRAY_SIZE(iid);
 317                     r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
 318                     if (ERROR_SUCCESS == r)
 319                     {
 320                         /* FIXME: shell extensions, shouldn't the type be
 321                          * PT_SHELLEXT? */
 322                         ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid));
 323                         i++;
 324                     }
 325                     else if (ERROR_NO_MORE_ITEMS == r)
 326                         break;
 327                     else
 328                         ret = FALSE;
 329                 }
 330                 RegCloseKey(hkey);
 331             }
 332         }
 333     }
 334     return ret;
 335 }
 336
 337 /**************************************************************************
 338 *        ISF_MyComputer_fnEnumObjects
 339 */
 340 static HRESULT WINAPI ISF_MyComputer_fnEnumObjects (IShellFolder2 *iface,
 341                HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 342 {
 343     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 344     IEnumIDListImpl *list;
 345
 346     TRACE("(%p)->(HWND=%p flags=0x%08lx pplist=%p)\n", This,
 347           hwndOwner, dwFlags, ppEnumIDList);
 348
 349     if (!(list = IEnumIDList_Constructor()))
 350         return E_OUTOFMEMORY;
 351     CreateMyCompEnumList(list, dwFlags);
 352     *ppEnumIDList = &list->IEnumIDList_iface;
 353
 354     TRACE ("-- (%p)->(new ID List: %p)\n", This, *ppEnumIDList);
 355
 356     return S_OK;
 357 }
 358
 359 /**************************************************************************
 360 *        ISF_MyComputer_fnBindToObject
 361 */
 362 static HRESULT WINAPI ISF_MyComputer_fnBindToObject (IShellFolder2 *iface,
 363                LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 364 {
 365     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 366
 367     TRACE("(%p)->(pidl=%p,%p,%s,%p)\n", This,
 368           pidl, pbcReserved, shdebugstr_guid (riid), ppvOut);
 369
 370     return SHELL32_BindToChild (This->pidlRoot, &CLSID_ShellFSFolder, NULL, pidl, riid, ppvOut);
 371 }
 372
 373 /**************************************************************************
 374 *    ISF_MyComputer_fnBindToStorage
 375 */
 376 static HRESULT WINAPI ISF_MyComputer_fnBindToStorage (IShellFolder2 * iface,
 377                LPCITEMIDLIST pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
 378 {
 379     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 380
 381     FIXME("(%p)->(pidl=%p,%p,%s,%p) stub\n", This,
 382           pidl, pbcReserved, shdebugstr_guid (riid), ppvOut);
 383
 384     *ppvOut = NULL;
 385     return E_NOTIMPL;
 386 }
 387
 388 /**************************************************************************
 389 *     ISF_MyComputer_fnCompareIDs
 390 */
 391
 392 static HRESULT WINAPI ISF_MyComputer_fnCompareIDs (IShellFolder2 *iface,
 393                LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 394 {
 395     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 396     HRESULT hr;
 397
 398     TRACE ("(%p)->(0x%08Ix,pidl1=%p,pidl2=%p)\n", This, lParam, pidl1, pidl2);
 399     hr = SHELL32_CompareIDs(&This->IShellFolder2_iface, lParam, pidl1, pidl2);
 400     TRACE ("-- 0x%08lx\n", hr);
 401     return hr;
 402 }
 403
 404 /**************************************************************************
 405 *    ISF_MyComputer_fnCreateViewObject
 406 */
 407 static HRESULT WINAPI ISF_MyComputer_fnCreateViewObject (IShellFolder2 *iface,
 408                HWND hwndOwner, REFIID riid, LPVOID * ppvOut)
 409 {
 410     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 411     LPSHELLVIEW pShellView;
 412     HRESULT hr = E_INVALIDARG;
 413
 414     TRACE("(%p)->(hwnd=%p,%s,%p)\n", This,
 415           hwndOwner, shdebugstr_guid (riid), ppvOut);
 416
 417     if (!ppvOut)
 418         return hr;
 419
 420     *ppvOut = NULL;
 421
 422     if (IsEqualIID (riid, &IID_IDropTarget))
 423     {
 424         WARN ("IDropTarget not implemented\n");
 425         hr = E_NOTIMPL;
 426     }
 427     else if (IsEqualIID (riid, &IID_IContextMenu))
 428     {
 429         hr = BackgroundMenu_Constructor((IShellFolder*)iface, FALSE, riid, ppvOut);
 430     }
 431     else if (IsEqualIID (riid, &IID_IShellView))
 432     {
 433         pShellView = IShellView_Constructor ((IShellFolder *) iface);
 434         if (pShellView)
 435         {
 436             hr = IShellView_QueryInterface (pShellView, riid, ppvOut);
 437             IShellView_Release (pShellView);
 438         }
 439     }
 440     TRACE ("-- (%p)->(interface=%p)\n", This, ppvOut);
 441     return hr;
 442 }
 443
 444 /**************************************************************************
 445 *  ISF_MyComputer_fnGetAttributesOf
 446 */
 447 static HRESULT WINAPI ISF_MyComputer_fnGetAttributesOf (IShellFolder2 * iface,
 448                 UINT cidl, LPCITEMIDLIST * apidl, DWORD * rgfInOut)
 449 {
 450     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 451     HRESULT hr = S_OK;
 452
 453     TRACE ("(%p)->(cidl=%d apidl=%p mask=%p (0x%08lx))\n",
 454            This, cidl, apidl, rgfInOut, rgfInOut ? *rgfInOut : 0);
 455
 456     if (!rgfInOut)
 457         return E_INVALIDARG;
 458     if (cidl && !apidl)
 459         return E_INVALIDARG;
 460
 461     if (*rgfInOut == 0)
 462         *rgfInOut = ~0;
 463
 464     if(cidl == 0){
 465         IShellFolder2 *parent = NULL;
 466         LPCITEMIDLIST rpidl = NULL;
 467
 468         hr = SHBindToParent(This->pidlRoot, &IID_IShellFolder2, (void **)&parent, &rpidl);
 469         if(SUCCEEDED(hr)) {
 470             SHELL32_GetItemAttributes(parent, rpidl, rgfInOut);
 471             IShellFolder2_Release(parent);
 472         }
 473     } else {
 474         while (cidl > 0 && *apidl) {
 475             pdump (*apidl);
 476             SHELL32_GetItemAttributes(&This->IShellFolder2_iface, *apidl, rgfInOut);
 477             apidl++;
 478             cidl--;
 479         }
 480     }
 481     /* make sure SFGAO_VALIDATE is cleared, some apps depend on that */
 482     *rgfInOut &= ~SFGAO_VALIDATE;
 483
 484     TRACE ("-- result=0x%08lx\n", *rgfInOut);
 485     return hr;
 486 }
 487
 488 /**************************************************************************
 489 *    ISF_MyComputer_fnGetUIObjectOf
 490 *
 491 * PARAMETERS
 492 *  hwndOwner [in]  Parent window for any output
 493 *  cidl      [in]  array size
 494 *  apidl     [in]  simple pidl array
 495 *  riid      [in]  Requested Interface
 496 *  prgfInOut [   ] reserved
 497 *  ppvObject [out] Resulting Interface
 498 *
 499 */
 500 static HRESULT WINAPI ISF_MyComputer_fnGetUIObjectOf (IShellFolder2 * iface,
 501                 HWND hwndOwner, UINT cidl, LPCITEMIDLIST * apidl, REFIID riid,
 502                 UINT * prgfInOut, LPVOID * ppvOut)
 503 {
 504     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 505
 506     LPITEMIDLIST pidl;
 507     IUnknown *pObj = NULL;
 508     HRESULT hr = E_INVALIDARG;
 509
 510     TRACE("(%p)->(%p,%u,apidl=%p,%s,%p,%p)\n", This,
 511           hwndOwner, cidl, apidl, shdebugstr_guid (riid), prgfInOut, ppvOut);
 512
 513     if (!ppvOut)
 514         return hr;
 515
 516     *ppvOut = NULL;
 517
 518     if (IsEqualIID (riid, &IID_IContextMenu) && (cidl >= 1))
 519     {
 520         return ItemMenu_Constructor((IShellFolder*) iface, This->pidlRoot, apidl, cidl, riid, ppvOut);
 521     }
 522     else if (IsEqualIID (riid, &IID_IDataObject) && (cidl >= 1))
 523     {
 524         pObj = (LPUNKNOWN) IDataObject_Constructor (hwndOwner,
 525                                               This->pidlRoot, apidl, cidl);
 526         hr = S_OK;
 527     }
 528     else if (IsEqualIID (riid, &IID_IExtractIconA) && (cidl == 1))
 529     {
 530         pidl = ILCombine (This->pidlRoot, apidl[0]);
 531         pObj = (LPUNKNOWN) IExtractIconA_Constructor (pidl);
 532         SHFree (pidl);
 533         hr = S_OK;
 534     }
 535     else if (IsEqualIID (riid, &IID_IExtractIconW) && (cidl == 1))
 536     {
 537         pidl = ILCombine (This->pidlRoot, apidl[0]);
 538         pObj = (LPUNKNOWN) IExtractIconW_Constructor (pidl);
 539         SHFree (pidl);
 540         hr = S_OK;
 541     }
 542     else if (IsEqualIID (riid, &IID_IDropTarget) && (cidl >= 1))
 543     {
 544         hr = IShellFolder2_QueryInterface (iface, &IID_IDropTarget,
 545                                           (LPVOID *) &pObj);
 546     }
 547     else if ((IsEqualIID(riid,&IID_IShellLinkW) ||
 548               IsEqualIID(riid,&IID_IShellLinkA)) && (cidl == 1))
 549     {
 550         pidl = ILCombine (This->pidlRoot, apidl[0]);
 551         hr = IShellLink_ConstructFromFile(NULL, riid, pidl, &pObj);
 552         SHFree (pidl);
 553     }
 554     else
 555         hr = E_NOINTERFACE;
 556
 557     if (SUCCEEDED(hr) && !pObj)
 558         hr = E_OUTOFMEMORY;
 559
 560     *ppvOut = pObj;
 561     TRACE ("(%p)->hr=0x%08lx\n", This, hr);
 562     return hr;
 563 }
 564
 565 /**************************************************************************
 566 *    ISF_MyComputer_fnGetDisplayNameOf
 567 */
 568 static HRESULT WINAPI ISF_MyComputer_fnGetDisplayNameOf (IShellFolder2 *iface,
 569                LPCITEMIDLIST pidl, DWORD dwFlags, LPSTRRET strRet)
 570 {
 571     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 572
 573     LPWSTR pszPath;
 574     HRESULT hr = S_OK;
 575
 576     TRACE ("(%p)->(pidl=%p,0x%08lx,%p)\n", This, pidl, dwFlags, strRet);
 577     pdump (pidl);
 578
 579     if (!strRet)
 580         return E_INVALIDARG;
 581
 582     pszPath = CoTaskMemAlloc((MAX_PATH +1) * sizeof(WCHAR));
 583     if (!pszPath)
 584         return E_OUTOFMEMORY;
 585
 586     pszPath[0] = 0;
 587
 588     if (!pidl->mkid.cb)
 589     {
 590         /* parsing name like ::{...} */
 591         pszPath[0] = ':';
 592         pszPath[1] = ':';
 593         SHELL32_GUIDToStringW(&CLSID_MyComputer, &pszPath[2]);
 594     }
 595     else if (_ILIsPidlSimple(pidl))
 596     {
 597         /* take names of special folders only if its only this folder */
 598         if (_ILIsSpecialFolder(pidl))
 599         {
 600             GUID const *clsid;
 601
 602             clsid = _ILGetGUIDPointer (pidl);
 603             if (clsid)
 604             {
 605                 if ((GET_SHGDN_FOR (dwFlags) & (SHGDN_FORPARSING | SHGDN_FORADDRESSBAR)) == SHGDN_FORPARSING)
 606                 {
 607                     BOOL bWantsForParsing = FALSE;
 608                     WCHAR szRegPath[100];
 609                     LONG r;
 610
 611                     /*
 612                      * We can only get a filesystem path from a shellfolder
 613                      * if the value WantsFORPARSING exists in
 614                      *      CLSID\\{...}\\shellfolder
 615                      * exception: the MyComputer folder has this keys not
 616                      *            but like any filesystem backed
 617                      *            folder it needs these behaviour
 618                      *
 619                      * Get the "WantsFORPARSING" flag from the registry
 620                      */
 621
 622                     lstrcpyW (szRegPath, L"CLSID\\");
 623                     SHELL32_GUIDToStringW (clsid, &szRegPath[6]);
 624                     lstrcatW (szRegPath, L"\\shellfolder");
 625                     r = SHGetValueW (HKEY_CLASSES_ROOT, szRegPath, L"WantsForParsing", NULL, NULL, NULL);
 626                     if (r == ERROR_SUCCESS)
 627                         bWantsForParsing = TRUE;
 628
 629                     if ((GET_SHGDN_RELATION (dwFlags) == SHGDN_NORMAL) &&
 630                         bWantsForParsing)
 631                     {
 632                         /*
 633                          * We need the filesystem path to the destination folder
 634                          * Only the folder itself can know it
 635                          */
 636                         hr = SHELL32_GetDisplayNameOfChild (iface, pidl,
 637                                                 dwFlags, pszPath, MAX_PATH);
 638                     }
 639                     else
 640                     {
 641                         LPWSTR p = pszPath;
 642
 643                         /* parsing name like ::{...} */
 644                         p[0] = ':';
 645                         p[1] = ':';
 646                         p += 2;
 647                         p += SHELL32_GUIDToStringW(&CLSID_MyComputer, p);
 648
 649                         /* \:: */
 650                         p[0] = '\\';
 651                         p[1] = ':';
 652                         p[2] = ':';
 653                         p += 3;
 654                         SHELL32_GUIDToStringW(clsid, p);
 655                     }
 656                 }
 657                 else
 658                 {
 659                     /* user friendly name */
 660                     HCR_GetClassNameW (clsid, pszPath, MAX_PATH);
 661                 }
 662             }
 663             else
 664             {
 665                 /* append my own path */
 666                 _ILSimpleGetTextW (pidl, pszPath, MAX_PATH);
 667             }
 668         }
 669         else if (_ILIsDrive(pidl))
 670         {
 671             _ILSimpleGetTextW (pidl, pszPath, MAX_PATH);    /* append my own path */
 672
 673             /* long view "lw_name (C:)" */
 674             if (!(dwFlags & SHGDN_FORPARSING))
 675             {
 676                 WCHAR wszDrive[32 /* label */ + 6 /* ' (C:)'\0 */] = {0};
 677
 678                 GetVolumeInformationW (pszPath, wszDrive, ARRAY_SIZE(wszDrive) - 5, NULL, NULL,
 679                         NULL, NULL, 0);
 680                 lstrcatW (wszDrive, L" (");
 681                 lstrcpynW (wszDrive + lstrlenW(wszDrive), pszPath, 3);
 682                 lstrcatW (wszDrive, L")");
 683                 lstrcpyW (pszPath, wszDrive);
 684             }
 685         }
 686         else
 687         {
 688             /* Neither a shell namespace extension nor a drive letter. */
 689             ERR("Wrong pidl type\n");
 690             CoTaskMemFree(pszPath);
 691             return E_INVALIDARG;
 692         }
 693     }
 694     else
 695     {
 696         /* Complex pidl. Let the child folder do the work */
 697         hr = SHELL32_GetDisplayNameOfChild(iface, pidl, dwFlags, pszPath, MAX_PATH);
 698     }
 699
 700     if (SUCCEEDED (hr))
 701     {
 702         /* Win9x always returns ANSI strings, NT always returns Unicode strings */
 703         if (GetVersion() & 0x80000000)
 704         {
 705             strRet->uType = STRRET_CSTR;
 706             if (!WideCharToMultiByte(CP_ACP, 0, pszPath, -1, strRet->u.cStr, MAX_PATH,
 707                     NULL, NULL))
 708                 strRet->u.cStr[0] = '\0';
 709             CoTaskMemFree(pszPath);
 710         }
 711         else
 712         {
 713             strRet->uType = STRRET_WSTR;
 714             strRet->u.pOleStr = pszPath;
 715         }
 716     }
 717     else
 718         CoTaskMemFree(pszPath);
 719
 720     TRACE ("-- (%p)->(%s)\n", This, strRet->uType == STRRET_CSTR ? strRet->u.cStr : debugstr_w(strRet->u.pOleStr));
 721     return hr;
 722 }
 723
 724 /**************************************************************************
 725 *  ISF_MyComputer_fnSetNameOf
 726 *  Changes the name of a file object or subfolder, possibly changing its item
 727 *  identifier in the process.
 728 *
 729 * PARAMETERS
 730 *  hwndOwner  [in]   Owner window for output
 731 *  pidl       [in]   simple pidl of item to change
 732 *  lpszName   [in]   the items new display name
 733 *  dwFlags    [in]   SHGNO formatting flags
 734 *  ppidlOut   [out]  simple pidl returned
 735 */
 736 static HRESULT WINAPI ISF_MyComputer_fnSetNameOf (
 737                IShellFolder2 * iface, HWND hwndOwner, LPCITEMIDLIST pidl,
 738                LPCOLESTR lpName, DWORD dwFlags, LPITEMIDLIST * pPidlOut)
 739 {
 740     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 741     FIXME ("(%p)->(%p,pidl=%p,%s,%lu,%p)\n", This,
 742            hwndOwner, pidl, debugstr_w (lpName), dwFlags, pPidlOut);
 743     return E_FAIL;
 744 }
 745
 746 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultSearchGUID(IShellFolder2 *iface, GUID *guid)
 747 {
 748     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 749     TRACE("(%p)->(%p)\n", This, guid);
 750     return E_NOTIMPL;
 751 }
 752 static HRESULT WINAPI ISF_MyComputer_fnEnumSearches (
 753                IShellFolder2 * iface, IEnumExtraSearch ** ppenum)
 754 {
 755     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 756     FIXME ("(%p)\n", This);
 757     return E_NOTIMPL;
 758 }
 759
 760 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumn(IShellFolder2 *iface, DWORD reserved,
 761         ULONG *sort, ULONG *display)
 762 {
 763     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 764
 765     TRACE("(%p)->(%#lx, %p, %p)\n", This, reserved, sort, display);
 766
 767     return E_NOTIMPL;
 768 }
 769
 770 static HRESULT WINAPI ISF_MyComputer_fnGetDefaultColumnState (
 771                IShellFolder2 * iface, UINT iColumn, DWORD * pcsFlags)
 772 {
 773     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 774
 775     TRACE ("(%p)->(%d %p)\n", This, iColumn, pcsFlags);
 776
 777     if (!pcsFlags || iColumn >= ARRAY_SIZE(mycomputer_header))
 778         return E_INVALIDARG;
 779
 780     *pcsFlags = mycomputer_header[iColumn].pcsFlags;
 781
 782     return S_OK;
 783 }
 784
 785 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsEx (IShellFolder2 * iface,
 786                LPCITEMIDLIST pidl, const SHCOLUMNID * pscid, VARIANT * pv)
 787 {
 788     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 789     FIXME ("(%p)\n", This);
 790     return E_NOTIMPL;
 791 }
 792
 793 /* FIXME: drive size >4GB is rolling over */
 794 static HRESULT WINAPI ISF_MyComputer_fnGetDetailsOf (IShellFolder2 *iface,
 795                LPCITEMIDLIST pidl, UINT iColumn, SHELLDETAILS *psd)
 796 {
 797     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 798     char szPath[MAX_PATH];
 799     ULARGE_INTEGER ulBytes;
 800     HRESULT hr = S_OK;
 801
 802     TRACE ("(%p)->(%p %i %p)\n", This, pidl, iColumn, psd);
 803
 804     if (!psd || iColumn >= ARRAY_SIZE(mycomputer_header))
 805         return E_INVALIDARG;
 806
 807     if (!pidl)
 808         return SHELL32_GetColumnDetails(mycomputer_header, iColumn, psd);
 809
 810     psd->str.u.cStr[0] = 0;
 811     psd->str.uType = STRRET_CSTR;
 812
 813     switch (iColumn)
 814     {
 815         case 2:        /* total size */
 816             if (_ILIsDrive (pidl))
 817             {
 818                 _ILSimpleGetText (pidl, szPath, MAX_PATH);
 819                 GetDiskFreeSpaceExA (szPath, NULL, &ulBytes, NULL);
 820                 StrFormatByteSizeA (ulBytes.u.LowPart, psd->str.u.cStr, MAX_PATH);
 821             }
 822             break;
 823         case 3:        /* free size */
 824             if (_ILIsDrive (pidl))
 825             {
 826                 _ILSimpleGetText (pidl, szPath, MAX_PATH);
 827                 GetDiskFreeSpaceExA (szPath, &ulBytes, NULL, NULL);
 828                 StrFormatByteSizeA (ulBytes.u.LowPart, psd->str.u.cStr, MAX_PATH);
 829             }
 830             break;
 831
 832         default:
 833             return shellfolder_get_file_details( iface, pidl, mycomputer_header, iColumn, psd );
 834     }
 835
 836     return hr;
 837 }
 838
 839 static HRESULT WINAPI ISF_MyComputer_fnMapColumnToSCID (IShellFolder2 *iface, UINT column, SHCOLUMNID *scid)
 840 {
 841     IMyComputerFolderImpl *This = impl_from_IShellFolder2(iface);
 842
 843     TRACE("(%p)->(%u %p)\n", This, column, scid);
 844
 845     if (column >= ARRAY_SIZE(mycomputer_header))
 846         return E_INVALIDARG;
 847
 848     return shellfolder_map_column_to_scid(mycomputer_header, column, scid);
 849 }
 850
 851 static const IShellFolder2Vtbl vt_ShellFolder2 =
 852 {
 853     ISF_MyComputer_fnQueryInterface,
 854     ISF_MyComputer_fnAddRef,
 855     ISF_MyComputer_fnRelease,
 856     ISF_MyComputer_fnParseDisplayName,
 857     ISF_MyComputer_fnEnumObjects,
 858     ISF_MyComputer_fnBindToObject,
 859     ISF_MyComputer_fnBindToStorage,
 860     ISF_MyComputer_fnCompareIDs,
 861     ISF_MyComputer_fnCreateViewObject,
 862     ISF_MyComputer_fnGetAttributesOf,
 863     ISF_MyComputer_fnGetUIObjectOf,
 864     ISF_MyComputer_fnGetDisplayNameOf,
 865     ISF_MyComputer_fnSetNameOf,
 866     /* ShellFolder2 */
 867     ISF_MyComputer_fnGetDefaultSearchGUID,
 868     ISF_MyComputer_fnEnumSearches,
 869     ISF_MyComputer_fnGetDefaultColumn,
 870     ISF_MyComputer_fnGetDefaultColumnState,
 871     ISF_MyComputer_fnGetDetailsEx,
 872     ISF_MyComputer_fnGetDetailsOf,
 873     ISF_MyComputer_fnMapColumnToSCID
 874 };
 875
 876 /************************************************************************
 877  *    IMCFldr_PersistFolder2_QueryInterface
 878  */
 879 static HRESULT WINAPI IMCFldr_PersistFolder2_QueryInterface (
 880                IPersistFolder2 * iface, REFIID iid, LPVOID * ppvObj)
 881 {
 882     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 883     TRACE ("(%p)\n", This);
 884     return IShellFolder2_QueryInterface (&This->IShellFolder2_iface, iid, ppvObj);
 885 }
 886
 887 /************************************************************************
 888  *    IMCFldr_PersistFolder2_AddRef
 889  */
 890 static ULONG WINAPI IMCFldr_PersistFolder2_AddRef (IPersistFolder2 * iface)
 891 {
 892     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 893     TRACE ("(%p)->(count=%lu)\n", This, This->ref);
 894     return IShellFolder2_AddRef (&This->IShellFolder2_iface);
 895 }
 896
 897 /************************************************************************
 898  *    ISFPersistFolder_Release
 899  */
 900 static ULONG WINAPI IMCFldr_PersistFolder2_Release (IPersistFolder2 * iface)
 901 {
 902     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 903     TRACE ("(%p)->(count=%lu)\n", This, This->ref);
 904     return IShellFolder2_Release (&This->IShellFolder2_iface);
 905 }
 906
 907 /************************************************************************
 908  *    IMCFldr_PersistFolder2_GetClassID
 909  */
 910 static HRESULT WINAPI IMCFldr_PersistFolder2_GetClassID (
 911                IPersistFolder2 * iface, CLSID * lpClassId)
 912 {
 913     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 914
 915     TRACE ("(%p)\n", This);
 916
 917     if (!lpClassId)
 918     return E_POINTER;
 919     *lpClassId = CLSID_MyComputer;
 920
 921     return S_OK;
 922 }
 923
 924 /************************************************************************
 925  *    IMCFldr_PersistFolder2_Initialize
 926  *
 927  * NOTES: it makes no sense to change the pidl
 928  */
 929 static HRESULT WINAPI IMCFldr_PersistFolder2_Initialize (
 930                IPersistFolder2 * iface, LPCITEMIDLIST pidl)
 931 {
 932     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 933     TRACE ("(%p)->(%p)\n", This, pidl);
 934     return E_NOTIMPL;
 935 }
 936
 937 /**************************************************************************
 938  *    IPersistFolder2_fnGetCurFolder
 939  */
 940 static HRESULT WINAPI IMCFldr_PersistFolder2_GetCurFolder (
 941                IPersistFolder2 * iface, LPITEMIDLIST * pidl)
 942 {
 943     IMyComputerFolderImpl *This = impl_from_IPersistFolder2(iface);
 944
 945     TRACE ("(%p)->(%p)\n", This, pidl);
 946
 947     if (!pidl)
 948         return E_POINTER;
 949     *pidl = ILClone (This->pidlRoot);
 950     return S_OK;
 951 }
 952
 953 static const IPersistFolder2Vtbl vt_PersistFolder2 =
 954 {
 955     IMCFldr_PersistFolder2_QueryInterface,
 956     IMCFldr_PersistFolder2_AddRef,
 957     IMCFldr_PersistFolder2_Release,
 958     IMCFldr_PersistFolder2_GetClassID,
 959     IMCFldr_PersistFolder2_Initialize,
 960     IMCFldr_PersistFolder2_GetCurFolder
 961 };