dll/win32/shell32/folders/recyclebin.cpp

   1 /*
   2  * Trash virtual folder support. The trashing engine is implemented in trash.c
   3  *
   4  * Copyright (C) 2006 Mikolaj Zalewski
   5  * Copyright (C) 2009 Andrew Hill
   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 <precomp.h>
  23
  24 #include <ntquery.h>
  25
  26 #define MAX_PROPERTY_SHEET_PAGE 32
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(CRecycleBin);
  29
  30 typedef struct
  31 {
  32     int column_name_id;
  33     const GUID *fmtId;
  34     DWORD pid;
  35     int pcsFlags;
  36     int fmt;
  37     int cxChars;
  38 } columninfo;
  39
  40 static const columninfo RecycleBinColumns[] =
  41 {
  42     {IDS_SHV_COLUMN1,        &FMTID_Storage,   PID_STG_NAME,       SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  30},
  43     {IDS_SHV_COLUMN_DELFROM, &FMTID_Displaced, PID_DISPLACED_FROM, SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  30},
  44     {IDS_SHV_COLUMN_DELDATE, &FMTID_Displaced, PID_DISPLACED_DATE, SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  20},
  45     {IDS_SHV_COLUMN2,        &FMTID_Storage,   PID_STG_SIZE,       SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 20},
  46     {IDS_SHV_COLUMN3,        &FMTID_Storage,   PID_STG_STORAGETYPE, SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  20},
  47     {IDS_SHV_COLUMN4,        &FMTID_Storage,   PID_STG_WRITETIME,  SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  20},
  48     /*    {"creation time",  &FMTID_Storage,   PID_STG_CREATETIME, SHCOLSTATE_TYPE_DATE,                        LVCFMT_LEFT,  20}, */
  49     /*    {"attribs",        &FMTID_Storage,   PID_STG_ATTRIBUTES, SHCOLSTATE_TYPE_STR,                         LVCFMT_LEFT,  20},       */
  50 };
  51
  52 #define COLUMN_NAME    0
  53 #define COLUMN_DELFROM 1
  54 #define COLUMN_DATEDEL 2
  55 #define COLUMN_SIZE    3
  56 #define COLUMN_TYPE    4
  57 #define COLUMN_MTIME   5
  58
  59 #define COLUMNS_COUNT  6
  60
  61 /*
  62  * Recycle Bin folder
  63  */
  64
  65 class CRecycleBinEnum :
  66     public CEnumIDListBase
  67 {
  68     private:
  69     public:
  70         CRecycleBinEnum();
  71         ~CRecycleBinEnum();
  72         HRESULT WINAPI Initialize(DWORD dwFlags);
  73         static BOOL WINAPI CBEnumRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile);
  74         BOOL WINAPI CBEnumRecycleBin(IN HANDLE hDeletedFile);
  75
  76         BEGIN_COM_MAP(CRecycleBinEnum)
  77         COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
  78         END_COM_MAP()
  79 };
  80
  81 class CRecycleBinItemContextMenu :
  82     public CComObjectRootEx<CComMultiThreadModelNoCS>,
  83     public IContextMenu2
  84 {
  85     private:
  86         LPITEMIDLIST                        apidl;
  87     public:
  88         CRecycleBinItemContextMenu();
  89         ~CRecycleBinItemContextMenu();
  90         HRESULT WINAPI Initialize(LPCITEMIDLIST pidl);
  91
  92         // IContextMenu
  93         virtual HRESULT WINAPI QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
  94         virtual HRESULT WINAPI InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi);
  95         virtual HRESULT WINAPI GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen);
  96
  97         // IContextMenu2
  98         virtual HRESULT WINAPI HandleMenuMsg(UINT uMsg, WPARAM wParam, LPARAM lParam);
  99
 100         BEGIN_COM_MAP(CRecycleBinItemContextMenu)
 101         COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
 102         COM_INTERFACE_ENTRY_IID(IID_IContextMenu2, IContextMenu2)
 103         END_COM_MAP()
 104 };
 105
 106 typedef struct
 107 {
 108     PIDLRecycleStruct *pFileDetails;
 109     HANDLE hDeletedFile;
 110     BOOL bFound;
 111 } SEARCH_CONTEXT, *PSEARCH_CONTEXT;
 112
 113 typedef struct
 114 {
 115     DWORD dwNukeOnDelete;
 116     DWORD dwSerial;
 117     DWORD dwMaxCapacity;
 118 } DRIVE_ITEM_CONTEXT, *PDRIVE_ITEM_CONTEXT;
 119
 120 BOOL WINAPI CBSearchRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile)
 121 {
 122     PSEARCH_CONTEXT pContext = (PSEARCH_CONTEXT)Context;
 123
 124     PDELETED_FILE_DETAILS_W pFileDetails;
 125     DWORD dwSize;
 126     BOOL ret;
 127
 128     if (!GetDeletedFileDetailsW(hDeletedFile,
 129                                 0,
 130                                 NULL,
 131                                 &dwSize) &&
 132             GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 133     {
 134         ERR("GetDeletedFileDetailsW failed\n");
 135         return FALSE;
 136     }
 137
 138     pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
 139     if (!pFileDetails)
 140     {
 141         ERR("No memory\n");
 142         return FALSE;
 143     }
 144
 145     if (!GetDeletedFileDetailsW(hDeletedFile,
 146                                 dwSize,
 147                                 pFileDetails,
 148                                 NULL))
 149     {
 150         ERR("GetDeletedFileDetailsW failed\n");
 151         SHFree(pFileDetails);
 152         return FALSE;
 153     }
 154
 155     ret = memcmp(pFileDetails, pContext->pFileDetails, dwSize);
 156     if (!ret)
 157     {
 158         pContext->hDeletedFile = hDeletedFile;
 159         pContext->bFound = TRUE;
 160     }
 161     else
 162         CloseRecycleBinHandle(hDeletedFile);
 163
 164     SHFree(pFileDetails);
 165     return ret;
 166 }
 167
 168 static PIDLRecycleStruct * _ILGetRecycleStruct(LPCITEMIDLIST pidl)
 169 {
 170     LPPIDLDATA pdata = _ILGetDataPointer(pidl);
 171
 172     if (pdata && pdata->type == 0x00)
 173         return (PIDLRecycleStruct*) & (pdata->u.crecycle);
 174
 175     return NULL;
 176 }
 177
 178 CRecycleBinEnum::CRecycleBinEnum()
 179 {
 180 }
 181
 182 CRecycleBinEnum::~CRecycleBinEnum()
 183 {
 184 }
 185
 186 HRESULT WINAPI CRecycleBinEnum::Initialize(DWORD dwFlags)
 187 {
 188     static LPCWSTR szDrive = L"C:\\";
 189
 190     if (dwFlags & SHCONTF_NONFOLDERS)
 191     {
 192         TRACE("Starting Enumeration\n");
 193
 194         if (!EnumerateRecycleBinW(szDrive /* FIXME */ , CBEnumRecycleBin, (PVOID)this))
 195         {
 196             WARN("Error: EnumerateCRecycleBinW failed\n");
 197             return E_FAIL;
 198         }
 199     }
 200     else
 201     {
 202         // do nothing
 203     }
 204     return S_OK;
 205 }
 206
 207 static LPITEMIDLIST _ILCreateRecycleItem(PDELETED_FILE_DETAILS_W pFileDetails)
 208 {
 209     PIDLDATA tmp;
 210     LPITEMIDLIST pidl;
 211     PIDLRecycleStruct * p;
 212     int size0 = (char*)&tmp.u.crecycle.szName - (char*)&tmp.u.crecycle;
 213     int size = size0;
 214
 215     tmp.type = 0x00;
 216     size += (wcslen(pFileDetails->FileName) + 1) * sizeof(WCHAR);
 217
 218     pidl = (LPITEMIDLIST)SHAlloc(size + 4);
 219     if (!pidl)
 220         return pidl;
 221
 222     pidl->mkid.cb = size + 2;
 223     memcpy(pidl->mkid.abID, &tmp, 2 + size0);
 224
 225     p = &((PIDLDATA*)pidl->mkid.abID)->u.crecycle;
 226     RtlCopyMemory(p, pFileDetails, sizeof(DELETED_FILE_DETAILS_W));
 227     wcscpy(p->szName, pFileDetails->FileName);
 228     *(WORD*)((char*)pidl + (size + 2)) = 0;
 229     return pidl;
 230 }
 231
 232 BOOL WINAPI CRecycleBinEnum::CBEnumRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile)
 233 {
 234     return static_cast<CRecycleBinEnum *>(Context)->CBEnumRecycleBin(hDeletedFile);
 235 }
 236
 237 BOOL WINAPI CRecycleBinEnum::CBEnumRecycleBin(IN HANDLE hDeletedFile)
 238 {
 239     PDELETED_FILE_DETAILS_W pFileDetails;
 240     DWORD dwSize;
 241     LPITEMIDLIST pidl = NULL;
 242     BOOL ret;
 243
 244     if (!GetDeletedFileDetailsW(hDeletedFile,
 245                                 0,
 246                                 NULL,
 247                                 &dwSize) &&
 248             GetLastError() != ERROR_INSUFFICIENT_BUFFER)
 249     {
 250         ERR("GetDeletedFileDetailsW failed\n");
 251         return FALSE;
 252     }
 253
 254     pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
 255     if (!pFileDetails)
 256     {
 257         ERR("No memory\n");
 258         return FALSE;
 259     }
 260
 261     if (!GetDeletedFileDetailsW(hDeletedFile,
 262                                 dwSize,
 263                                 pFileDetails,
 264                                 NULL))
 265     {
 266         ERR("GetDeletedFileDetailsW failed\n");
 267         SHFree(pFileDetails);
 268         return FALSE;
 269     }
 270
 271     pidl = _ILCreateRecycleItem(pFileDetails);
 272     if (!pidl)
 273     {
 274         SHFree(pFileDetails);
 275         return FALSE;
 276     }
 277
 278     ret = AddToEnumList(pidl);
 279
 280     if (!ret)
 281         SHFree(pidl);
 282     SHFree(pFileDetails);
 283     TRACE("Returning %d\n", ret);
 284     CloseRecycleBinHandle(hDeletedFile);
 285     return ret;
 286 }
 287
 288 /**************************************************************************
 289 * IContextMenu2 Bitbucket Item Implementation
 290 */
 291
 292 CRecycleBinItemContextMenu::CRecycleBinItemContextMenu()
 293 {
 294     apidl = NULL;
 295 }
 296
 297 CRecycleBinItemContextMenu::~CRecycleBinItemContextMenu()
 298 {
 299     ILFree(apidl);
 300 }
 301
 302 HRESULT WINAPI CRecycleBinItemContextMenu::Initialize(LPCITEMIDLIST pidl)
 303 {
 304     apidl = ILClone(pidl);
 305     if (apidl == NULL)
 306         return E_OUTOFMEMORY;
 307     return S_OK;
 308 }
 309
 310 HRESULT WINAPI CRecycleBinItemContextMenu::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
 311 {
 312     WCHAR szBuffer[30] = {0};
 313     ULONG Count = 1;
 314
 315     TRACE("(%p)->(hmenu=%p indexmenu=%x cmdfirst=%x cmdlast=%x flags=%x )\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
 316
 317     if (LoadStringW(shell32_hInstance, IDS_RESTORE, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
 318     {
 319         szBuffer[(sizeof(szBuffer)/sizeof(WCHAR))-1] = L'\0';
 320         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_ENABLED);
 321         Count++;
 322     }
 323
 324     if (LoadStringW(shell32_hInstance, IDS_CUT, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
 325     {
 326         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
 327         szBuffer[(sizeof(szBuffer)/sizeof(WCHAR))-1] = L'\0';
 328         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
 329     }
 330
 331     if (LoadStringW(shell32_hInstance, IDS_DELETE, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
 332     {
 333         szBuffer[(sizeof(szBuffer)/sizeof(WCHAR))-1] = L'\0';
 334         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
 335         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
 336     }
 337
 338     if (LoadStringW(shell32_hInstance, IDS_PROPERTIES, szBuffer, sizeof(szBuffer) / sizeof(WCHAR)))
 339     {
 340         szBuffer[(sizeof(szBuffer)/sizeof(WCHAR))-1] = L'\0';
 341         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
 342         _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_DEFAULT);
 343     }
 344
 345     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, Count);
 346 }
 347
 348 HRESULT WINAPI CRecycleBinItemContextMenu::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
 349 {
 350     SEARCH_CONTEXT Context;
 351     static LPCWSTR szDrive = L"C:\\";
 352
 353     TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd);
 354
 355     if (lpcmi->lpVerb == MAKEINTRESOURCEA(1) || lpcmi->lpVerb == MAKEINTRESOURCEA(5))
 356     {
 357         Context.pFileDetails = _ILGetRecycleStruct(apidl);
 358         Context.bFound = FALSE;
 359
 360         EnumerateRecycleBinW(szDrive, CBSearchRecycleBin, (PVOID)&Context);
 361         if (!Context.bFound)
 362             return E_FAIL;
 363
 364         if (lpcmi->lpVerb == MAKEINTRESOURCEA(1))
 365         {
 366             /* restore file */
 367             if (RestoreFile(Context.hDeletedFile))
 368                 return S_OK;
 369             else
 370                 return E_FAIL;
 371         }
 372         else
 373         {
 374             DeleteFileHandleToRecycleBin(Context.hDeletedFile);
 375             return E_NOTIMPL;
 376         }
 377     }
 378     else if (lpcmi->lpVerb == MAKEINTRESOURCEA(3))
 379     {
 380         FIXME("implement cut\n");
 381         return E_NOTIMPL;
 382     }
 383     else if (lpcmi->lpVerb == MAKEINTRESOURCEA(7))
 384     {
 385         FIXME("implement properties\n");
 386         return E_NOTIMPL;
 387     }
 388
 389     return S_OK;
 390 }
 391
 392 HRESULT WINAPI CRecycleBinItemContextMenu::GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
 393 {
 394     TRACE("(%p)->(idcom=%lx flags=%x %p name=%p len=%x)\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
 395
 396     return E_FAIL;
 397 }
 398
 399 HRESULT WINAPI CRecycleBinItemContextMenu::HandleMenuMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
 400 {
 401     TRACE("CRecycleBin_IContextMenu2Item_HandleMenuMsg (%p)->(msg=%x wp=%lx lp=%lx)\n", this, uMsg, wParam, lParam);
 402
 403     return E_NOTIMPL;
 404 }
 405
 406 /**************************************************************************
 407 * registers clipboardformat once
 408 */
 409 void CRecycleBin::SF_RegisterClipFmt()
 410 {
 411     TRACE ("(%p)\n", this);
 412
 413     if (!cfShellIDList)
 414         cfShellIDList = RegisterClipboardFormatW(CFSTR_SHELLIDLIST);
 415 }
 416
 417 CRecycleBin::CRecycleBin()
 418 {
 419     pidl = NULL;
 420     iIdEmpty = 0;
 421     cfShellIDList = 0;
 422     SF_RegisterClipFmt();
 423     fAcceptFmt = FALSE;
 424 }
 425
 426 CRecycleBin::~CRecycleBin()
 427 {
 428     /*    InterlockedDecrement(&objCount);*/
 429     SHFree(pidl);
 430 }
 431
 432 /*************************************************************************
 433  * RecycleBin IPersistFolder2 interface
 434  */
 435
 436 HRESULT WINAPI CRecycleBin::GetClassID(CLSID *pClassID)
 437 {
 438     TRACE("(%p, %p)\n", this, pClassID);
 439     if (pClassID == NULL)
 440         return E_INVALIDARG;
 441     memcpy(pClassID, &CLSID_RecycleBin, sizeof(CLSID));
 442     return S_OK;
 443 }
 444
 445 HRESULT WINAPI CRecycleBin::Initialize(LPCITEMIDLIST pidl)
 446 {
 447     TRACE("(%p, %p)\n", this, pidl);
 448
 449     SHFree((LPVOID)this->pidl);
 450     this->pidl = ILClone(pidl);
 451     if (this->pidl == NULL)
 452         return E_OUTOFMEMORY;
 453     return S_OK;
 454 }
 455
 456 HRESULT WINAPI CRecycleBin::GetCurFolder(LPITEMIDLIST *ppidl)
 457 {
 458     TRACE("\n");
 459     *ppidl = ILClone(pidl);
 460     return S_OK;
 461 }
 462
 463 /*************************************************************************
 464  * RecycleBin IShellFolder2 interface
 465  */
 466
 467 HRESULT WINAPI CRecycleBin::ParseDisplayName(HWND hwnd, LPBC pbc,
 468         LPOLESTR pszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl,
 469         ULONG *pdwAttributes)
 470 {
 471     FIXME("stub\n");
 472     return E_NOTIMPL;
 473 }
 474
 475
 476 PDELETED_FILE_DETAILS_W
 477 UnpackDetailsFromPidl(LPCITEMIDLIST pidl)
 478 {
 479     return (PDELETED_FILE_DETAILS_W)&pidl->mkid.abID;
 480 }
 481
 482 HRESULT WINAPI CRecycleBin::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 483 {
 484     return ShellObjectCreatorInit<CRecycleBinEnum>(dwFlags, IID_IEnumIDList, ppEnumIDList);
 485 }
 486
 487 HRESULT WINAPI CRecycleBin::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbc, REFIID riid, void **ppv)
 488 {
 489     FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
 490     return E_NOTIMPL;
 491 }
 492
 493 HRESULT WINAPI CRecycleBin::BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbc, REFIID riid, void **ppv)
 494 {
 495     FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
 496     return E_NOTIMPL;
 497 }
 498
 499 HRESULT WINAPI CRecycleBin::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 500 {
 501     /* TODO */
 502     TRACE("(%p, %p, %p, %p)\n", this, (void *)lParam, pidl1, pidl2);
 503     if (pidl1->mkid.cb != pidl2->mkid.cb)
 504         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, pidl1->mkid.cb - pidl2->mkid.cb);
 505     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (unsigned short)memcmp(pidl1->mkid.abID, pidl2->mkid.abID, pidl1->mkid.cb));
 506 }
 507
 508 HRESULT WINAPI CRecycleBin::CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv)
 509 {
 510     CComPtr<IShellView> pShellView;
 511     HRESULT hr = E_NOINTERFACE;
 512
 513     TRACE("(%p, %p, %s, %p)\n", this, hwndOwner, debugstr_guid(&riid), ppv);
 514
 515     if (!ppv)
 516         return hr;
 517
 518     *ppv = NULL;
 519
 520     if (IsEqualIID (riid, IID_IDropTarget))
 521     {
 522         hr = this->QueryInterface (IID_IDropTarget, ppv);
 523     }
 524     else if (IsEqualIID (riid, IID_IContextMenu) || IsEqualIID (riid, IID_IContextMenu2))
 525     {
 526         hr = this->QueryInterface(riid, ppv);
 527     }
 528     else if (IsEqualIID (riid, IID_IShellView))
 529     {
 530         hr = IShellView_Constructor ((IShellFolder *)this, &pShellView);
 531         if (pShellView)
 532         {
 533             hr = pShellView->QueryInterface(riid, ppv);
 534         }
 535     }
 536     else
 537         return hr;
 538     TRACE ("-- (%p)->(interface=%p)\n", this, ppv);
 539     return hr;
 540
 541 }
 542
 543 HRESULT WINAPI CRecycleBin::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 544         SFGAOF *rgfInOut)
 545 {
 546     TRACE("(%p, %d, {%p, ...}, {%x})\n", this, cidl, apidl ? apidl[0] : NULL, (unsigned int)*rgfInOut);
 547     *rgfInOut &= SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK;
 548     return S_OK;
 549 }
 550
 551 HRESULT WINAPI CRecycleBin::GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 552         REFIID riid, UINT *prgfInOut, void **ppv)
 553 {
 554     IUnknown *pObj = NULL;
 555     HRESULT hr = E_INVALIDARG;
 556
 557     TRACE ("(%p)->(%p,%u,apidl=%p, %p %p)\n", this,
 558            hwndOwner, cidl, apidl, prgfInOut, ppv);
 559
 560     if (!ppv)
 561         return hr;
 562
 563     *ppv = NULL;
 564
 565     if ((IsEqualIID (riid, IID_IContextMenu) || IsEqualIID(riid, IID_IContextMenu2)) && (cidl >= 1))
 566     {
 567         hr = ShellObjectCreatorInit<CRecycleBinItemContextMenu>(apidl[0], riid, &pObj);
 568     }
 569     else if (IsEqualIID (riid, IID_IDropTarget) && (cidl == 1))
 570     {
 571         IDropTarget * pDt = NULL;
 572         hr = QueryInterface(IID_PPV_ARG(IDropTarget, &pDt));
 573         pObj = pDt;
 574     }
 575     else
 576         hr = E_NOINTERFACE;
 577
 578     if (SUCCEEDED(hr) && !pObj)
 579         hr = E_OUTOFMEMORY;
 580
 581     *ppv = pObj;
 582     TRACE ("(%p)->hr=0x%08x\n", this, hr);
 583     return hr;
 584 }
 585
 586 HRESULT WINAPI CRecycleBin::GetDisplayNameOf(PCUITEMID_CHILD pidl, SHGDNF uFlags, STRRET *pName)
 587 {
 588     PIDLRecycleStruct *pFileDetails;
 589     LPWSTR pFileName;
 590
 591     TRACE("(%p, %p, %x, %p)\n", this, pidl, (unsigned int)uFlags, pName);
 592
 593
 594     if (_ILIsBitBucket (pidl))
 595     {
 596         WCHAR pszPath[100];
 597
 598         if (HCR_GetClassNameW(CLSID_RecycleBin, pszPath, MAX_PATH))
 599         {
 600             pName->uType = STRRET_WSTR;
 601             pName->pOleStr = StrDupW(pszPath);
 602             return S_OK;
 603         }
 604     }
 605
 606     pFileDetails = _ILGetRecycleStruct(pidl);
 607     if (!pFileDetails)
 608     {
 609         pName->cStr[0] = 0;
 610         pName->uType = STRRET_CSTR;
 611         return E_INVALIDARG;
 612     }
 613
 614     pFileName = wcsrchr(pFileDetails->szName, L'\\');
 615     if (!pFileName)
 616     {
 617         pName->cStr[0] = 0;
 618         pName->uType = STRRET_CSTR;
 619         return E_UNEXPECTED;
 620     }
 621
 622     pName->pOleStr = StrDupW(pFileName + 1);
 623     if (pName->pOleStr == NULL)
 624         return E_OUTOFMEMORY;
 625
 626     pName->uType = STRRET_WSTR;
 627     return S_OK;
 628 }
 629
 630 HRESULT WINAPI CRecycleBin::SetNameOf(HWND hwnd, PCUITEMID_CHILD pidl, LPCOLESTR pszName,
 631                                       SHGDNF uFlags, PITEMID_CHILD *ppidlOut)
 632 {
 633     TRACE("\n");
 634     return E_FAIL; /* not supported */
 635 }
 636
 637 HRESULT WINAPI CRecycleBin::GetDefaultSearchGUID(GUID *pguid)
 638 {
 639     FIXME("stub\n");
 640     return E_NOTIMPL;
 641 }
 642
 643 HRESULT WINAPI CRecycleBin::EnumSearches(IEnumExtraSearch **ppEnum)
 644 {
 645     FIXME("stub\n");
 646     *ppEnum = NULL;
 647     return E_NOTIMPL;
 648 }
 649
 650 HRESULT WINAPI CRecycleBin::GetDefaultColumn(DWORD dwReserved, ULONG *pSort, ULONG *pDisplay)
 651 {
 652     TRACE("(%p, %x, %p, %p)\n", this, (unsigned int)dwReserved, pSort, pDisplay);
 653     *pSort = 0;
 654     *pDisplay = 0;
 655     return S_OK;
 656 }
 657
 658 HRESULT WINAPI CRecycleBin::GetDefaultColumnState(UINT iColumn, SHCOLSTATEF *pcsFlags)
 659 {
 660     TRACE("(%p, %d, %p)\n", this, iColumn, pcsFlags);
 661     if (iColumn >= COLUMNS_COUNT)
 662         return E_INVALIDARG;
 663     *pcsFlags = RecycleBinColumns[iColumn].pcsFlags;
 664     return S_OK;
 665 }
 666
 667 HRESULT WINAPI CRecycleBin::GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 668 {
 669     FIXME("stub\n");
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT FormatDateTime(LPWSTR buffer, int size, FILETIME * ft)
 674 {
 675     FILETIME lft;
 676     SYSTEMTIME time;
 677     int ret;
 678
 679     FileTimeToLocalFileTime(ft, &lft);
 680     FileTimeToSystemTime(&lft, &time);
 681
 682     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time, NULL, buffer, size);
 683     if (ret > 0 && ret < size)
 684     {
 685         /* Append space + time without seconds */
 686         buffer[ret-1] = ' ';
 687         GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &buffer[ret], size - ret);
 688     }
 689
 690     return (ret != 0 ? E_FAIL : S_OK);
 691 }
 692
 693 HRESULT WINAPI CRecycleBin::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, LPSHELLDETAILS pDetails)
 694 {
 695     PIDLRecycleStruct * pFileDetails;
 696     WCHAR buffer[MAX_PATH];
 697     WCHAR szTypeName[100];
 698     LPWSTR pszBackslash;
 699     UINT Length;
 700
 701     TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, pDetails);
 702     if (iColumn >= COLUMNS_COUNT)
 703         return E_FAIL;
 704     pDetails->fmt = RecycleBinColumns[iColumn].fmt;
 705     pDetails->cxChar = RecycleBinColumns[iColumn].cxChars;
 706     if (pidl == NULL)
 707     {
 708         pDetails->str.uType = STRRET_WSTR;
 709         LoadStringW(shell32_hInstance, RecycleBinColumns[iColumn].column_name_id, buffer, MAX_PATH);
 710         return SHStrDupW(buffer, &pDetails->str.pOleStr);
 711     }
 712
 713     if (iColumn == COLUMN_NAME)
 714         return GetDisplayNameOf(pidl, SHGDN_NORMAL, &pDetails->str);
 715
 716     pFileDetails = _ILGetRecycleStruct(pidl);
 717     switch (iColumn)
 718     {
 719         case COLUMN_DATEDEL:
 720             FormatDateTime(buffer, MAX_PATH, &pFileDetails->DeletionTime);
 721             break;
 722         case COLUMN_DELFROM:
 723             pszBackslash = wcsrchr(pFileDetails->szName, L'\\');
 724             Length = (pszBackslash - pFileDetails->szName);
 725             memcpy((LPVOID)buffer, pFileDetails->szName, Length * sizeof(WCHAR));
 726             buffer[Length] = L'\0';
 727             break;
 728         case COLUMN_SIZE:
 729             StrFormatKBSizeW(pFileDetails->FileSize.QuadPart, buffer, MAX_PATH);
 730             break;
 731         case COLUMN_MTIME:
 732             FormatDateTime(buffer, MAX_PATH, &pFileDetails->LastModification);
 733             break;
 734         case COLUMN_TYPE:
 735             szTypeName[0] = L'\0';
 736             wcscpy(buffer, PathFindExtensionW(pFileDetails->szName));
 737             if (!( HCR_MapTypeToValueW(buffer, buffer, sizeof(buffer) / sizeof(WCHAR), TRUE) &&
 738                     HCR_MapTypeToValueW(buffer, szTypeName, sizeof(szTypeName) / sizeof(WCHAR), FALSE )))
 739             {
 740                 wcscpy (szTypeName, PathFindExtensionW(pFileDetails->szName));
 741                 wcscat(szTypeName, L"-");
 742                 Length = wcslen(szTypeName);
 743                 if (LoadStringW(shell32_hInstance, IDS_SHV_COLUMN1, &szTypeName[Length], (sizeof(szTypeName) / sizeof(WCHAR)) - Length))
 744                     szTypeName[(sizeof(szTypeName)/sizeof(WCHAR))-1] = L'\0';
 745             }
 746             pDetails->str.uType = STRRET_WSTR;
 747             return SHStrDupW(szTypeName, &pDetails->str.pOleStr);
 748             break;
 749         default:
 750             return E_FAIL;
 751     }
 752
 753     pDetails->str.uType = STRRET_WSTR;
 754     return SHStrDupW(buffer, &pDetails->str.pOleStr);
 755 }
 756
 757 HRESULT WINAPI CRecycleBin::MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid)
 758 {
 759     TRACE("(%p, %d, %p)\n", this, iColumn, pscid);
 760     if (iColumn >= COLUMNS_COUNT)
 761         return E_INVALIDARG;
 762     pscid->fmtid = *RecycleBinColumns[iColumn].fmtId;
 763     pscid->pid = RecycleBinColumns[iColumn].pid;
 764     return S_OK;
 765 }
 766
 767 /*************************************************************************
 768  * RecycleBin IContextMenu interface
 769  */
 770
 771 HRESULT WINAPI CRecycleBin::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
 772 {
 773     WCHAR szBuffer[100];
 774     MENUITEMINFOW mii;
 775     int id = 1;
 776
 777     TRACE("QueryContextMenu %p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
 778
 779     if (!hMenu)
 780         return E_INVALIDARG;
 781
 782     memset(&mii, 0, sizeof(mii));
 783     mii.cbSize = sizeof(mii);
 784     mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
 785     mii.fState = MFS_ENABLED;
 786     szBuffer[0] = L'\0';
 787     LoadStringW(shell32_hInstance, IDS_EMPTY_BITBUCKET, szBuffer, sizeof(szBuffer) / sizeof(WCHAR));
 788     mii.dwTypeData = szBuffer;
 789     mii.cch = wcslen(mii.dwTypeData);
 790     mii.wID = idCmdFirst + id++;
 791     mii.fType = MFT_STRING;
 792     iIdEmpty = 1;
 793
 794     if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
 795         return E_FAIL;
 796
 797     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
 798 }
 799
 800 HRESULT WINAPI CRecycleBin::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
 801 {
 802     HRESULT hr;
 803     LPSHELLBROWSER lpSB;
 804     IShellView * lpSV = NULL;
 805
 806     TRACE("%p %p verb %p\n", this, lpcmi, lpcmi->lpVerb);
 807
 808     if (LOWORD(lpcmi->lpVerb) == iIdEmpty)
 809     {
 810         // FIXME
 811         // path & flags
 812         hr = SHEmptyRecycleBinW(lpcmi->hwnd, L"C:\\", 0);
 813         TRACE("result %x\n", hr);
 814         if (hr != S_OK)
 815             return hr;
 816
 817         lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0);
 818         if (lpSB && SUCCEEDED(lpSB->QueryActiveShellView(&lpSV)))
 819             lpSV->Refresh();
 820     }
 821     return S_OK;
 822 }
 823
 824 HRESULT WINAPI CRecycleBin::GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
 825 {
 826     FIXME("%p %lu %u %p %p %u\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
 827
 828     return E_NOTIMPL;
 829 }
 830
 831 /*************************************************************************
 832  * RecycleBin IShellPropSheetExt interface
 833  */
 834
 835 HRESULT WINAPI CRecycleBin::AddPages(LPFNSVADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
 836 {
 837     FIXME("%p %p %lu\n", this, pfnAddPage, lParam);
 838
 839     return E_NOTIMPL;
 840 }
 841
 842 HRESULT WINAPI CRecycleBin::ReplacePage(EXPPS uPageID, LPFNSVADDPROPSHEETPAGE pfnReplaceWith, LPARAM lParam)
 843 {
 844     FIXME("%p %lu %p %lu\n", this, uPageID, pfnReplaceWith, lParam);
 845
 846     return E_NOTIMPL;
 847 }
 848
 849 /*************************************************************************
 850  * RecycleBin IShellExtInit interface
 851  */
 852
 853 HRESULT WINAPI CRecycleBin::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
 854 {
 855     TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID );
 856     return S_OK;
 857 }
 858
 859 void toggleNukeOnDeleteOption(HWND hwndDlg, BOOL bEnable)
 860 {
 861     if (bEnable)
 862     {
 863         SendDlgItemMessage(hwndDlg, 14001, BM_SETCHECK, BST_UNCHECKED, 0);
 864         EnableWindow(GetDlgItem(hwndDlg, 14002), FALSE);
 865         SendDlgItemMessage(hwndDlg, 14003, BM_SETCHECK, BST_CHECKED, 0);
 866     }
 867     else
 868     {
 869         SendDlgItemMessage(hwndDlg, 14001, BM_SETCHECK, BST_CHECKED, 0);
 870         EnableWindow(GetDlgItem(hwndDlg, 14002), TRUE);
 871         SendDlgItemMessage(hwndDlg, 14003, BM_SETCHECK, BST_UNCHECKED, 0);
 872     }
 873 }
 874
 875
 876 static VOID
 877 InitializeRecycleBinDlg(HWND hwndDlg, WCHAR DefaultDrive)
 878 {
 879     WCHAR CurDrive = L'A';
 880     WCHAR szDrive[] = L"A:\\";
 881     DWORD dwDrives;
 882     WCHAR szName[100];
 883     WCHAR szVolume[100];
 884     DWORD MaxComponent, Flags;
 885     DWORD dwSerial;
 886     LVCOLUMNW lc;
 887     HWND hDlgCtrl;
 888     LVITEMW li;
 889     INT itemCount;
 890     ULARGE_INTEGER TotalNumberOfFreeBytes, TotalNumberOfBytes, FreeBytesAvailable;
 891     RECT rect;
 892     int columnSize;
 893     int defIndex = 0;
 894     DWORD dwSize;
 895     PDRIVE_ITEM_CONTEXT pItem = NULL, pDefault = NULL, pFirst = NULL;
 896
 897     hDlgCtrl = GetDlgItem(hwndDlg, 14000);
 898
 899     if (!LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_LOCATION, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
 900         szVolume[0] = 0;
 901
 902     GetClientRect(hDlgCtrl, &rect);
 903
 904     memset(&lc, 0, sizeof(LV_COLUMN) );
 905     lc.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM | LVCF_FMT;
 906
 907     columnSize = 140; //FIXME
 908     lc.iSubItem   = 0;
 909     lc.fmt = LVCFMT_FIXED_WIDTH;
 910     lc.cx         = columnSize;
 911     lc.cchTextMax = wcslen(szVolume);
 912     lc.pszText    = szVolume;
 913     (void)SendMessageW(hDlgCtrl, LVM_INSERTCOLUMNW, 0, (LPARAM)&lc);
 914
 915     if (!LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_DISKSPACE, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
 916         szVolume[0] = 0;
 917
 918     lc.iSubItem   = 1;
 919     lc.cx         = rect.right - rect.left - columnSize;
 920     lc.cchTextMax = wcslen(szVolume);
 921     lc.pszText    = szVolume;
 922     (void)SendMessageW(hDlgCtrl, LVM_INSERTCOLUMNW, 1, (LPARAM)&lc);
 923
 924     dwDrives = GetLogicalDrives();
 925     itemCount = 0;
 926     do
 927     {
 928         if ((dwDrives & 0x1))
 929         {
 930             UINT Type = GetDriveTypeW(szDrive);
 931             if (Type == DRIVE_FIXED) //FIXME
 932             {
 933                 if (!GetVolumeInformationW(szDrive, szName, sizeof(szName) / sizeof(WCHAR), &dwSerial, &MaxComponent, &Flags, NULL, 0))
 934                 {
 935                     szName[0] = 0;
 936                     dwSerial = -1;
 937                 }
 938
 939                 swprintf(szVolume, L"%s (%c)", szName, szDrive[0]);
 940                 memset(&li, 0x0, sizeof(LVITEMW));
 941                 li.mask = LVIF_TEXT | LVIF_PARAM;
 942                 li.iSubItem = 0;
 943                 li.pszText = szVolume;
 944                 li.iItem = itemCount;
 945                 SendMessageW(hDlgCtrl, LVM_INSERTITEMW, 0, (LPARAM)&li);
 946                 if (GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable , &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
 947                 {
 948                     if (StrFormatByteSizeW(TotalNumberOfFreeBytes.QuadPart, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
 949                     {
 950
 951                         pItem = (DRIVE_ITEM_CONTEXT *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DRIVE_ITEM_CONTEXT));
 952                         if (pItem)
 953                         {
 954                             swprintf(szName, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume\\%04X-%04X", LOWORD(dwSerial), HIWORD(dwSerial));
 955                             dwSize = sizeof(DWORD);
 956                             RegGetValueW(HKEY_CURRENT_USER, szName, L"MaxCapacity", RRF_RT_DWORD, NULL, &pItem->dwMaxCapacity, &dwSize);
 957                             dwSize = sizeof(DWORD);
 958                             RegGetValueW(HKEY_CURRENT_USER, szName, L"NukeOnDelete", RRF_RT_DWORD, NULL, &pItem->dwNukeOnDelete, &dwSize);
 959                             pItem->dwSerial = dwSerial;
 960                             li.mask = LVIF_PARAM;
 961                             li.lParam = (LPARAM)pItem;
 962                             (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
 963                             if (CurDrive == DefaultDrive)
 964                             {
 965                                 defIndex = itemCount;
 966                                 pDefault = pItem;
 967                             }
 968                         }
 969                         if (!pFirst)
 970                             pFirst = pItem;
 971
 972                         li.mask = LVIF_TEXT;
 973                         li.iSubItem = 1;
 974                         li.pszText = szVolume;
 975                         li.iItem = itemCount;
 976                         (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
 977                     }
 978                 }
 979                 itemCount++;
 980             }
 981         }
 982         CurDrive++;
 983         szDrive[0] = CurDrive;
 984         dwDrives = (dwDrives >> 1);
 985     } while(dwDrives);
 986
 987     if (!pDefault)
 988         pDefault = pFirst;
 989     if (pDefault)
 990     {
 991         toggleNukeOnDeleteOption(hwndDlg, pDefault->dwNukeOnDelete);
 992         SetDlgItemInt(hwndDlg, 14002, pDefault->dwMaxCapacity, FALSE);
 993     }
 994     ZeroMemory(&li, sizeof(li));
 995     li.mask = LVIF_STATE;
 996     li.stateMask = (UINT) - 1;
 997     li.state = LVIS_FOCUSED | LVIS_SELECTED;
 998     li.iItem = defIndex;
 999     (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
1000
1001 }
1002
1003 static BOOL StoreDriveSettings(HWND hwndDlg)
1004 {
1005     int iCount, iIndex;
1006     HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1007     LVITEMW li;
1008     PDRIVE_ITEM_CONTEXT pItem;
1009     HKEY hKey, hSubKey;
1010     WCHAR szSerial[20];
1011     DWORD dwSize;
1012
1013
1014     if (RegCreateKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
1015         return FALSE;
1016
1017     iCount = ListView_GetItemCount(hDlgCtrl);
1018
1019     ZeroMemory(&li, sizeof(li));
1020     li.mask = LVIF_PARAM;
1021
1022     for(iIndex = 0; iIndex < iCount; iIndex++)
1023     {
1024         li.iItem = iIndex;
1025         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)&li))
1026         {
1027             pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1028             swprintf(szSerial, L"%04X-%04X", LOWORD(pItem->dwSerial), HIWORD(pItem->dwSerial));
1029             if (RegCreateKeyExW(hKey, szSerial, 0, NULL, 0, KEY_WRITE, NULL, &hSubKey, NULL) == ERROR_SUCCESS)
1030             {
1031                 dwSize = sizeof(DWORD);
1032                 RegSetValueExW(hSubKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&pItem->dwNukeOnDelete, dwSize);
1033                 dwSize = sizeof(DWORD);
1034                 RegSetValueExW(hSubKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&pItem->dwMaxCapacity, dwSize);
1035                 RegCloseKey(hSubKey);
1036             }
1037         }
1038     }
1039     RegCloseKey(hKey);
1040     return TRUE;
1041
1042 }
1043
1044 static VOID FreeDriveItemContext(HWND hwndDlg)
1045 {
1046     int iCount, iIndex;
1047     HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1048     LVITEMW li;
1049
1050     iCount = ListView_GetItemCount(hDlgCtrl);
1051
1052     ZeroMemory(&li, sizeof(li));
1053     li.mask = LVIF_PARAM;
1054
1055     for(iIndex = 0; iIndex < iCount; iIndex++)
1056     {
1057         li.iItem = iIndex;
1058         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)&li))
1059         {
1060             HeapFree(GetProcessHeap(), 0, (LPVOID)li.lParam);
1061         }
1062     }
1063 }
1064
1065 static INT
1066 GetDefaultItem(HWND hwndDlg, LVITEMW * li)
1067 {
1068     HWND hDlgCtrl;
1069     UINT iItemCount, iIndex;
1070
1071     hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1072     if (!hDlgCtrl)
1073         return -1;
1074
1075     iItemCount = ListView_GetItemCount(hDlgCtrl);
1076     if (!iItemCount)
1077         return -1;
1078
1079     ZeroMemory(li, sizeof(LVITEMW));
1080     li->mask = LVIF_PARAM | LVIF_STATE;
1081     li->stateMask = (UINT) - 1;
1082     for (iIndex = 0; iIndex < iItemCount; iIndex++)
1083     {
1084         li->iItem = iIndex;
1085         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)li))
1086         {
1087             if (li->state & LVIS_SELECTED)
1088                 return iIndex;
1089         }
1090     }
1091     return -1;
1092
1093 }
1094
1095 static INT_PTR CALLBACK
1096 RecycleBinDlg(
1097     HWND hwndDlg,
1098     UINT uMsg,
1099     WPARAM wParam,
1100     LPARAM lParam
1101 )
1102 {
1103     LPPSHNOTIFY lppsn;
1104     LPNMLISTVIEW lppl;
1105     LVITEMW li;
1106     PDRIVE_ITEM_CONTEXT pItem;
1107     BOOL bSuccess;
1108     UINT uResult;
1109     PROPSHEETPAGE * page;
1110     DWORD dwStyle;
1111
1112     switch(uMsg)
1113     {
1114         case WM_INITDIALOG:
1115             page = (PROPSHEETPAGE*)lParam;
1116             InitializeRecycleBinDlg(hwndDlg, (WCHAR)page->lParam);
1117             dwStyle = (DWORD) SendDlgItemMessage(hwndDlg, 14000, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
1118             dwStyle = dwStyle | LVS_EX_FULLROWSELECT;
1119             SendDlgItemMessage(hwndDlg, 14000, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwStyle);
1120             if (GetDlgCtrlID((HWND)wParam) != 14000)
1121             {
1122                 SetFocus(GetDlgItem(hwndDlg, 14000));
1123                 return FALSE;
1124             }
1125             return TRUE;
1126         case WM_COMMAND:
1127             switch(LOWORD(wParam))
1128             {
1129                 case 14001:
1130                     toggleNukeOnDeleteOption(hwndDlg, FALSE);
1131                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1132                     break;
1133                 case 14003:
1134                     toggleNukeOnDeleteOption(hwndDlg, TRUE);
1135                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1136                     break;
1137                 case 14004:
1138                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1139                     break;
1140             }
1141             break;
1142         case WM_NOTIFY:
1143             lppsn = (LPPSHNOTIFY) lParam;
1144             lppl = (LPNMLISTVIEW) lParam;
1145             if (lppsn->hdr.code == PSN_APPLY)
1146             {
1147                 if (GetDefaultItem(hwndDlg, &li) > -1)
1148                 {
1149                     pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1150                     if (pItem)
1151                     {
1152                         uResult = GetDlgItemInt(hwndDlg, 14002, &bSuccess, FALSE);
1153                         if (bSuccess)
1154                             pItem->dwMaxCapacity = uResult;
1155                         if (SendDlgItemMessageW(hwndDlg, 14003, BM_GETCHECK, 0, 0) == BST_CHECKED)
1156                             pItem->dwNukeOnDelete = TRUE;
1157                         else
1158                             pItem->dwNukeOnDelete = FALSE;
1159                     }
1160                 }
1161                 if (StoreDriveSettings(hwndDlg))
1162                 {
1163                     SetWindowLongPtr( hwndDlg, DWL_MSGRESULT, PSNRET_NOERROR );
1164                     return TRUE;
1165                 }
1166             }
1167             else if (lppl->hdr.code == LVN_ITEMCHANGING)
1168             {
1169                 ZeroMemory(&li, sizeof(li));
1170                 li.mask = LVIF_PARAM;
1171                 li.iItem = lppl->iItem;
1172                 if (!SendMessageW(lppl->hdr.hwndFrom, LVM_GETITEMW, 0, (LPARAM)&li))
1173                     return TRUE;
1174
1175                 pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1176                 if (!pItem)
1177                     return TRUE;
1178
1179                 if (!(lppl->uOldState & LVIS_FOCUSED) && (lppl->uNewState & LVIS_FOCUSED))
1180                 {
1181                     /* new focused item */
1182                     toggleNukeOnDeleteOption(lppl->hdr.hwndFrom, pItem->dwNukeOnDelete);
1183                     SetDlgItemInt(hwndDlg, 14002, pItem->dwMaxCapacity, FALSE);
1184                 }
1185                 else if ((lppl->uOldState & LVIS_FOCUSED) && !(lppl->uNewState & LVIS_FOCUSED))
1186                 {
1187                     /* kill focus */
1188                     uResult = GetDlgItemInt(hwndDlg, 14002, &bSuccess, FALSE);
1189                     if (bSuccess)
1190                         pItem->dwMaxCapacity = uResult;
1191                     if (SendDlgItemMessageW(hwndDlg, 14003, BM_GETCHECK, 0, 0) == BST_CHECKED)
1192                         pItem->dwNukeOnDelete = TRUE;
1193                     else
1194                         pItem->dwNukeOnDelete = FALSE;
1195                 }
1196                 return TRUE;
1197
1198             }
1199             break;
1200         case WM_DESTROY:
1201             FreeDriveItemContext(hwndDlg);
1202             break;
1203     }
1204     return FALSE;
1205 }
1206
1207 BOOL SH_ShowRecycleBinProperties(WCHAR sDrive)
1208 {
1209     HPROPSHEETPAGE hpsp[1];
1210     PROPSHEETHEADERW psh;
1211     HPROPSHEETPAGE hprop;
1212
1213     BOOL ret;
1214
1215
1216     ZeroMemory(&psh, sizeof(PROPSHEETHEADERW));
1217     psh.dwSize = sizeof(PROPSHEETHEADERW);
1218     psh.dwFlags = PSP_DEFAULT | PSH_PROPTITLE;
1219     psh.pszCaption = MAKEINTRESOURCEW(IDS_RECYCLEBIN_FOLDER_NAME);
1220     psh.hwndParent = NULL;
1221     psh.phpage = hpsp;
1222     psh.hInstance = shell32_hInstance;
1223
1224     hprop = SH_CreatePropertySheetPage(IDD_RECYCLE_BIN_PROPERTIES, RecycleBinDlg, (LPARAM)sDrive, NULL);
1225     if (!hprop)
1226     {
1227         ERR("Failed to create property sheet\n");
1228         return FALSE;
1229     }
1230     hpsp[psh.nPages] = hprop;
1231     psh.nPages++;
1232
1233
1234     ret = PropertySheetW(&psh);
1235     if (ret < 0)
1236         return FALSE;
1237     else
1238         return TRUE;
1239 }
1240
1241 BOOL
1242 TRASH_CanTrashFile(LPCWSTR wszPath)
1243 {
1244     LONG ret;
1245     DWORD dwNukeOnDelete, dwType, VolSerialNumber, MaxComponentLength;
1246     DWORD FileSystemFlags, dwSize, dwDisposition;
1247     HKEY hKey;
1248     WCHAR szBuffer[10];
1249     WCHAR szKey[150] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume\\";
1250
1251     if (wszPath[1] != L':')
1252     {
1253         /* path is UNC */
1254         return FALSE;
1255     }
1256
1257     if (GetDriveTypeW(wszPath) != DRIVE_FIXED)
1258     {
1259         /* no bitbucket on removable media */
1260         return FALSE;
1261     }
1262
1263     if (!GetVolumeInformationW(wszPath, NULL, 0, &VolSerialNumber, &MaxComponentLength, &FileSystemFlags, NULL, 0))
1264     {
1265         ERR("GetVolumeInformationW failed with %u\n", GetLastError());
1266         return FALSE;
1267     }
1268
1269     swprintf(szBuffer, L"%04X-%04X", LOWORD(VolSerialNumber), HIWORD(VolSerialNumber));
1270     wcscat(szKey, szBuffer);
1271
1272     if (RegCreateKeyExW(HKEY_CURRENT_USER, szKey, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition) != ERROR_SUCCESS)
1273     {
1274         ERR("RegCreateKeyExW failed\n");
1275         return FALSE;
1276     }
1277
1278     if (dwDisposition  & REG_CREATED_NEW_KEY)
1279     {
1280         /* per default move to bitbucket */
1281         dwNukeOnDelete = 0;
1282         RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
1283         /* per default unlimited size */
1284         dwSize = -1;
1285         RegSetValueExW(hKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
1286         RegCloseKey(hKey);
1287         return TRUE;
1288     }
1289     else
1290     {
1291         dwSize = sizeof(dwNukeOnDelete);
1292         ret = RegQueryValueExW(hKey, L"NukeOnDelete", NULL, &dwType, (LPBYTE)&dwNukeOnDelete, &dwSize);
1293         if (ret != ERROR_SUCCESS)
1294         {
1295             if (ret ==  ERROR_FILE_NOT_FOUND)
1296             {
1297                 /* restore key and enable bitbucket */
1298                 dwNukeOnDelete = 0;
1299                 RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
1300             }
1301             RegCloseKey(hKey);
1302             return TRUE;
1303         }
1304         else if (dwNukeOnDelete)
1305         {
1306             /* do not delete to bitbucket */
1307             RegCloseKey(hKey);
1308             return FALSE;
1309         }
1310         /* FIXME
1311          * check if bitbucket is full
1312          */
1313         RegCloseKey(hKey);
1314         return TRUE;
1315     }
1316 }
1317
1318 BOOL
1319 TRASH_TrashFile(LPCWSTR wszPath)
1320 {
1321     TRACE("(%s)\n", debugstr_w(wszPath));
1322     return DeleteFileToRecycleBin(wszPath);
1323 }
1324
1325 /*************************************************************************
1326  * SHUpdateCRecycleBinIcon                                [SHELL32.@]
1327  *
1328  * Undocumented
1329  */
1330 EXTERN_C HRESULT WINAPI SHUpdateRecycleBinIcon(void)
1331 {
1332     FIXME("stub\n");
1333
1334
1335
1336     return S_OK;
1337 }
1338
1339 /****************************************************************************
1340  * IDropTarget implementation
1341  */
1342 BOOL CRecycleBin::QueryDrop(DWORD dwKeyState, LPDWORD pdwEffect)
1343 {
1344     /* TODO on shift we should delete, we should update the cursor manager to show this. */
1345
1346     DWORD dwEffect = DROPEFFECT_COPY;
1347
1348     *pdwEffect = DROPEFFECT_NONE;
1349
1350     if (fAcceptFmt) { /* Does our interpretation of the keystate ... */
1351         *pdwEffect = KeyStateToDropEffect (dwKeyState);
1352
1353         if (*pdwEffect == DROPEFFECT_NONE)
1354             *pdwEffect = dwEffect;
1355
1356         /* ... matches the desired effect ? */
1357         if (dwEffect & *pdwEffect) {
1358             return TRUE;
1359         }
1360     }
1361     return FALSE;
1362 }
1363
1364 HRESULT WINAPI CRecycleBin::DragEnter(IDataObject *pDataObject,
1365                                     DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
1366 {
1367     TRACE("Recycle bin drag over (%p)\n", this);
1368     /* The recycle bin accepts pretty much everything, and sets a CSIDL flag. */
1369     fAcceptFmt = TRUE;
1370
1371     QueryDrop(dwKeyState, pdwEffect);
1372     return S_OK;
1373 }
1374
1375 HRESULT WINAPI CRecycleBin::DragOver(DWORD dwKeyState, POINTL pt,
1376                                    DWORD *pdwEffect)
1377 {
1378     TRACE("(%p)\n", this);
1379
1380     if (!pdwEffect)
1381         return E_INVALIDARG;
1382
1383     QueryDrop(dwKeyState, pdwEffect);
1384
1385     return S_OK;
1386 }
1387
1388 HRESULT WINAPI CRecycleBin::DragLeave()
1389 {
1390     TRACE("(%p)\n", this);
1391
1392     fAcceptFmt = FALSE;
1393
1394     return S_OK;
1395 }
1396
1397 HRESULT WINAPI CRecycleBin::Drop(IDataObject *pDataObject,
1398                                DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
1399 {
1400     TRACE("(%p) object dropped on recycle bin, effect %u\n", this, *pdwEffect);
1401
1402     /* TODO: pdwEffect should be read and make the drop object be permanently deleted in the move case (shift held) */
1403
1404     FORMATETC fmt;
1405     TRACE("(%p)->(DataObject=%p)\n", this, pDataObject);
1406     InitFormatEtc (fmt, cfShellIDList, TYMED_HGLOBAL);
1407
1408     /* Handle cfShellIDList Drop objects here, otherwise send the approriate message to other software */
1409     if (SUCCEEDED(pDataObject->QueryGetData(&fmt))) {
1410         IStream *s;
1411         CoMarshalInterThreadInterfaceInStream(IID_IDataObject, pDataObject, &s);
1412         SHCreateThread(DoDeleteThreadProc, s, NULL, NULL);
1413     }
1414     else
1415     {
1416         /*
1417          * TODO call SetData on the data object with format CFSTR_TARGETCLSID
1418          * set to the Recycle Bin's class identifier CLSID_RecycleBin.
1419          */
1420     }
1421     return S_OK;
1422 }
1423
1424 DWORD WINAPI DoDeleteThreadProc(LPVOID lpParameter)
1425 {
1426     CoInitialize(NULL);
1427     CComPtr<IDataObject> pDataObject;
1428     HRESULT hr = CoGetInterfaceAndReleaseStream (static_cast<IStream*>(lpParameter), IID_PPV_ARG(IDataObject, &pDataObject));
1429     if (SUCCEEDED(hr))
1430     {
1431         DoDeleteDataObject(pDataObject);
1432     }
1433     CoUninitialize();
1434     return 0;
1435 }
1436
1437 HRESULT WINAPI DoDeleteDataObject(IDataObject *pda)
1438 {
1439     TRACE("performing delete");
1440     HRESULT hr;
1441
1442     STGMEDIUM medium;
1443     FORMATETC formatetc;
1444     InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
1445     hr = pda->GetData(&formatetc, &medium);
1446     if (FAILED(hr))
1447         return hr;
1448
1449     /* lock the handle */
1450     LPIDA lpcida = (LPIDA)GlobalLock(medium.hGlobal);
1451     if (!lpcida)
1452     {
1453         ReleaseStgMedium(&medium);
1454         return E_FAIL;
1455     }
1456
1457     /* convert the data into pidl */
1458     LPITEMIDLIST pidl;
1459     LPITEMIDLIST *apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
1460     if (!apidl)
1461     {
1462         ReleaseStgMedium(&medium);
1463         return E_FAIL;
1464     }
1465
1466     CComPtr<IShellFolder> psfDesktop;
1467     CComPtr<IShellFolder> psfFrom = NULL;
1468
1469     /* Grab the desktop shell folder */
1470     hr = SHGetDesktopFolder(&psfDesktop);
1471     if (FAILED(hr))
1472     {
1473         ERR("SHGetDesktopFolder failed\n");
1474         SHFree(pidl);
1475         _ILFreeaPidl(apidl, lpcida->cidl);
1476         ReleaseStgMedium(&medium);
1477         return E_FAIL;
1478     }
1479
1480     /* Find source folder, this is where the clipboard data was copied from */
1481     if (_ILIsDesktop(pidl))
1482     {
1483         psfFrom = psfDesktop;
1484     }
1485     else
1486     {
1487         hr = psfDesktop->BindToObject(pidl, NULL, IID_PPV_ARG(IShellFolder, &psfFrom));
1488         if (FAILED(hr))
1489         {
1490             ERR("no IShellFolder\n");
1491             SHFree(pidl);
1492             _ILFreeaPidl(apidl, lpcida->cidl);
1493             ReleaseStgMedium(&medium);
1494             return E_FAIL;
1495         }
1496     }
1497
1498     STRRET strTemp;
1499     hr = psfFrom->GetDisplayNameOf(apidl[0], SHGDN_FORPARSING, &strTemp);
1500     if (FAILED(hr))
1501     {
1502         ERR("IShellFolder_GetDisplayNameOf failed with %x\n", hr);
1503         SHFree(pidl);
1504         _ILFreeaPidl(apidl, lpcida->cidl);
1505         ReleaseStgMedium(&medium);
1506         return hr;
1507     }
1508
1509     WCHAR wszPath[MAX_PATH];
1510     hr = StrRetToBufW(&strTemp, apidl[0], wszPath, _countof(wszPath));
1511     if (FAILED(hr))
1512     {
1513         ERR("StrRetToBufW failed with %x\n", hr);
1514         SHFree(pidl);
1515         _ILFreeaPidl(apidl, lpcida->cidl);
1516         ReleaseStgMedium(&medium);
1517         return hr;
1518     }
1519
1520     /* Only keep the base path */
1521     LPWSTR pwszFilename = PathFindFileNameW(wszPath);
1522     *pwszFilename = L'\0';
1523
1524     /* Build paths list */
1525     LPWSTR pwszPaths = BuildPathsList(wszPath, lpcida->cidl, (LPCITEMIDLIST*) apidl);
1526     if (!pwszPaths)
1527     {
1528         SHFree(pidl);
1529         _ILFreeaPidl(apidl, lpcida->cidl);
1530         ReleaseStgMedium(&medium);
1531         return E_FAIL;
1532     }
1533
1534     /* Delete them */
1535     SHFILEOPSTRUCTW FileOp;
1536     ZeroMemory(&FileOp, sizeof(FileOp));
1537     FileOp.wFunc = FO_DELETE;
1538     FileOp.pFrom = pwszPaths;
1539     FileOp.fFlags = FOF_ALLOWUNDO;
1540
1541     if (SHFileOperationW(&FileOp) != 0)
1542     {
1543         ERR("SHFileOperation failed with 0x%x for %s\n", GetLastError(), debugstr_w(pwszPaths));
1544         hr = E_FAIL;
1545     }
1546
1547     HeapFree(GetProcessHeap(), 0, pwszPaths);
1548     SHFree(pidl);
1549     _ILFreeaPidl(apidl, lpcida->cidl);
1550     ReleaseStgMedium(&medium);
1551
1552     return hr;
1553 }