reactos/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 IEnumIDListImpl
  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 static HRESULT WINAPI CRecycleBinItemContextMenuConstructor(REFIID riid, LPCITEMIDLIST pidl, LPVOID *ppv)
 407 {
 408     CComObject<CRecycleBinItemContextMenu>    *theMenu;
 409     CComPtr<IUnknown>                        result;
 410     HRESULT                                    hResult;
 411
 412     TRACE("%s\n", shdebugstr_guid(&riid));
 413
 414     if (ppv == NULL)
 415         return E_POINTER;
 416     *ppv = NULL;
 417     ATLTRY(theMenu = new CComObject<CRecycleBinItemContextMenu>);
 418     if (theMenu == NULL)
 419         return E_OUTOFMEMORY;
 420     hResult = theMenu->QueryInterface(riid, (void **)&result);
 421     if (FAILED(hResult))
 422     {
 423         delete theMenu;
 424         return hResult;
 425     }
 426     hResult = theMenu->Initialize(pidl);
 427     if (FAILED(hResult))
 428         return hResult;
 429     *ppv = result.Detach();
 430     TRACE ("--(%p)\n", *ppv);
 431     return S_OK;
 432 }
 433
 434 /**************************************************************************
 435 * registers clipboardformat once
 436 */
 437 void CRecycleBin::SF_RegisterClipFmt()
 438 {
 439     TRACE ("(%p)\n", this);
 440
 441     if (!cfShellIDList)
 442         cfShellIDList = RegisterClipboardFormatW(CFSTR_SHELLIDLIST);
 443 }
 444
 445 CRecycleBin::CRecycleBin()
 446 {
 447     pidl = NULL;
 448     iIdEmpty = 0;
 449     cfShellIDList = 0;
 450     SF_RegisterClipFmt();
 451     fAcceptFmt = FALSE;
 452 }
 453
 454 CRecycleBin::~CRecycleBin()
 455 {
 456     /*    InterlockedDecrement(&objCount);*/
 457     SHFree(pidl);
 458 }
 459
 460 /*************************************************************************
 461  * RecycleBin IPersistFolder2 interface
 462  */
 463
 464 HRESULT WINAPI CRecycleBin::GetClassID(CLSID *pClassID)
 465 {
 466     TRACE("(%p, %p)\n", this, pClassID);
 467     if (pClassID == NULL)
 468         return E_INVALIDARG;
 469     memcpy(pClassID, &CLSID_RecycleBin, sizeof(CLSID));
 470     return S_OK;
 471 }
 472
 473 HRESULT WINAPI CRecycleBin::Initialize(LPCITEMIDLIST pidl)
 474 {
 475     TRACE("(%p, %p)\n", this, pidl);
 476
 477     SHFree((LPVOID)this->pidl);
 478     this->pidl = ILClone(pidl);
 479     if (this->pidl == NULL)
 480         return E_OUTOFMEMORY;
 481     return S_OK;
 482 }
 483
 484 HRESULT WINAPI CRecycleBin::GetCurFolder(LPITEMIDLIST *ppidl)
 485 {
 486     TRACE("\n");
 487     *ppidl = ILClone(pidl);
 488     return S_OK;
 489 }
 490
 491 /*************************************************************************
 492  * RecycleBin IShellFolder2 interface
 493  */
 494
 495 HRESULT WINAPI CRecycleBin::ParseDisplayName(HWND hwnd, LPBC pbc,
 496         LPOLESTR pszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl,
 497         ULONG *pdwAttributes)
 498 {
 499     FIXME("stub\n");
 500     return E_NOTIMPL;
 501 }
 502
 503
 504 PDELETED_FILE_DETAILS_W
 505 UnpackDetailsFromPidl(LPCITEMIDLIST pidl)
 506 {
 507     return (PDELETED_FILE_DETAILS_W)&pidl->mkid.abID;
 508 }
 509
 510 HRESULT WINAPI CRecycleBin::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
 511 {
 512     CComObject<CRecycleBinEnum>                *theEnumerator;
 513     CComPtr<IEnumIDList>                    result;
 514     HRESULT                                    hResult;
 515
 516     TRACE ("(%p)->(HWND=%p flags=0x%08x pplist=%p)\n", this, hwndOwner, dwFlags, ppEnumIDList);
 517
 518     if (ppEnumIDList == NULL)
 519         return E_POINTER;
 520     *ppEnumIDList = NULL;
 521     ATLTRY (theEnumerator = new CComObject<CRecycleBinEnum>);
 522     if (theEnumerator == NULL)
 523         return E_OUTOFMEMORY;
 524     hResult = theEnumerator->QueryInterface(IID_PPV_ARG(IEnumIDList, &result));
 525     if (FAILED (hResult))
 526     {
 527         delete theEnumerator;
 528         return hResult;
 529     }
 530     hResult = theEnumerator->Initialize(dwFlags);
 531     if (FAILED (hResult))
 532         return hResult;
 533     *ppEnumIDList = result.Detach();
 534
 535     TRACE ("-- (%p)->(new ID List: %p)\n", this, *ppEnumIDList);
 536
 537     return S_OK;
 538 }
 539
 540 HRESULT WINAPI CRecycleBin::BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbc, REFIID riid, void **ppv)
 541 {
 542     FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
 543     return E_NOTIMPL;
 544 }
 545
 546 HRESULT WINAPI CRecycleBin::BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbc, REFIID riid, void **ppv)
 547 {
 548     FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
 549     return E_NOTIMPL;
 550 }
 551
 552 HRESULT WINAPI CRecycleBin::CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
 553 {
 554     /* TODO */
 555     TRACE("(%p, %p, %p, %p)\n", this, (void *)lParam, pidl1, pidl2);
 556     if (pidl1->mkid.cb != pidl2->mkid.cb)
 557         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, pidl1->mkid.cb - pidl2->mkid.cb);
 558     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (unsigned short)memcmp(pidl1->mkid.abID, pidl2->mkid.abID, pidl1->mkid.cb));
 559 }
 560
 561 HRESULT WINAPI CRecycleBin::CreateViewObject(HWND hwndOwner, REFIID riid, void **ppv)
 562 {
 563     LPSHELLVIEW pShellView;
 564     HRESULT hr = E_NOINTERFACE;
 565
 566     TRACE("(%p, %p, %s, %p)\n", this, hwndOwner, debugstr_guid(&riid), ppv);
 567
 568     if (!ppv)
 569         return hr;
 570
 571     *ppv = NULL;
 572
 573     if (IsEqualIID (riid, IID_IDropTarget))
 574     {
 575         hr = this->QueryInterface (IID_IDropTarget, ppv);
 576     }
 577     else if (IsEqualIID (riid, IID_IContextMenu) || IsEqualIID (riid, IID_IContextMenu2))
 578     {
 579         hr = this->QueryInterface(riid, ppv);
 580     }
 581     else if (IsEqualIID (riid, IID_IShellView))
 582     {
 583         hr = IShellView_Constructor ((IShellFolder *)this, &pShellView);
 584         if (pShellView)
 585         {
 586             hr = pShellView->QueryInterface(riid, ppv);
 587             pShellView->Release();
 588         }
 589     }
 590     else
 591         return hr;
 592     TRACE ("-- (%p)->(interface=%p)\n", this, ppv);
 593     return hr;
 594
 595 }
 596
 597 HRESULT WINAPI CRecycleBin::GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 598         SFGAOF *rgfInOut)
 599 {
 600     TRACE("(%p, %d, {%p, ...}, {%x})\n", this, cidl, apidl ? apidl[0] : NULL, (unsigned int)*rgfInOut);
 601     *rgfInOut &= SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK;
 602     return S_OK;
 603 }
 604
 605 HRESULT WINAPI CRecycleBin::GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl,
 606         REFIID riid, UINT *prgfInOut, void **ppv)
 607 {
 608     IUnknown *pObj = NULL;
 609     HRESULT hr = E_INVALIDARG;
 610
 611     TRACE ("(%p)->(%p,%u,apidl=%p, %p %p)\n", this,
 612            hwndOwner, cidl, apidl, prgfInOut, ppv);
 613
 614     if (!ppv)
 615         return hr;
 616
 617     *ppv = NULL;
 618
 619     if ((IsEqualIID (riid, IID_IContextMenu) || IsEqualIID(riid, IID_IContextMenu2)) && (cidl >= 1))
 620     {
 621         hr = CRecycleBinItemContextMenuConstructor(riid, apidl[0], (void **)&pObj);
 622     }
 623     else if (IsEqualIID (riid, IID_IDropTarget) && (cidl == 1))
 624     {
 625         hr = this->QueryInterface(IID_IDropTarget, (LPVOID *) & pObj);
 626     }
 627     else
 628         hr = E_NOINTERFACE;
 629
 630     if (SUCCEEDED(hr) && !pObj)
 631         hr = E_OUTOFMEMORY;
 632
 633     *ppv = pObj;
 634     TRACE ("(%p)->hr=0x%08x\n", this, hr);
 635     return hr;
 636 }
 637
 638 HRESULT WINAPI CRecycleBin::GetDisplayNameOf(PCUITEMID_CHILD pidl, SHGDNF uFlags, STRRET *pName)
 639 {
 640     PIDLRecycleStruct *pFileDetails;
 641     LPWSTR pFileName;
 642
 643     TRACE("(%p, %p, %x, %p)\n", this, pidl, (unsigned int)uFlags, pName);
 644
 645
 646     if (_ILIsBitBucket (pidl))
 647     {
 648         WCHAR pszPath[100];
 649
 650         if (HCR_GetClassNameW(CLSID_RecycleBin, pszPath, MAX_PATH))
 651         {
 652             pName->uType = STRRET_WSTR;
 653             pName->pOleStr = StrDupW(pszPath);
 654             return S_OK;
 655         }
 656     }
 657
 658     pFileDetails = _ILGetRecycleStruct(pidl);
 659     if (!pFileDetails)
 660     {
 661         pName->cStr[0] = 0;
 662         pName->uType = STRRET_CSTR;
 663         return E_INVALIDARG;
 664     }
 665
 666     pFileName = wcsrchr(pFileDetails->szName, L'\\');
 667     if (!pFileName)
 668     {
 669         pName->cStr[0] = 0;
 670         pName->uType = STRRET_CSTR;
 671         return E_UNEXPECTED;
 672     }
 673
 674     pName->pOleStr = StrDupW(pFileName + 1);
 675     if (pName->pOleStr == NULL)
 676         return E_OUTOFMEMORY;
 677
 678     pName->uType = STRRET_WSTR;
 679     return S_OK;
 680 }
 681
 682 HRESULT WINAPI CRecycleBin::SetNameOf(HWND hwnd, PCUITEMID_CHILD pidl, LPCOLESTR pszName,
 683                                       SHGDNF uFlags, PITEMID_CHILD *ppidlOut)
 684 {
 685     TRACE("\n");
 686     return E_FAIL; /* not supported */
 687 }
 688
 689 HRESULT WINAPI CRecycleBin::GetDefaultSearchGUID(GUID *pguid)
 690 {
 691     FIXME("stub\n");
 692     return E_NOTIMPL;
 693 }
 694
 695 HRESULT WINAPI CRecycleBin::EnumSearches(IEnumExtraSearch **ppEnum)
 696 {
 697     FIXME("stub\n");
 698     *ppEnum = NULL;
 699     return E_NOTIMPL;
 700 }
 701
 702 HRESULT WINAPI CRecycleBin::GetDefaultColumn(DWORD dwReserved, ULONG *pSort, ULONG *pDisplay)
 703 {
 704     TRACE("(%p, %x, %p, %p)\n", this, (unsigned int)dwReserved, pSort, pDisplay);
 705     *pSort = 0;
 706     *pDisplay = 0;
 707     return S_OK;
 708 }
 709
 710 HRESULT WINAPI CRecycleBin::GetDefaultColumnState(UINT iColumn, SHCOLSTATEF *pcsFlags)
 711 {
 712     TRACE("(%p, %d, %p)\n", this, iColumn, pcsFlags);
 713     if (iColumn >= COLUMNS_COUNT)
 714         return E_INVALIDARG;
 715     *pcsFlags = RecycleBinColumns[iColumn].pcsFlags;
 716     return S_OK;
 717 }
 718
 719 HRESULT WINAPI CRecycleBin::GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 720 {
 721     FIXME("stub\n");
 722     return E_NOTIMPL;
 723 }
 724
 725 static HRESULT FormatDateTime(LPWSTR buffer, int size, FILETIME * ft)
 726 {
 727     FILETIME lft;
 728     SYSTEMTIME time;
 729     int ret;
 730
 731     FileTimeToLocalFileTime(ft, &lft);
 732     FileTimeToSystemTime(&lft, &time);
 733
 734     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time, NULL, buffer, size);
 735     if (ret > 0 && ret < size)
 736     {
 737         /* Append space + time without seconds */
 738         buffer[ret-1] = ' ';
 739         GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &buffer[ret], size - ret);
 740     }
 741
 742     return (ret != 0 ? E_FAIL : S_OK);
 743 }
 744
 745 HRESULT WINAPI CRecycleBin::GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, LPSHELLDETAILS pDetails)
 746 {
 747     PIDLRecycleStruct * pFileDetails;
 748     WCHAR buffer[MAX_PATH];
 749     WCHAR szTypeName[100];
 750     LPWSTR pszBackslash;
 751     UINT Length;
 752
 753     TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, pDetails);
 754     if (iColumn >= COLUMNS_COUNT)
 755         return E_FAIL;
 756     pDetails->fmt = RecycleBinColumns[iColumn].fmt;
 757     pDetails->cxChar = RecycleBinColumns[iColumn].cxChars;
 758     if (pidl == NULL)
 759     {
 760         pDetails->str.uType = STRRET_WSTR;
 761         LoadStringW(shell32_hInstance, RecycleBinColumns[iColumn].column_name_id, buffer, MAX_PATH);
 762         return SHStrDupW(buffer, &pDetails->str.pOleStr);
 763     }
 764
 765     if (iColumn == COLUMN_NAME)
 766         return GetDisplayNameOf(pidl, SHGDN_NORMAL, &pDetails->str);
 767
 768     pFileDetails = _ILGetRecycleStruct(pidl);
 769     switch (iColumn)
 770     {
 771         case COLUMN_DATEDEL:
 772             FormatDateTime(buffer, MAX_PATH, &pFileDetails->DeletionTime);
 773             break;
 774         case COLUMN_DELFROM:
 775             pszBackslash = wcsrchr(pFileDetails->szName, L'\\');
 776             Length = (pszBackslash - pFileDetails->szName);
 777             memcpy((LPVOID)buffer, pFileDetails->szName, Length * sizeof(WCHAR));
 778             buffer[Length] = L'\0';
 779             break;
 780         case COLUMN_SIZE:
 781             StrFormatKBSizeW(pFileDetails->FileSize.QuadPart, buffer, MAX_PATH);
 782             break;
 783         case COLUMN_MTIME:
 784             FormatDateTime(buffer, MAX_PATH, &pFileDetails->LastModification);
 785             break;
 786         case COLUMN_TYPE:
 787             szTypeName[0] = L'\0';
 788             wcscpy(buffer, PathFindExtensionW(pFileDetails->szName));
 789             if (!( HCR_MapTypeToValueW(buffer, buffer, sizeof(buffer) / sizeof(WCHAR), TRUE) &&
 790                     HCR_MapTypeToValueW(buffer, szTypeName, sizeof(szTypeName) / sizeof(WCHAR), FALSE )))
 791             {
 792                 wcscpy (szTypeName, PathFindExtensionW(pFileDetails->szName));
 793                 wcscat(szTypeName, L"-");
 794                 Length = wcslen(szTypeName);
 795                 if (LoadStringW(shell32_hInstance, IDS_SHV_COLUMN1, &szTypeName[Length], (sizeof(szTypeName) / sizeof(WCHAR)) - Length))
 796                     szTypeName[(sizeof(szTypeName)/sizeof(WCHAR))-1] = L'\0';
 797             }
 798             pDetails->str.uType = STRRET_WSTR;
 799             return SHStrDupW(szTypeName, &pDetails->str.pOleStr);
 800             break;
 801         default:
 802             return E_FAIL;
 803     }
 804
 805     pDetails->str.uType = STRRET_WSTR;
 806     return SHStrDupW(buffer, &pDetails->str.pOleStr);
 807 }
 808
 809 HRESULT WINAPI CRecycleBin::MapColumnToSCID(UINT iColumn, SHCOLUMNID *pscid)
 810 {
 811     TRACE("(%p, %d, %p)\n", this, iColumn, pscid);
 812     if (iColumn >= COLUMNS_COUNT)
 813         return E_INVALIDARG;
 814     pscid->fmtid = *RecycleBinColumns[iColumn].fmtId;
 815     pscid->pid = RecycleBinColumns[iColumn].pid;
 816     return S_OK;
 817 }
 818
 819 /*************************************************************************
 820  * RecycleBin IContextMenu interface
 821  */
 822
 823 HRESULT WINAPI CRecycleBin::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
 824 {
 825     WCHAR szBuffer[100];
 826     MENUITEMINFOW mii;
 827     int id = 1;
 828
 829     TRACE("QueryContextMenu %p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
 830
 831     if (!hMenu)
 832         return E_INVALIDARG;
 833
 834     memset(&mii, 0, sizeof(mii));
 835     mii.cbSize = sizeof(mii);
 836     mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
 837     mii.fState = MFS_ENABLED;
 838     szBuffer[0] = L'\0';
 839     LoadStringW(shell32_hInstance, IDS_EMPTY_BITBUCKET, szBuffer, sizeof(szBuffer) / sizeof(WCHAR));
 840     mii.dwTypeData = szBuffer;
 841     mii.cch = wcslen(mii.dwTypeData);
 842     mii.wID = idCmdFirst + id++;
 843     mii.fType = MFT_STRING;
 844     iIdEmpty = 1;
 845
 846     if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
 847         return E_FAIL;
 848
 849     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
 850 }
 851
 852 HRESULT WINAPI CRecycleBin::InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
 853 {
 854     HRESULT hr;
 855     LPSHELLBROWSER lpSB;
 856     LPSHELLVIEW lpSV = NULL;
 857
 858     TRACE("%p %p verb %p\n", this, lpcmi, lpcmi->lpVerb);
 859
 860     if (LOWORD(lpcmi->lpVerb) == iIdEmpty)
 861     {
 862         // FIXME
 863         // path & flags
 864         hr = SHEmptyRecycleBinW(lpcmi->hwnd, L"C:\\", 0);
 865         TRACE("result %x\n", hr);
 866         if (hr != S_OK)
 867             return hr;
 868
 869         lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0);
 870         if (lpSB && SUCCEEDED(lpSB->QueryActiveShellView(&lpSV)))
 871             lpSV->Refresh();
 872     }
 873     return S_OK;
 874 }
 875
 876 HRESULT WINAPI CRecycleBin::GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
 877 {
 878     FIXME("%p %lu %u %p %p %u\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
 879
 880     return E_NOTIMPL;
 881 }
 882
 883 /*************************************************************************
 884  * RecycleBin IShellPropSheetExt interface
 885  */
 886
 887 HRESULT WINAPI CRecycleBin::AddPages(LPFNSVADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
 888 {
 889     FIXME("%p %p %lu\n", this, pfnAddPage, lParam);
 890
 891     return E_NOTIMPL;
 892 }
 893
 894 HRESULT WINAPI CRecycleBin::ReplacePage(EXPPS uPageID, LPFNSVADDPROPSHEETPAGE pfnReplaceWith, LPARAM lParam)
 895 {
 896     FIXME("%p %lu %p %lu\n", this, uPageID, pfnReplaceWith, lParam);
 897
 898     return E_NOTIMPL;
 899 }
 900
 901 /*************************************************************************
 902  * RecycleBin IShellExtInit interface
 903  */
 904
 905 HRESULT WINAPI CRecycleBin::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pdtobj, HKEY hkeyProgID)
 906 {
 907     TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID );
 908     return S_OK;
 909 }
 910
 911 void toggleNukeOnDeleteOption(HWND hwndDlg, BOOL bEnable)
 912 {
 913     if (bEnable)
 914     {
 915         SendDlgItemMessage(hwndDlg, 14001, BM_SETCHECK, BST_UNCHECKED, 0);
 916         EnableWindow(GetDlgItem(hwndDlg, 14002), FALSE);
 917         SendDlgItemMessage(hwndDlg, 14003, BM_SETCHECK, BST_CHECKED, 0);
 918     }
 919     else
 920     {
 921         SendDlgItemMessage(hwndDlg, 14001, BM_SETCHECK, BST_CHECKED, 0);
 922         EnableWindow(GetDlgItem(hwndDlg, 14002), TRUE);
 923         SendDlgItemMessage(hwndDlg, 14003, BM_SETCHECK, BST_UNCHECKED, 0);
 924     }
 925 }
 926
 927
 928 static VOID
 929 InitializeRecycleBinDlg(HWND hwndDlg, WCHAR DefaultDrive)
 930 {
 931     WCHAR CurDrive = L'A';
 932     WCHAR szDrive[] = L"A:\\";
 933     DWORD dwDrives;
 934     WCHAR szName[100];
 935     WCHAR szVolume[100];
 936     DWORD MaxComponent, Flags;
 937     DWORD dwSerial;
 938     LVCOLUMNW lc;
 939     HWND hDlgCtrl;
 940     LVITEMW li;
 941     INT itemCount;
 942     ULARGE_INTEGER TotalNumberOfFreeBytes, TotalNumberOfBytes, FreeBytesAvailable;
 943     RECT rect;
 944     int columnSize;
 945     int defIndex = 0;
 946     DWORD dwSize;
 947     PDRIVE_ITEM_CONTEXT pItem = NULL, pDefault = NULL, pFirst = NULL;
 948
 949     hDlgCtrl = GetDlgItem(hwndDlg, 14000);
 950
 951     if (!LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_LOCATION, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
 952         szVolume[0] = 0;
 953
 954     GetClientRect(hDlgCtrl, &rect);
 955
 956     memset(&lc, 0, sizeof(LV_COLUMN) );
 957     lc.mask = LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM | LVCF_FMT;
 958
 959     columnSize = 140; //FIXME
 960     lc.iSubItem   = 0;
 961     lc.fmt = LVCFMT_FIXED_WIDTH;
 962     lc.cx         = columnSize;
 963     lc.cchTextMax = wcslen(szVolume);
 964     lc.pszText    = szVolume;
 965     (void)SendMessageW(hDlgCtrl, LVM_INSERTCOLUMNW, 0, (LPARAM)&lc);
 966
 967     if (!LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_DISKSPACE, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
 968         szVolume[0] = 0;
 969
 970     lc.iSubItem   = 1;
 971     lc.cx         = rect.right - rect.left - columnSize;
 972     lc.cchTextMax = wcslen(szVolume);
 973     lc.pszText    = szVolume;
 974     (void)SendMessageW(hDlgCtrl, LVM_INSERTCOLUMNW, 1, (LPARAM)&lc);
 975
 976     dwDrives = GetLogicalDrives();
 977     itemCount = 0;
 978     do
 979     {
 980         if ((dwDrives & 0x1))
 981         {
 982             UINT Type = GetDriveTypeW(szDrive);
 983             if (Type == DRIVE_FIXED) //FIXME
 984             {
 985                 if (!GetVolumeInformationW(szDrive, szName, sizeof(szName) / sizeof(WCHAR), &dwSerial, &MaxComponent, &Flags, NULL, 0))
 986                 {
 987                     szName[0] = 0;
 988                     dwSerial = -1;
 989                 }
 990
 991                 swprintf(szVolume, L"%s (%c)", szName, szDrive[0]);
 992                 memset(&li, 0x0, sizeof(LVITEMW));
 993                 li.mask = LVIF_TEXT | LVIF_PARAM;
 994                 li.iSubItem = 0;
 995                 li.pszText = szVolume;
 996                 li.iItem = itemCount;
 997                 SendMessageW(hDlgCtrl, LVM_INSERTITEMW, 0, (LPARAM)&li);
 998                 if (GetDiskFreeSpaceExW(szDrive, &FreeBytesAvailable , &TotalNumberOfBytes, &TotalNumberOfFreeBytes))
 999                 {
1000                     if (StrFormatByteSizeW(TotalNumberOfFreeBytes.QuadPart, szVolume, sizeof(szVolume) / sizeof(WCHAR)))
1001                     {
1002
1003                         pItem = (DRIVE_ITEM_CONTEXT *)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DRIVE_ITEM_CONTEXT));
1004                         if (pItem)
1005                         {
1006                             swprintf(szName, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume\\%04X-%04X", LOWORD(dwSerial), HIWORD(dwSerial));
1007                             dwSize = sizeof(DWORD);
1008                             RegGetValueW(HKEY_CURRENT_USER, szName, L"MaxCapacity", RRF_RT_DWORD, NULL, &pItem->dwMaxCapacity, &dwSize);
1009                             dwSize = sizeof(DWORD);
1010                             RegGetValueW(HKEY_CURRENT_USER, szName, L"NukeOnDelete", RRF_RT_DWORD, NULL, &pItem->dwNukeOnDelete, &dwSize);
1011                             pItem->dwSerial = dwSerial;
1012                             li.mask = LVIF_PARAM;
1013                             li.lParam = (LPARAM)pItem;
1014                             (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
1015                             if (CurDrive == DefaultDrive)
1016                             {
1017                                 defIndex = itemCount;
1018                                 pDefault = pItem;
1019                             }
1020                         }
1021                         if (!pFirst)
1022                             pFirst = pItem;
1023
1024                         li.mask = LVIF_TEXT;
1025                         li.iSubItem = 1;
1026                         li.pszText = szVolume;
1027                         li.iItem = itemCount;
1028                         (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
1029                     }
1030                 }
1031                 itemCount++;
1032             }
1033         }
1034         CurDrive++;
1035         szDrive[0] = CurDrive;
1036         dwDrives = (dwDrives >> 1);
1037     } while(dwDrives);
1038
1039     if (!pDefault)
1040         pDefault = pFirst;
1041     if (pDefault)
1042     {
1043         toggleNukeOnDeleteOption(hwndDlg, pDefault->dwNukeOnDelete);
1044         SetDlgItemInt(hwndDlg, 14002, pDefault->dwMaxCapacity, FALSE);
1045     }
1046     ZeroMemory(&li, sizeof(li));
1047     li.mask = LVIF_STATE;
1048     li.stateMask = (UINT) - 1;
1049     li.state = LVIS_FOCUSED | LVIS_SELECTED;
1050     li.iItem = defIndex;
1051     (void)SendMessageW(hDlgCtrl, LVM_SETITEMW, 0, (LPARAM)&li);
1052
1053 }
1054
1055 static BOOL StoreDriveSettings(HWND hwndDlg)
1056 {
1057     int iCount, iIndex;
1058     HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1059     LVITEMW li;
1060     PDRIVE_ITEM_CONTEXT pItem;
1061     HKEY hKey, hSubKey;
1062     WCHAR szSerial[20];
1063     DWORD dwSize;
1064
1065
1066     if (RegCreateKeyExW(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume", 0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL) != ERROR_SUCCESS)
1067         return FALSE;
1068
1069     iCount = ListView_GetItemCount(hDlgCtrl);
1070
1071     ZeroMemory(&li, sizeof(li));
1072     li.mask = LVIF_PARAM;
1073
1074     for(iIndex = 0; iIndex < iCount; iIndex++)
1075     {
1076         li.iItem = iIndex;
1077         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)&li))
1078         {
1079             pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1080             swprintf(szSerial, L"%04X-%04X", LOWORD(pItem->dwSerial), HIWORD(pItem->dwSerial));
1081             if (RegCreateKeyExW(hKey, szSerial, 0, NULL, 0, KEY_WRITE, NULL, &hSubKey, NULL) == ERROR_SUCCESS)
1082             {
1083                 dwSize = sizeof(DWORD);
1084                 RegSetValueExW(hSubKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&pItem->dwNukeOnDelete, dwSize);
1085                 dwSize = sizeof(DWORD);
1086                 RegSetValueExW(hSubKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&pItem->dwMaxCapacity, dwSize);
1087                 RegCloseKey(hSubKey);
1088             }
1089         }
1090     }
1091     RegCloseKey(hKey);
1092     return TRUE;
1093
1094 }
1095
1096 static VOID FreeDriveItemContext(HWND hwndDlg)
1097 {
1098     int iCount, iIndex;
1099     HWND hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1100     LVITEMW li;
1101
1102     iCount = ListView_GetItemCount(hDlgCtrl);
1103
1104     ZeroMemory(&li, sizeof(li));
1105     li.mask = LVIF_PARAM;
1106
1107     for(iIndex = 0; iIndex < iCount; iIndex++)
1108     {
1109         li.iItem = iIndex;
1110         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)&li))
1111         {
1112             HeapFree(GetProcessHeap(), 0, (LPVOID)li.lParam);
1113         }
1114     }
1115 }
1116
1117 static INT
1118 GetDefaultItem(HWND hwndDlg, LVITEMW * li)
1119 {
1120     HWND hDlgCtrl;
1121     UINT iItemCount, iIndex;
1122
1123     hDlgCtrl = GetDlgItem(hwndDlg, 14000);
1124     if (!hDlgCtrl)
1125         return -1;
1126
1127     iItemCount = ListView_GetItemCount(hDlgCtrl);
1128     if (!iItemCount)
1129         return -1;
1130
1131     ZeroMemory(li, sizeof(LVITEMW));
1132     li->mask = LVIF_PARAM | LVIF_STATE;
1133     li->stateMask = (UINT) - 1;
1134     for (iIndex = 0; iIndex < iItemCount; iIndex++)
1135     {
1136         li->iItem = iIndex;
1137         if (SendMessageW(hDlgCtrl, LVM_GETITEMW, 0, (LPARAM)li))
1138         {
1139             if (li->state & LVIS_SELECTED)
1140                 return iIndex;
1141         }
1142     }
1143     return -1;
1144
1145 }
1146
1147 static INT_PTR CALLBACK
1148 RecycleBinDlg(
1149     HWND hwndDlg,
1150     UINT uMsg,
1151     WPARAM wParam,
1152     LPARAM lParam
1153 )
1154 {
1155     LPPSHNOTIFY lppsn;
1156     LPNMLISTVIEW lppl;
1157     LVITEMW li;
1158     PDRIVE_ITEM_CONTEXT pItem;
1159     BOOL bSuccess;
1160     UINT uResult;
1161     PROPSHEETPAGE * page;
1162     DWORD dwStyle;
1163
1164     switch(uMsg)
1165     {
1166         case WM_INITDIALOG:
1167             page = (PROPSHEETPAGE*)lParam;
1168             InitializeRecycleBinDlg(hwndDlg, (WCHAR)page->lParam);
1169             dwStyle = (DWORD) SendDlgItemMessage(hwndDlg, 14000, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0);
1170             dwStyle = dwStyle | LVS_EX_FULLROWSELECT;
1171             SendDlgItemMessage(hwndDlg, 14000, LVM_SETEXTENDEDLISTVIEWSTYLE, 0, dwStyle);
1172             if (GetDlgCtrlID((HWND)wParam) != 14000)
1173             {
1174                 SetFocus(GetDlgItem(hwndDlg, 14000));
1175                 return FALSE;
1176             }
1177             return TRUE;
1178         case WM_COMMAND:
1179             switch(LOWORD(wParam))
1180             {
1181                 case 14001:
1182                     toggleNukeOnDeleteOption(hwndDlg, FALSE);
1183                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1184                     break;
1185                 case 14003:
1186                     toggleNukeOnDeleteOption(hwndDlg, TRUE);
1187                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1188                     break;
1189                 case 14004:
1190                     PropSheet_Changed(GetParent(hwndDlg), hwndDlg);
1191                     break;
1192             }
1193             break;
1194         case WM_NOTIFY:
1195             lppsn = (LPPSHNOTIFY) lParam;
1196             lppl = (LPNMLISTVIEW) lParam;
1197             if (lppsn->hdr.code == PSN_APPLY)
1198             {
1199                 if (GetDefaultItem(hwndDlg, &li) > -1)
1200                 {
1201                     pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1202                     if (pItem)
1203                     {
1204                         uResult = GetDlgItemInt(hwndDlg, 14002, &bSuccess, FALSE);
1205                         if (bSuccess)
1206                             pItem->dwMaxCapacity = uResult;
1207                         if (SendDlgItemMessageW(hwndDlg, 14003, BM_GETCHECK, 0, 0) == BST_CHECKED)
1208                             pItem->dwNukeOnDelete = TRUE;
1209                         else
1210                             pItem->dwNukeOnDelete = FALSE;
1211                     }
1212                 }
1213                 if (StoreDriveSettings(hwndDlg))
1214                 {
1215                     SetWindowLongPtr( hwndDlg, DWL_MSGRESULT, PSNRET_NOERROR );
1216                     return TRUE;
1217                 }
1218             }
1219             else if (lppl->hdr.code == LVN_ITEMCHANGING)
1220             {
1221                 ZeroMemory(&li, sizeof(li));
1222                 li.mask = LVIF_PARAM;
1223                 li.iItem = lppl->iItem;
1224                 if (!SendMessageW(lppl->hdr.hwndFrom, LVM_GETITEMW, 0, (LPARAM)&li))
1225                     return TRUE;
1226
1227                 pItem = (PDRIVE_ITEM_CONTEXT)li.lParam;
1228                 if (!pItem)
1229                     return TRUE;
1230
1231                 if (!(lppl->uOldState & LVIS_FOCUSED) && (lppl->uNewState & LVIS_FOCUSED))
1232                 {
1233                     /* new focused item */
1234                     toggleNukeOnDeleteOption(lppl->hdr.hwndFrom, pItem->dwNukeOnDelete);
1235                     SetDlgItemInt(hwndDlg, 14002, pItem->dwMaxCapacity, FALSE);
1236                 }
1237                 else if ((lppl->uOldState & LVIS_FOCUSED) && !(lppl->uNewState & LVIS_FOCUSED))
1238                 {
1239                     /* kill focus */
1240                     uResult = GetDlgItemInt(hwndDlg, 14002, &bSuccess, FALSE);
1241                     if (bSuccess)
1242                         pItem->dwMaxCapacity = uResult;
1243                     if (SendDlgItemMessageW(hwndDlg, 14003, BM_GETCHECK, 0, 0) == BST_CHECKED)
1244                         pItem->dwNukeOnDelete = TRUE;
1245                     else
1246                         pItem->dwNukeOnDelete = FALSE;
1247                 }
1248                 return TRUE;
1249
1250             }
1251             break;
1252         case WM_DESTROY:
1253             FreeDriveItemContext(hwndDlg);
1254             break;
1255     }
1256     return FALSE;
1257 }
1258
1259 BOOL SH_ShowRecycleBinProperties(WCHAR sDrive)
1260 {
1261     HPROPSHEETPAGE hpsp[1];
1262     PROPSHEETHEADERW psh;
1263     HPROPSHEETPAGE hprop;
1264
1265     BOOL ret;
1266
1267
1268     ZeroMemory(&psh, sizeof(PROPSHEETHEADERW));
1269     psh.dwSize = sizeof(PROPSHEETHEADERW);
1270     psh.dwFlags = PSP_DEFAULT | PSH_PROPTITLE;
1271     psh.pszCaption = MAKEINTRESOURCEW(IDS_RECYCLEBIN_FOLDER_NAME);
1272     psh.hwndParent = NULL;
1273     psh.phpage = hpsp;
1274     psh.hInstance = shell32_hInstance;
1275
1276     hprop = SH_CreatePropertySheetPage(IDD_RECYCLE_BIN_PROPERTIES, RecycleBinDlg, (LPARAM)sDrive, NULL);
1277     if (!hprop)
1278     {
1279         ERR("Failed to create property sheet\n");
1280         return FALSE;
1281     }
1282     hpsp[psh.nPages] = hprop;
1283     psh.nPages++;
1284
1285
1286     ret = PropertySheetW(&psh);
1287     if (ret < 0)
1288         return FALSE;
1289     else
1290         return TRUE;
1291 }
1292
1293 BOOL
1294 TRASH_CanTrashFile(LPCWSTR wszPath)
1295 {
1296     LONG ret;
1297     DWORD dwNukeOnDelete, dwType, VolSerialNumber, MaxComponentLength;
1298     DWORD FileSystemFlags, dwSize, dwDisposition;
1299     HKEY hKey;
1300     WCHAR szBuffer[10];
1301     WCHAR szKey[150] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\Bitbucket\\Volume\\";
1302
1303     if (wszPath[1] != L':')
1304     {
1305         /* path is UNC */
1306         return FALSE;
1307     }
1308
1309     if (GetDriveTypeW(wszPath) != DRIVE_FIXED)
1310     {
1311         /* no bitbucket on removable media */
1312         return FALSE;
1313     }
1314
1315     if (!GetVolumeInformationW(wszPath, NULL, 0, &VolSerialNumber, &MaxComponentLength, &FileSystemFlags, NULL, 0))
1316     {
1317         ERR("GetVolumeInformationW failed with %u\n", GetLastError());
1318         return FALSE;
1319     }
1320
1321     swprintf(szBuffer, L"%04X-%04X", LOWORD(VolSerialNumber), HIWORD(VolSerialNumber));
1322     wcscat(szKey, szBuffer);
1323
1324     if (RegCreateKeyExW(HKEY_CURRENT_USER, szKey, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition) != ERROR_SUCCESS)
1325     {
1326         ERR("RegCreateKeyExW failed\n");
1327         return FALSE;
1328     }
1329
1330     if (dwDisposition  & REG_CREATED_NEW_KEY)
1331     {
1332         /* per default move to bitbucket */
1333         dwNukeOnDelete = 0;
1334         RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
1335         /* per default unlimited size */
1336         dwSize = -1;
1337         RegSetValueExW(hKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
1338         RegCloseKey(hKey);
1339         return TRUE;
1340     }
1341     else
1342     {
1343         dwSize = sizeof(dwNukeOnDelete);
1344         ret = RegQueryValueExW(hKey, L"NukeOnDelete", NULL, &dwType, (LPBYTE)&dwNukeOnDelete, &dwSize);
1345         if (ret != ERROR_SUCCESS)
1346         {
1347             if (ret ==  ERROR_FILE_NOT_FOUND)
1348             {
1349                 /* restore key and enable bitbucket */
1350                 dwNukeOnDelete = 0;
1351                 RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
1352             }
1353             RegCloseKey(hKey);
1354             return TRUE;
1355         }
1356         else if (dwNukeOnDelete)
1357         {
1358             /* do not delete to bitbucket */
1359             RegCloseKey(hKey);
1360             return FALSE;
1361         }
1362         /* FIXME
1363          * check if bitbucket is full
1364          */
1365         RegCloseKey(hKey);
1366         return TRUE;
1367     }
1368 }
1369
1370 BOOL
1371 TRASH_TrashFile(LPCWSTR wszPath)
1372 {
1373     TRACE("(%s)\n", debugstr_w(wszPath));
1374     return DeleteFileToRecycleBin(wszPath);
1375 }
1376
1377 /*************************************************************************
1378  * SHUpdateCRecycleBinIcon                                [SHELL32.@]
1379  *
1380  * Undocumented
1381  */
1382 EXTERN_C HRESULT WINAPI SHUpdateRecycleBinIcon(void)
1383 {
1384     FIXME("stub\n");
1385
1386
1387
1388     return S_OK;
1389 }
1390
1391 /****************************************************************************
1392  * IDropTarget implementation
1393  */
1394 BOOL CRecycleBin::QueryDrop(DWORD dwKeyState, LPDWORD pdwEffect)
1395 {
1396     /* TODO on shift we should delete, we should update the cursor manager to show this. */
1397
1398     DWORD dwEffect = DROPEFFECT_COPY;
1399
1400     *pdwEffect = DROPEFFECT_NONE;
1401
1402     if (fAcceptFmt) { /* Does our interpretation of the keystate ... */
1403         *pdwEffect = KeyStateToDropEffect (dwKeyState);
1404
1405         if (*pdwEffect == DROPEFFECT_NONE)
1406             *pdwEffect = dwEffect;
1407
1408         /* ... matches the desired effect ? */
1409         if (dwEffect & *pdwEffect) {
1410             return TRUE;
1411         }
1412     }
1413     return FALSE;
1414 }
1415
1416 HRESULT WINAPI CRecycleBin::DragEnter(IDataObject *pDataObject,
1417                                     DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
1418 {
1419     TRACE("Recycle bin drag over (%p)\n", this);
1420     /* The recycle bin accepts pretty much everything, and sets a CSIDL flag. */
1421     fAcceptFmt = TRUE;
1422
1423     QueryDrop(dwKeyState, pdwEffect);
1424     return S_OK;
1425 }
1426
1427 HRESULT WINAPI CRecycleBin::DragOver(DWORD dwKeyState, POINTL pt,
1428                                    DWORD *pdwEffect)
1429 {
1430     TRACE("(%p)\n", this);
1431
1432     if (!pdwEffect)
1433         return E_INVALIDARG;
1434
1435     QueryDrop(dwKeyState, pdwEffect);
1436
1437     return S_OK;
1438 }
1439
1440 HRESULT WINAPI CRecycleBin::DragLeave()
1441 {
1442     TRACE("(%p)\n", this);
1443
1444     fAcceptFmt = FALSE;
1445
1446     return S_OK;
1447 }
1448
1449 HRESULT WINAPI CRecycleBin::Drop(IDataObject *pDataObject,
1450                                DWORD dwKeyState, POINTL pt, DWORD *pdwEffect)
1451 {
1452     TRACE("(%p) object dropped on recycle bin, effect %u\n", this, *pdwEffect);
1453
1454     /* TODO: pdwEffect should be read and make the drop object be permanently deleted in the move case (shift held) */
1455
1456     FORMATETC fmt;
1457     TRACE("(%p)->(DataObject=%p)\n", this, pDataObject);
1458     InitFormatEtc (fmt, cfShellIDList, TYMED_HGLOBAL);
1459
1460     /* Handle cfShellIDList Drop objects here, otherwise send the approriate message to other software */
1461     if (SUCCEEDED(pDataObject->QueryGetData(&fmt))) {
1462         pDataObject->AddRef();
1463         SHCreateThread(DoDeleteThreadProc, pDataObject, NULL, NULL);
1464     }
1465     else
1466     {
1467         /*
1468          * TODO call SetData on the data object with format CFSTR_TARGETCLSID
1469          * set to the Recycle Bin's class identifier CLSID_RecycleBin.
1470          */
1471     }
1472     return S_OK;
1473 }
1474
1475 DWORD WINAPI DoDeleteThreadProc(LPVOID lpParameter)
1476 {
1477     IDataObject *pda = (IDataObject*) lpParameter;
1478     DoDeleteDataObject(pda);
1479     //Release the data object
1480     pda->Release();
1481     return 0;
1482 }
1483
1484 HRESULT WINAPI DoDeleteDataObject(IDataObject *pda)
1485 {
1486     TRACE("performing delete");
1487     HRESULT hr;
1488
1489     STGMEDIUM medium;
1490     FORMATETC formatetc;
1491     InitFormatEtc(formatetc, RegisterClipboardFormatW(CFSTR_SHELLIDLIST), TYMED_HGLOBAL);
1492     hr = pda->GetData(&formatetc, &medium);
1493     if (FAILED(hr))
1494         return hr;
1495
1496     /* lock the handle */
1497     LPIDA lpcida = (LPIDA)GlobalLock(medium.hGlobal);
1498     if (!lpcida)
1499     {
1500         ReleaseStgMedium(&medium);
1501         return E_FAIL;
1502     }
1503
1504     /* convert the data into pidl */
1505     LPITEMIDLIST pidl;
1506     LPITEMIDLIST *apidl = _ILCopyCidaToaPidl(&pidl, lpcida);
1507     if (!apidl)
1508     {
1509         ReleaseStgMedium(&medium);
1510         return E_FAIL;
1511     }
1512
1513     CComPtr<IShellFolder> psfDesktop;
1514     CComPtr<IShellFolder> psfFrom = NULL;
1515
1516     /* Grab the desktop shell folder */
1517     hr = SHGetDesktopFolder(&psfDesktop);
1518     if (FAILED(hr))
1519     {
1520         ERR("SHGetDesktopFolder failed\n");
1521         SHFree(pidl);
1522         _ILFreeaPidl(apidl, lpcida->cidl);
1523         ReleaseStgMedium(&medium);
1524         return E_FAIL;
1525     }
1526
1527     /* Find source folder, this is where the clipboard data was copied from */
1528     if (_ILIsDesktop(pidl))
1529     {
1530         psfFrom = psfDesktop;
1531     }
1532     else
1533     {
1534         hr = psfDesktop->BindToObject(pidl, NULL, IID_IShellFolder, (LPVOID*)&psfFrom);
1535         if (FAILED(hr))
1536         {
1537             ERR("no IShellFolder\n");
1538             SHFree(pidl);
1539             _ILFreeaPidl(apidl, lpcida->cidl);
1540             ReleaseStgMedium(&medium);
1541             return E_FAIL;
1542         }
1543     }
1544
1545     STRRET strTemp;
1546     hr = psfFrom->GetDisplayNameOf(apidl[0], SHGDN_FORPARSING, &strTemp);
1547     if (FAILED(hr))
1548     {
1549         ERR("IShellFolder_GetDisplayNameOf failed with %x\n", hr);
1550         SHFree(pidl);
1551         _ILFreeaPidl(apidl, lpcida->cidl);
1552         ReleaseStgMedium(&medium);
1553         return hr;
1554     }
1555
1556     WCHAR wszPath[MAX_PATH];
1557     hr = StrRetToBufW(&strTemp, apidl[0], wszPath, _countof(wszPath));
1558     if (FAILED(hr))
1559     {
1560         ERR("StrRetToBufW failed with %x\n", hr);
1561         SHFree(pidl);
1562         _ILFreeaPidl(apidl, lpcida->cidl);
1563         ReleaseStgMedium(&medium);
1564         return hr;
1565     }
1566
1567     /* Only keep the base path */
1568     LPWSTR pwszFilename = PathFindFileNameW(wszPath);
1569     *pwszFilename = L'\0';
1570
1571     /* Build paths list */
1572     LPWSTR pwszPaths = BuildPathsList(wszPath, lpcida->cidl, (LPCITEMIDLIST*) apidl);
1573     if (!pwszPaths)
1574     {
1575         SHFree(pidl);
1576         _ILFreeaPidl(apidl, lpcida->cidl);
1577         ReleaseStgMedium(&medium);
1578         return E_FAIL;
1579     }
1580
1581     /* Delete them */
1582     SHFILEOPSTRUCTW FileOp;
1583     ZeroMemory(&FileOp, sizeof(FileOp));
1584     FileOp.wFunc = FO_DELETE;
1585     FileOp.pFrom = pwszPaths;
1586     FileOp.fFlags = FOF_ALLOWUNDO;
1587
1588     if (SHFileOperationW(&FileOp) != 0)
1589     {
1590         ERR("SHFileOperation failed with 0x%x for %s\n", GetLastError(), debugstr_w(pwszPaths));
1591         hr = E_FAIL;
1592     }
1593
1594     HeapFree(GetProcessHeap(), 0, pwszPaths);
1595     SHFree(pidl);
1596     _ILFreeaPidl(apidl, lpcida->cidl);
1597     ReleaseStgMedium(&medium);
1598
1599     return hr;
1600 }