ReactOS  0.4.15-dev-1200-gc3b3fcd
CRecycleBin.cpp
Go to the documentation of this file.
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  * Copyright (C) 2018 Russell Johnson
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22 
23 #include <precomp.h>
24 
25 #include <mmsystem.h>
26 #include <ntquery.h>
27 
29 
30 typedef struct
31 {
33  const GUID *fmtId;
35  int pcsFlags;
36  int fmt;
37  int cxChars;
38 } columninfo;
39 
40 static const columninfo RecycleBinColumns[] =
41 {
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 
66 {
67  CComPtr<IDefaultExtractIconInit> initIcon;
70  return hr;
71 
72  /* FIXME: This is completely unimplemented */
73  initIcon->SetNormalIcon(swShell32Name, 0);
74 
75  return initIcon->QueryInterface(riid, ppvOut);
76 }
77 
79  public CEnumIDListBase
80 {
81  private:
82  public:
86  static BOOL WINAPI CBEnumRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile);
87  BOOL WINAPI CBEnumRecycleBin(IN HANDLE hDeletedFile);
88 
90  COM_INTERFACE_ENTRY_IID(IID_IEnumIDList, IEnumIDList)
91  END_COM_MAP()
92 };
93 
95  public CComObjectRootEx<CComMultiThreadModelNoCS>,
96  public IContextMenu2
97 {
98  private:
100  public:
104 
105  // IContextMenu
106  virtual HRESULT WINAPI QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags);
108  virtual HRESULT WINAPI GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen);
109 
110  // IContextMenu2
112 
114  COM_INTERFACE_ENTRY_IID(IID_IContextMenu, IContextMenu)
115  COM_INTERFACE_ENTRY_IID(IID_IContextMenu2, IContextMenu2)
116  END_COM_MAP()
117 };
118 
119 typedef struct
120 {
121  PIDLRecycleStruct *pFileDetails;
125 
127 {
129 
130  PDELETED_FILE_DETAILS_W pFileDetails;
131  DWORD dwSize;
132  BOOL ret;
133 
134  if (!GetDeletedFileDetailsW(hDeletedFile,
135  0,
136  NULL,
137  &dwSize) &&
139  {
140  ERR("GetDeletedFileDetailsW failed\n");
141  return FALSE;
142  }
143 
144  pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
145  if (!pFileDetails)
146  {
147  ERR("No memory\n");
148  return FALSE;
149  }
150 
151  if (!GetDeletedFileDetailsW(hDeletedFile,
152  dwSize,
153  pFileDetails,
154  NULL))
155  {
156  ERR("GetDeletedFileDetailsW failed\n");
157  SHFree(pFileDetails);
158  return FALSE;
159  }
160 
161  ret = memcmp(pFileDetails, pContext->pFileDetails, dwSize);
162  if (!ret)
163  {
164  pContext->hDeletedFile = hDeletedFile;
165  pContext->bFound = TRUE;
166  }
167  else
168  CloseRecycleBinHandle(hDeletedFile);
169 
170  SHFree(pFileDetails);
171  return ret;
172 }
173 
174 static PIDLRecycleStruct * _ILGetRecycleStruct(LPCITEMIDLIST pidl)
175 {
177 
178  if (pdata && pdata->type == 0x00)
179  return (PIDLRecycleStruct*) & (pdata->u.crecycle);
180 
181  return NULL;
182 }
183 
185 {
186 }
187 
189 {
190 }
191 
193 {
194  WCHAR szDrive[8];
195  if (!GetEnvironmentVariableW(L"SystemDrive", szDrive, _countof(szDrive) - 1))
196  {
197  ERR("GetEnvironmentVariableW failed\n");
198  return E_FAIL;
199  }
200  PathAddBackslashW(szDrive);
201 
202  if (dwFlags & SHCONTF_NONFOLDERS)
203  {
204  TRACE("Starting Enumeration\n");
205 
206  if (!EnumerateRecycleBinW(szDrive, CBEnumRecycleBin, this))
207  {
208  WARN("Error: EnumerateCRecycleBinW failed\n");
209  return E_FAIL;
210  }
211  }
212  else
213  {
214  // do nothing
215  }
216  return S_OK;
217 }
218 
220 {
221  PIDLDATA tmp;
222  LPITEMIDLIST pidl;
223  PIDLRecycleStruct * p;
224  int size0 = (char*)&tmp.u.crecycle.szName - (char*)&tmp.u.crecycle;
225  int size = size0;
226 
227  tmp.type = 0x00;
228  size += (wcslen(pFileDetails->FileName) + 1) * sizeof(WCHAR);
229 
230  pidl = (LPITEMIDLIST)SHAlloc(size + 4);
231  if (!pidl)
232  return pidl;
233 
234  pidl->mkid.cb = size + 2;
235  memcpy(pidl->mkid.abID, &tmp, 2 + size0);
236 
237  p = &((PIDLDATA*)pidl->mkid.abID)->u.crecycle;
238  RtlCopyMemory(p, pFileDetails, sizeof(DELETED_FILE_DETAILS_W));
239  wcscpy(p->szName, pFileDetails->FileName);
240  *(WORD*)((char*)pidl + (size + 2)) = 0;
241  return pidl;
242 }
243 
245 {
246  return static_cast<CRecycleBinEnum *>(Context)->CBEnumRecycleBin(hDeletedFile);
247 }
248 
250 {
251  PDELETED_FILE_DETAILS_W pFileDetails;
252  DWORD dwSize;
253  LPITEMIDLIST pidl = NULL;
254  BOOL ret;
255 
256  if (!GetDeletedFileDetailsW(hDeletedFile,
257  0,
258  NULL,
259  &dwSize) &&
261  {
262  ERR("GetDeletedFileDetailsW failed\n");
263  return FALSE;
264  }
265 
266  pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
267  if (!pFileDetails)
268  {
269  ERR("No memory\n");
270  return FALSE;
271  }
272 
273  if (!GetDeletedFileDetailsW(hDeletedFile,
274  dwSize,
275  pFileDetails,
276  NULL))
277  {
278  ERR("GetDeletedFileDetailsW failed\n");
279  SHFree(pFileDetails);
280  return FALSE;
281  }
282 
283  pidl = _ILCreateRecycleItem(pFileDetails);
284  if (!pidl)
285  {
286  SHFree(pFileDetails);
287  return FALSE;
288  }
289 
290  ret = AddToEnumList(pidl);
291 
292  if (!ret)
293  SHFree(pidl);
294  SHFree(pFileDetails);
295  TRACE("Returning %d\n", ret);
296  CloseRecycleBinHandle(hDeletedFile);
297  return ret;
298 }
299 
300 /**************************************************************************
301 * IContextMenu2 Bitbucket Item Implementation
302 */
303 
305 {
306  apidl = NULL;
307 }
308 
310 {
311  ILFree(apidl);
312 }
313 
315 {
316  apidl = ILClone(pidl);
317  if (apidl == NULL)
318  return E_OUTOFMEMORY;
319  return S_OK;
320 }
321 
323 {
324  WCHAR szBuffer[30] = {0};
325  ULONG Count = 1;
326 
327  TRACE("(%p)->(hmenu=%p indexmenu=%x cmdfirst=%x cmdlast=%x flags=%x )\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
328 
329  if (LoadStringW(shell32_hInstance, IDS_RESTORE, szBuffer, _countof(szBuffer)))
330  {
331  szBuffer[_countof(szBuffer)-1] = L'\0';
332  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_ENABLED);
333  Count++;
334  }
335 
336  if (LoadStringW(shell32_hInstance, IDS_CUT, szBuffer, _countof(szBuffer)))
337  {
338  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
339  szBuffer[_countof(szBuffer)-1] = L'\0';
340  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
341  }
342 
343  if (LoadStringW(shell32_hInstance, IDS_DELETE, szBuffer, _countof(szBuffer)))
344  {
345  szBuffer[_countof(szBuffer)-1] = L'\0';
346  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
347  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
348  }
349 
350  if (LoadStringW(shell32_hInstance, IDS_PROPERTIES, szBuffer, _countof(szBuffer)))
351  {
352  szBuffer[_countof(szBuffer)-1] = L'\0';
353  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
354  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_DEFAULT);
355  }
356 
357  return MAKE_HRESULT(SEVERITY_SUCCESS, 0, Count);
358 }
359 
361 {
363  WCHAR szDrive[8];
364 
365  TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd);
366 
367  if (lpcmi->lpVerb == MAKEINTRESOURCEA(1) || lpcmi->lpVerb == MAKEINTRESOURCEA(5))
368  {
369  Context.pFileDetails = _ILGetRecycleStruct(apidl);
370  Context.bFound = FALSE;
371 
372  if (!GetEnvironmentVariableW(L"SystemDrive", szDrive, _countof(szDrive) - 1))
373  {
374  ERR("GetEnvironmentVariableW failed\n");
375  return E_FAIL;
376  }
377  PathAddBackslashW(szDrive);
378 
380  if (!Context.bFound)
381  return E_FAIL;
382 
383  if (lpcmi->lpVerb == MAKEINTRESOURCEA(1))
384  {
385  /* restore file */
386  if (RestoreFile(Context.hDeletedFile))
387  return S_OK;
388  else
389  return E_FAIL;
390  }
391  else
392  {
394  return E_NOTIMPL;
395  }
396  }
397  else if (lpcmi->lpVerb == MAKEINTRESOURCEA(3))
398  {
399  FIXME("implement cut\n");
400  return E_NOTIMPL;
401  }
402  else if (lpcmi->lpVerb == MAKEINTRESOURCEA(7))
403  {
404  FIXME("implement properties\n");
405  return E_NOTIMPL;
406  }
407 
408  return S_OK;
409 }
410 
412 {
413  TRACE("(%p)->(idcom=%lx flags=%x %p name=%p len=%x)\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
414 
415  return E_FAIL;
416 }
417 
419 {
420  TRACE("CRecycleBin_IContextMenu2Item_HandleMenuMsg (%p)->(msg=%x wp=%lx lp=%lx)\n", this, uMsg, wParam, lParam);
421 
422  return E_NOTIMPL;
423 }
424 
426 {
427  pidl = NULL;
428 }
429 
431 {
432  SHFree(pidl);
433 }
434 
435 /*************************************************************************
436  * RecycleBin IPersistFolder2 interface
437  */
438 
440 {
441  TRACE("(%p, %p)\n", this, pClassID);
442  if (pClassID == NULL)
443  return E_INVALIDARG;
444  memcpy(pClassID, &CLSID_RecycleBin, sizeof(CLSID));
445  return S_OK;
446 }
447 
449 {
450  TRACE("(%p, %p)\n", this, pidl);
451 
452  SHFree((LPVOID)this->pidl);
453  this->pidl = ILClone(pidl);
454  if (this->pidl == NULL)
455  return E_OUTOFMEMORY;
456  return S_OK;
457 }
458 
460 {
461  TRACE("\n");
462  *ppidl = ILClone(pidl);
463  return S_OK;
464 }
465 
466 /*************************************************************************
467  * RecycleBin IShellFolder2 interface
468  */
469 
471  LPOLESTR pszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl,
472  ULONG *pdwAttributes)
473 {
474  FIXME("stub\n");
475  return E_NOTIMPL;
476 }
477 
478 
481 {
482  return (PDELETED_FILE_DETAILS_W)&pidl->mkid.abID;
483 }
484 
485 HRESULT WINAPI CRecycleBin::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
486 {
487  return ShellObjectCreatorInit<CRecycleBinEnum>(dwFlags, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
488 }
489 
491 {
492  FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
493  return E_NOTIMPL;
494 }
495 
497 {
498  FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
499  return E_NOTIMPL;
500 }
501 
503 {
504  PIDLRecycleStruct* pData1 = _ILGetRecycleStruct(pidl1);
505  PIDLRecycleStruct* pData2 = _ILGetRecycleStruct(pidl2);
506  LPWSTR pName1, pName2;
507 
508  if(!pData1 || !pData2 || LOWORD(lParam) >= COLUMNS_COUNT)
509  return E_INVALIDARG;
510 
511  SHORT result;
512  LONGLONG diff;
513  switch (LOWORD(lParam))
514  {
515  case 0: /* Name */
516  pName1 = PathFindFileNameW(pData1->szName);
517  pName2 = PathFindFileNameW(pData2->szName);
518  result = wcsicmp(pName1, pName2);
519  break;
520  case 1: /* Orig. Location */
521  result = wcsicmp(pData1->szName, pData2->szName);
522  break;
523  case 2: /* Date Deleted */
524  result = CompareFileTime(&pData1->DeletionTime, &pData2->DeletionTime);
525  break;
526  case 3: /* Size */
527  diff = pData1->FileSize.QuadPart - pData2->FileSize.QuadPart;
528  return MAKE_COMPARE_HRESULT(diff);
529  case 4: /* Type */
530  pName1 = PathFindExtensionW(pData1->szName);
531  pName2 = PathFindExtensionW(pData2->szName);
532  result = wcsicmp(pName1, pName2);
533  break;
534  case 5: /* Modified */
535  result = CompareFileTime(&pData1->LastModification, &pData2->LastModification);
536  break;
537  }
539 }
540 
542 {
543  CComPtr<IShellView> pShellView;
545 
546  TRACE("(%p, %p, %s, %p)\n", this, hwndOwner, debugstr_guid(&riid), ppv);
547 
548  if (!ppv)
549  return hr;
550 
551  *ppv = NULL;
552 
553  if (IsEqualIID (riid, IID_IDropTarget))
554  {
556  }
557  else if (IsEqualIID (riid, IID_IContextMenu) || IsEqualIID (riid, IID_IContextMenu2))
558  {
559  hr = this->QueryInterface(riid, ppv);
560  }
561  else if (IsEqualIID (riid, IID_IShellView))
562  {
563  SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this};
564  hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppv);
565  }
566  else
567  return hr;
568 
569  TRACE ("-- (%p)->(interface=%p)\n", this, ppv);
570  return hr;
571 
572 }
573 
575  SFGAOF *rgfInOut)
576 {
577  TRACE("(%p, %d, {%p, ...}, {%x})\n", this, cidl, apidl ? apidl[0] : NULL, (unsigned int)*rgfInOut);
578  *rgfInOut &= SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK;
579  return S_OK;
580 }
581 
583  REFIID riid, UINT *prgfInOut, void **ppv)
584 {
585  LPVOID pObj = NULL;
587 
588  TRACE ("(%p)->(%p,%u,apidl=%p, %p %p)\n", this,
589  hwndOwner, cidl, apidl, prgfInOut, ppv);
590 
591  if (!ppv)
592  return hr;
593 
594  *ppv = NULL;
595 
596  if ((IsEqualIID (riid, IID_IContextMenu) || IsEqualIID(riid, IID_IContextMenu2)) && (cidl >= 1))
597  {
598  hr = ShellObjectCreatorInit<CRecycleBinItemContextMenu>(apidl[0], riid, &pObj);
599  }
600  else if((IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) && (cidl == 1))
601  {
602  hr = CRecyclerExtractIcon_CreateInstance(apidl[0], riid, &pObj);
603  }
604  else
605  hr = E_NOINTERFACE;
606 
607  if (SUCCEEDED(hr) && !pObj)
608  hr = E_OUTOFMEMORY;
609 
610  *ppv = pObj;
611  TRACE ("(%p)->hr=0x%08x\n", this, hr);
612  return hr;
613 }
614 
616 {
617  PIDLRecycleStruct *pFileDetails;
618  LPWSTR pFileName;
619 
620  TRACE("(%p, %p, %x, %p)\n", this, pidl, (unsigned int)uFlags, pName);
621 
622  pFileDetails = _ILGetRecycleStruct(pidl);
623  if (!pFileDetails)
624  {
625  pName->cStr[0] = 0;
626  pName->uType = STRRET_CSTR;
627  return E_INVALIDARG;
628  }
629 
630  pFileName = wcsrchr(pFileDetails->szName, L'\\');
631  if (!pFileName)
632  {
633  pName->cStr[0] = 0;
634  pName->uType = STRRET_CSTR;
635  return E_UNEXPECTED;
636  }
637 
638  pName->pOleStr = StrDupW(pFileName + 1);
639  if (pName->pOleStr == NULL)
640  return E_OUTOFMEMORY;
641 
642  pName->uType = STRRET_WSTR;
643  return S_OK;
644 }
645 
647  SHGDNF uFlags, PITEMID_CHILD *ppidlOut)
648 {
649  TRACE("\n");
650  return E_FAIL; /* not supported */
651 }
652 
654 {
655  FIXME("stub\n");
656  return E_NOTIMPL;
657 }
658 
660 {
661  FIXME("stub\n");
662  *ppEnum = NULL;
663  return E_NOTIMPL;
664 }
665 
667 {
668  TRACE("(%p, %x, %p, %p)\n", this, (unsigned int)dwReserved, pSort, pDisplay);
669  if (pSort)
670  *pSort = 0;
671  if (pDisplay)
672  *pDisplay = 0;
673  return S_OK;
674 }
675 
677 {
678  TRACE("(%p, %d, %p)\n", this, iColumn, pcsFlags);
679  if (iColumn >= COLUMNS_COUNT)
680  return E_INVALIDARG;
681  *pcsFlags = RecycleBinColumns[iColumn].pcsFlags;
682  return S_OK;
683 }
684 
686 {
687  FIXME("stub\n");
688  return E_NOTIMPL;
689 }
690 
692 {
693  FILETIME lft;
695  int ret;
696 
697  FileTimeToLocalFileTime(ft, &lft);
698  FileTimeToSystemTime(&lft, &time);
699 
701  if (ret > 0 && ret < size)
702  {
703  /* Append space + time without seconds */
704  buffer[ret-1] = ' ';
706  }
707 
708  return (ret != 0 ? E_FAIL : S_OK);
709 }
710 
712 {
713  PIDLRecycleStruct * pFileDetails;
715  WCHAR szTypeName[100];
716  LPWSTR pszBackslash;
717  UINT Length;
718 
719  TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, pDetails);
720  if (iColumn >= COLUMNS_COUNT)
721  return E_FAIL;
722  pDetails->fmt = RecycleBinColumns[iColumn].fmt;
723  pDetails->cxChar = RecycleBinColumns[iColumn].cxChars;
724  if (pidl == NULL)
725  return SHSetStrRet(&pDetails->str, RecycleBinColumns[iColumn].column_name_id);
726 
727  if (iColumn == COLUMN_NAME)
728  return GetDisplayNameOf(pidl, SHGDN_NORMAL, &pDetails->str);
729 
730  pFileDetails = _ILGetRecycleStruct(pidl);
731  switch (iColumn)
732  {
733  case COLUMN_DATEDEL:
734  FormatDateTime(buffer, MAX_PATH, &pFileDetails->DeletionTime);
735  break;
736  case COLUMN_DELFROM:
737  pszBackslash = wcsrchr(pFileDetails->szName, L'\\');
738  Length = (pszBackslash - pFileDetails->szName);
739  memcpy((LPVOID)buffer, pFileDetails->szName, Length * sizeof(WCHAR));
740  buffer[Length] = L'\0';
741  break;
742  case COLUMN_SIZE:
743  StrFormatKBSizeW(pFileDetails->FileSize.QuadPart, buffer, MAX_PATH);
744  break;
745  case COLUMN_MTIME:
746  FormatDateTime(buffer, MAX_PATH, &pFileDetails->LastModification);
747  break;
748  case COLUMN_TYPE:
749  // FIXME: We should in fact use a UNICODE version of _ILGetFileType
750  szTypeName[0] = L'\0';
751  wcscpy(buffer, PathFindExtensionW(pFileDetails->szName));
754  {
755  /* load localized file string */
756  szTypeName[0] = '\0';
758  {
759  szTypeName[63] = '\0';
761  }
762  }
763  return SHSetStrRet(&pDetails->str, szTypeName);
764  default:
765  return E_FAIL;
766  }
767 
768  return SHSetStrRet(&pDetails->str, buffer);
769 }
770 
772 {
773  TRACE("(%p, %d, %p)\n", this, iColumn, pscid);
774  if (iColumn >= COLUMNS_COUNT)
775  return E_INVALIDARG;
776  pscid->fmtid = *RecycleBinColumns[iColumn].fmtId;
777  pscid->pid = RecycleBinColumns[iColumn].pid;
778  return S_OK;
779 }
780 
782 {
783  CComPtr<IEnumIDList> spEnumFiles;
785  if (FAILED(hr))
786  return TRUE;
787  CComHeapPtr<ITEMIDLIST> spPidl;
788  ULONG itemcount;
789  return spEnumFiles->Next(1, &spPidl, &itemcount) != S_OK;
790  }
791 
792 /*************************************************************************
793  * RecycleBin IContextMenu interface
794  */
795 
796 HRESULT WINAPI CRecycleBin::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
797 {
798  WCHAR szBuffer[100];
799  MENUITEMINFOW mii;
800  int id = 1;
801 
802  TRACE("QueryContextMenu %p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
803 
804  if (!hMenu)
805  return E_INVALIDARG;
806 
807  ZeroMemory(&mii, sizeof(mii));
808  mii.cbSize = sizeof(mii);
809  mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
811  szBuffer[0] = L'\0';
813  mii.dwTypeData = szBuffer;
814  mii.cch = wcslen(mii.dwTypeData);
815  mii.wID = idCmdFirst + id++;
816  mii.fType = MFT_STRING;
817  iIdEmpty = 1;
818 
819  if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
820  return E_FAIL;
821 
822  return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
823 }
824 
826 {
827  HRESULT hr;
828  LPSHELLBROWSER lpSB;
829  IShellView * lpSV = NULL;
830  WCHAR szDrive[8];
831 
832  TRACE("%p %p verb %p\n", this, lpcmi, lpcmi->lpVerb);
833 
834  if (LOWORD(lpcmi->lpVerb) == iIdEmpty)
835  {
836  if (!GetEnvironmentVariableW(L"SystemDrive", szDrive, _countof(szDrive) - 1))
837  {
838  ERR("GetEnvironmentVariableW failed\n");
839  return E_FAIL;
840  }
841  PathAddBackslashW(szDrive);
842 
843  hr = SHEmptyRecycleBinW(lpcmi->hwnd, szDrive, 0);
844  TRACE("result %x\n", hr);
845  if (hr != S_OK)
846  return hr;
847 
848  lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0);
849  if (lpSB && SUCCEEDED(lpSB->QueryActiveShellView(&lpSV)))
850  lpSV->Refresh();
851  }
852  return S_OK;
853 }
854 
855 HRESULT WINAPI CRecycleBin::GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
856 {
857  FIXME("%p %lu %u %p %p %u\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
858 
859  return E_NOTIMPL;
860 }
861 
862 /*************************************************************************
863  * RecycleBin IShellPropSheetExt interface
864  */
865 
867 {
868  FIXME("%p %p %lu\n", this, pfnAddPage, lParam);
869 
870  return E_NOTIMPL;
871 }
872 
874 {
875  FIXME("%p %lu %p %lu\n", this, uPageID, pfnReplaceWith, lParam);
876 
877  return E_NOTIMPL;
878 }
879 
880 /*************************************************************************
881  * RecycleBin IShellExtInit interface
882  */
883 
885 {
886  TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID );
887  return S_OK;
888 }
889 
895 BOOL
897 {
898  LONG ret;
899  DWORD dwNukeOnDelete, dwType, VolSerialNumber, MaxComponentLength;
900  DWORD FileSystemFlags, dwSize, dwDisposition;
901  HKEY hKey;
902  WCHAR szBuffer[10];
903  WCHAR szKey[150] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket\\Volume\\";
904 
905  if (wszPath[1] != L':')
906  {
907  /* path is UNC */
908  return FALSE;
909  }
910 
911  // Copy and retrieve the root path from get given string
912  WCHAR wszRootPathName[MAX_PATH];
913  StringCbCopyW(wszRootPathName, sizeof(wszRootPathName), wszPath);
914  PathStripToRootW(wszRootPathName);
915 
916  // Test to see if the drive is fixed (non removable)
917  if (GetDriveTypeW(wszRootPathName) != DRIVE_FIXED)
918  {
919  /* no bitbucket on removable media */
920  return FALSE;
921  }
922 
923  if (!GetVolumeInformationW(wszRootPathName, NULL, 0, &VolSerialNumber, &MaxComponentLength, &FileSystemFlags, NULL, 0))
924  {
925  ERR("GetVolumeInformationW failed with %u wszRootPathName=%s\n", GetLastError(), debugstr_w(wszRootPathName));
926  return FALSE;
927  }
928 
929  swprintf(szBuffer, L"%04X-%04X", LOWORD(VolSerialNumber), HIWORD(VolSerialNumber));
930  wcscat(szKey, szBuffer);
931 
932  if (RegCreateKeyExW(HKEY_CURRENT_USER, szKey, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition) != ERROR_SUCCESS)
933  {
934  ERR("RegCreateKeyExW failed\n");
935  return FALSE;
936  }
937 
938  if (dwDisposition & REG_CREATED_NEW_KEY)
939  {
940  /* per default move to bitbucket */
941  dwNukeOnDelete = 0;
942  RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
943  /* per default unlimited size */
944  dwSize = -1;
945  RegSetValueExW(hKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
946  RegCloseKey(hKey);
947  return TRUE;
948  }
949  else
950  {
951  dwSize = sizeof(dwNukeOnDelete);
952  ret = RegQueryValueExW(hKey, L"NukeOnDelete", NULL, &dwType, (LPBYTE)&dwNukeOnDelete, &dwSize);
953  if (ret != ERROR_SUCCESS)
954  {
955  if (ret == ERROR_FILE_NOT_FOUND)
956  {
957  /* restore key and enable bitbucket */
958  dwNukeOnDelete = 0;
959  RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
960  }
961  RegCloseKey(hKey);
962  return TRUE;
963  }
964  else if (dwNukeOnDelete)
965  {
966  /* do not delete to bitbucket */
967  RegCloseKey(hKey);
968  return FALSE;
969  }
970  /* FIXME
971  * check if bitbucket is full
972  */
973  RegCloseKey(hKey);
974  return TRUE;
975  }
976 }
977 
978 BOOL
980 {
981  TRACE("(%s)\n", debugstr_w(wszPath));
982  return DeleteFileToRecycleBin(wszPath);
983 }
984 
985 /*************************************************************************
986  * SHUpdateCRecycleBinIcon [SHELL32.@]
987  *
988  * Undocumented
989  */
991 {
992  FIXME("stub\n");
993 
994  return S_OK;
995 }
996 
997 /*************************************************************************
998  * SHEmptyRecycleBinA (SHELL32.@)
999  */
1001 {
1002  LPWSTR szRootPathW = NULL;
1003  int len;
1004  HRESULT hr;
1005 
1006  TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_a(pszRootPath), dwFlags);
1007 
1008  if (pszRootPath)
1009  {
1010  len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
1011  if (len == 0)
1012  return HRESULT_FROM_WIN32(GetLastError());
1013  szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1014  if (!szRootPathW)
1015  return E_OUTOFMEMORY;
1016  if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
1017  {
1018  HeapFree(GetProcessHeap(), 0, szRootPathW);
1019  return HRESULT_FROM_WIN32(GetLastError());
1020  }
1021  }
1022 
1023  hr = SHEmptyRecycleBinW(hwnd, szRootPathW, dwFlags);
1024  HeapFree(GetProcessHeap(), 0, szRootPathW);
1025 
1026  return hr;
1027 }
1028 
1030 {
1031  WCHAR szPath[MAX_PATH] = {0}, szBuffer[MAX_PATH];
1032  DWORD dwSize, dwType, count;
1033  LONG ret;
1034  IShellFolder *pDesktop, *pRecycleBin;
1035  PIDLIST_ABSOLUTE pidlRecycleBin;
1036  PITEMID_CHILD pidl;
1037  HRESULT hr = S_OK;
1038  LPENUMIDLIST penumFiles;
1039  STRRET StrRet;
1040 
1041  TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_w(pszRootPath), dwFlags);
1042 
1043  if (!(dwFlags & SHERB_NOCONFIRMATION))
1044  {
1045  hr = SHGetDesktopFolder(&pDesktop);
1046  if (FAILED(hr))
1047  return hr;
1048  hr = SHGetFolderLocation(NULL, CSIDL_BITBUCKET, NULL, 0, &pidlRecycleBin);
1049  if (FAILED(hr))
1050  {
1051  pDesktop->Release();
1052  return hr;
1053  }
1054  hr = pDesktop->BindToObject(pidlRecycleBin, NULL, IID_PPV_ARG(IShellFolder, &pRecycleBin));
1055  CoTaskMemFree(pidlRecycleBin);
1056  pDesktop->Release();
1057  if (FAILED(hr))
1058  return hr;
1059  hr = pRecycleBin->EnumObjects(hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penumFiles);
1060  if (FAILED(hr))
1061  {
1062  pRecycleBin->Release();
1063  return hr;
1064  }
1065 
1066  count = 0;
1067  if (hr != S_FALSE)
1068  {
1069  while (penumFiles->Next(1, &pidl, NULL) == S_OK)
1070  {
1071  count++;
1072  pRecycleBin->GetDisplayNameOf(pidl, SHGDN_NORMAL, &StrRet);
1073  StrRetToBuf(&StrRet, pidl, szBuffer, _countof(szBuffer));
1074  CoTaskMemFree(pidl);
1075  }
1076  penumFiles->Release();
1077  }
1078  pRecycleBin->Release();
1079 
1080  switch (count)
1081  {
1082  case 0:
1083  /* no files, don't need confirmation */
1084  break;
1085 
1086  case 1:
1087  /* we have only one item inside the bin, so show a message box with its name */
1089  MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
1090  {
1091  return S_OK;
1092  }
1093  break;
1094 
1095  default:
1096  /* we have more than one item, so show a message box with the count of the items */
1097  StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%u", count);
1099  MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
1100  {
1101  return S_OK;
1102  }
1103  break;
1104  }
1105  }
1106 
1108  {
1109  ret = EmptyRecycleBinW(pszRootPath);
1110  }
1111  else
1112  {
1113  /* FIXME
1114  * show a progress dialog
1115  */
1116  ret = EmptyRecycleBinW(pszRootPath);
1117  }
1118 
1119  if (!ret)
1120  return HRESULT_FROM_WIN32(GetLastError());
1121 
1122  if (!(dwFlags & SHERB_NOSOUND))
1123  {
1124  dwSize = sizeof(szPath);
1126  L"AppEvents\\Schemes\\Apps\\Explorer\\EmptyRecycleBin\\.Current",
1127  NULL,
1128  RRF_RT_REG_SZ,
1129  &dwType,
1130  (PVOID)szPath,
1131  &dwSize);
1132  if (ret != ERROR_SUCCESS)
1133  return S_OK;
1134 
1135  if (dwType != REG_EXPAND_SZ) /* type dismatch */
1136  return S_OK;
1137 
1138  szPath[_countof(szPath)-1] = L'\0';
1140  }
1141  return S_OK;
1142 }
1143 
1145 {
1146  LPWSTR szRootPathW = NULL;
1147  int len;
1148  HRESULT hr;
1149 
1150  TRACE("%s, %p\n", debugstr_a(pszRootPath), pSHQueryRBInfo);
1151 
1152  if (pszRootPath)
1153  {
1154  len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
1155  if (len == 0)
1156  return HRESULT_FROM_WIN32(GetLastError());
1157  szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1158  if (!szRootPathW)
1159  return E_OUTOFMEMORY;
1160  if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
1161  {
1162  HeapFree(GetProcessHeap(), 0, szRootPathW);
1163  return HRESULT_FROM_WIN32(GetLastError());
1164  }
1165  }
1166 
1167  hr = SHQueryRecycleBinW(szRootPathW, pSHQueryRBInfo);
1168  HeapFree(GetProcessHeap(), 0, szRootPathW);
1169 
1170  return hr;
1171 }
1172 
1174 {
1175  FIXME("%s, %p - stub\n", debugstr_w(pszRootPath), pSHQueryRBInfo);
1176 
1177  if (!(pszRootPath) || (pszRootPath[0] == 0) ||
1178  !(pSHQueryRBInfo) || (pSHQueryRBInfo->cbSize < sizeof(SHQUERYRBINFO)))
1179  {
1180  return E_INVALIDARG;
1181  }
1182 
1183  pSHQueryRBInfo->i64Size = 0;
1184  pSHQueryRBInfo->i64NumItems = 0;
1185 
1186  return S_OK;
1187 }
LSTATUS WINAPI RegGetValueW(HKEY hKey, LPCWSTR pszSubKey, LPCWSTR pszValue, DWORD dwFlags, LPDWORD pdwType, PVOID pvData, LPDWORD pcbData)
Definition: reg.c:1965
#define PID_STG_WRITETIME
Definition: ntquery.h:60
void WINAPI _InsertMenuItemW(HMENU hmenu, UINT indexMenu, BOOL fByPosition, UINT wID, UINT fType, LPCWSTR dwTypeData, UINT fState)
#define IDS_CUT
Definition: shresdef.h:211
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define IN
Definition: typedefs.h:39
#define MFT_STRING
Definition: winuser.h:741
DWORD cbSize
Definition: shellapi.h:377
#define REFIID
Definition: guiddef.h:118
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
virtual HRESULT WINAPI InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
LPPIDLDATA _ILGetDataPointer(LPCITEMIDLIST pidl)
Definition: pidl.c:2176
HRESULT Refresh()
void WINAPI ILFree(LPITEMIDLIST pidl)
Definition: pidl.c:925
#define E_NOINTERFACE
Definition: winerror.h:2364
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
VOID WINAPI CoTaskMemFree(LPVOID ptr)
Definition: ifs.c:442
#define ERROR_SUCCESS
Definition: deptool.c:10
HRESULT hr
Definition: shlfolder.c:183
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185
interface IBindCtx * LPBC
Definition: objfwd.h:18
virtual HRESULT WINAPI GetDefaultColumnState(UINT iColumn, DWORD *pcsFlags)
virtual HRESULT WINAPI GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
virtual HRESULT WINAPI GetDetailsEx(PCUITEMID_CHILD pidl, const SHCOLUMNID *pscid, VARIANT *pv)
#define TRUE
Definition: types.h:120
REFIID riid
Definition: precomp.h:44
LRESULT WINAPI SendMessageA(_In_ HWND, _In_ UINT, _In_ WPARAM, _In_ LPARAM)
BOOL AddToEnumList(LPITEMIDLIST pidl)
HRESULT WINAPI SHQueryRecycleBinA(LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
#define CP_ACP
Definition: compat.h:109
#define LOCALE_USER_DEFAULT
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define DATE_SHORTDATE
Definition: winnls.h:193
HRESULT WINAPI SHQueryRecycleBinW(LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
#define COLUMN_MTIME
Definition: CRecycleBin.cpp:57
virtual HRESULT WINAPI GetDetailsOf(PCUITEMID_CHILD pidl, UINT iColumn, SHELLDETAILS *psd)
#define WARN(fmt,...)
Definition: debug.h:112
#define IDS_RESTORE
Definition: shresdef.h:212
#define LVCFMT_RIGHT
Definition: commctrl.h:2595
LPITEMIDLIST pidl
Definition: CRecycleBin.h:39
const ITEMIDLIST UNALIGNED * LPCITEMIDLIST
Definition: shtypes.idl:42
REFIID LPVOID * ppv
Definition: atlbase.h:39
WCHAR swShell32Name[MAX_PATH]
Definition: folders.cpp:22
#define IDS_SHV_COLUMN_DELFROM
Definition: shresdef.h:52
#define MFS_DISABLED
Definition: winuser.h:744
#define LVCFMT_LEFT
Definition: commctrl.h:2594
#define RRF_RT_REG_SZ
Definition: driver.c:575
const ITEMID_CHILD UNALIGNED * PCUITEMID_CHILD
Definition: shtypes.idl:70
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1044
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1223
#define ZeroMemory
Definition: winbase.h:1648
#define COLUMN_DELFROM
Definition: CRecycleBin.cpp:53
GLuint buffer
Definition: glext.h:5915
#define MAKEINTRESOURCEA(i)
Definition: winuser.h:581
PDELETED_FILE_DETAILS_W UnpackDetailsFromPidl(LPCITEMIDLIST pidl)
#define PID_STG_NAME
Definition: ntquery.h:56
LPWSTR dwTypeData
Definition: winuser.h:3244
#define CSIDL_BITBUCKET
Definition: shlobj.h:2022
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:535
UINT_PTR WPARAM
Definition: windef.h:207
static HRESULT FormatDateTime(LPWSTR buffer, int size, FILETIME *ft)
PIDLRecycleStruct * pFileDetails
BOOL RecycleBinIsEmpty()
__u16 time
Definition: mkdosfs.c:366
#define IDS_PROPERTIES
Definition: resource.h:101
UINT uFlags
Definition: api.c:59
#define MFS_DEFAULT
Definition: winuser.h:743
char * LPSTR
Definition: xmlstorage.h:182
virtual HRESULT WINAPI GetDisplayNameOf(PCUITEMID_CHILD pidl, DWORD dwFlags, LPSTRRET strRet)
HRESULT CRecyclerExtractIcon_CreateInstance(LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
Definition: CRecycleBin.cpp:65
static LPOLESTR
Definition: stg_prop.c:27
BOOL WINAPI FileTimeToLocalFileTime(IN CONST FILETIME *lpFileTime, OUT LPFILETIME lpLocalFileTime)
Definition: time.c:221
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:3755
#define IID_PPV_ARG(Itype, ppType)
#define E_FAIL
Definition: ddrawi.h:102
LPWSTR WINAPI StrDupW(LPCWSTR lpszStr)
Definition: string.c:1089
int WINAPI LoadStringW(_In_opt_ HINSTANCE hInstance, _In_ UINT uID, _Out_writes_to_(cchBufferMax, return+1) LPWSTR lpBuffer, _In_ int cchBufferMax)
STRRET str
Definition: shtypes.idl:108
BOOL WINAPI GetDeletedFileDetailsW(IN HANDLE hDeletedFile, IN DWORD BufferSize, IN OUT PDELETED_FILE_DETAILS_W FileDetails OPTIONAL, OUT LPDWORD RequiredSize OPTIONAL)
Definition: recyclebin.c:301
WPARAM wParam
Definition: combotst.c:138
#define SEVERITY_SUCCESS
Definition: winerror.h:64
#define IDS_SHV_COLUMN_TYPE
Definition: resource.h:75
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1091
virtual HRESULT WINAPI CreateViewObject(HWND hwndOwner, REFIID riid, LPVOID *ppvOut)
HRESULT GetDisplayNameOf([in] PCUITEMID_CHILD pidl, [in] SHGDNF uFlags, [out] STRRET *lpName)
#define MB_ICONEXCLAMATION
Definition: winuser.h:779
static LPITEMIDLIST _ILCreateRecycleItem(PDELETED_FILE_DETAILS_W pFileDetails)
BOOL WINAPI DeleteFileHandleToRecycleBin(IN HANDLE hDeletedFile)
Definition: recyclebin.c:93
#define IDS_SHV_COLUMN_SIZE
Definition: shresdef.h:44
#define COLUMNS_COUNT
Definition: CRecycleBin.cpp:59
HRESULT WINAPI Initialize(LPCITEMIDLIST pidl)
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:53
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define MFS_ENABLED
Definition: winuser.h:745
#define FALSE
Definition: types.h:117
#define MB_YESNO
Definition: winuser.h:811
const PCUITEMID_CHILD * PCUITEMID_CHILD_ARRAY
Definition: shtypes.idl:71
BOOL WINAPI PathStripToRootW(LPWSTR lpszPath)
Definition: path.c:728
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED _In_opt_ LPTRANSMIT_FILE_BUFFERS _In_ DWORD dwReserved
Definition: mswsock.h:90
LPWSTR WINAPI PathAddBackslashW(LPWSTR lpszPath)
Definition: path.c:289
#define MIIM_STATE
Definition: winuser.h:716
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
short SHORT
Definition: pedump.c:59
#define StrRetToBuf
Definition: shlwapi.h:1769
virtual HRESULT WINAPI GetCurFolder(PIDLIST_ABSOLUTE *pidl)
#define debugstr_w
Definition: kernel32.h:32
HRESULT EnumObjects([in] HWND hwndOwner, [in] SHCONTF grfFlags, [out] IEnumIDList **ppenumIDList)
virtual HRESULT WINAPI InvokeCommand(LPCMINVOKECOMMANDINFO lpcmi)
#define FIXME(fmt,...)
Definition: debug.h:111
const GUID * fmtId
Definition: CRecycleBin.cpp:33
#define StrRet
Definition: shellclasses.h:871
#define IDS_SHV_COLUMN_DELDATE
Definition: shresdef.h:53
ULONG Release()
#define S_FALSE
Definition: winerror.h:2357
#define IDS_ANY_FILE
Definition: shresdef.h:172
#define E_INVALIDARG
Definition: ddrawi.h:101
virtual HRESULT WINAPI BindToStorage(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
smooth NULL
Definition: ftsmooth.c:416
STRSAFEAPI StringCbPrintfW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:557
#define PID_DISPLACED_FROM
Definition: shlguid.h:178
_Reserved_ DWORD _In_ DWORD _Out_ DWORD _Out_writes_bytes_to_opt_ pcbTypeName LPSTR szTypeName
Definition: wincrypt.h:4283
LPWSTR WINAPI PathFindFileNameW(LPCWSTR lpszPath)
Definition: path.c:389
LONG_PTR LPARAM
Definition: windef.h:208
HRESULT BindToObject([in] PCUIDLIST_RELATIVE pidl, [in] LPBC pbcReserved, [in] REFIID riid, [out, iid_is(riid)] void **ppvOut)
#define REG_CREATED_NEW_KEY
Definition: nt_native.h:1084
const char * LPCSTR
Definition: xmlstorage.h:183
struct _SFV_CREATE SFV_CREATE
#define MAKE_HRESULT(sev, fac, code)
Definition: dmerror.h:30
LPWSTR WINAPI PathFindExtensionW(LPCWSTR lpszPath)
Definition: path.c:442
#define debugstr_guid
Definition: kernel32.h:35
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static PROTOCOLDATA * pdata
Definition: protocol.c:158
#define PID_STG_SIZE
Definition: ntquery.h:58
WCHAR FileName[ANY_SIZE]
Definition: recyclebin.h:40
#define MIIM_ID
Definition: winuser.h:717
#define IDS_DELETEITEM_TEXT
Definition: shresdef.h:116
#define DeleteFileToRecycleBin
Definition: recyclebin.h:82
#define PID_STG_STORAGETYPE
Definition: ntquery.h:50
virtual HRESULT WINAPI EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
__int64 i64Size
Definition: shellapi.h:378
#define KEY_WRITE
Definition: nt_native.h:1031
virtual HRESULT WINAPI GetDefaultSearchGUID(GUID *pguid)
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4895
#define BEGIN_COM_MAP(x)
Definition: atlcom.h:541
int64_t LONGLONG
Definition: typedefs.h:68
BOOL WINAPI CloseRecycleBinHandle(IN HANDLE hDeletedFile)
Definition: recyclebin.c:12
#define TRACE(s)
Definition: solgame.cpp:4
virtual HRESULT WINAPI EnumSearches(IEnumExtraSearch **ppenum)
virtual HRESULT WINAPI Initialize(PCIDLIST_ABSOLUTE pidl)
static LPSTR pName
Definition: security.c:75
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:188
HRESULT WINAPI SHGetDesktopFolder(IShellFolder **psf)
GLsizeiptr size
Definition: glext.h:5919
LONG WINAPI CompareFileTime(IN CONST FILETIME *lpFileTime1, IN CONST FILETIME *lpFileTime2)
Definition: time.c:106
#define GetProcessHeap()
Definition: compat.h:595
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
EXTERN_C HRESULT WINAPI SHUpdateRecycleBinIcon(void)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
virtual HRESULT WINAPI ParseDisplayName(HWND hwndOwner, LPBC pbc, LPOLESTR lpszDisplayName, DWORD *pchEaten, PIDLIST_RELATIVE *ppidl, DWORD *pdwAttributes)
#define debugstr_a
Definition: kernel32.h:31
virtual HRESULT WINAPI GetUIObjectOf(HWND hwndOwner, UINT cidl, PCUITEMID_CHILD_ARRAY apidl, REFIID riid, UINT *prgfInOut, LPVOID *ppvOut)
LONG HRESULT
Definition: typedefs.h:79
#define COLUMN_NAME
Definition: CRecycleBin.cpp:52
#define _countof(array)
Definition: sndvol32.h:68
virtual HRESULT WINAPI BindToObject(PCUIDLIST_RELATIVE pidl, LPBC pbcReserved, REFIID riid, LPVOID *ppvOut)
BOOL WINAPI CBSearchRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile)
#define FAILED_UNEXPECTEDLY(hr)
Definition: shellutils.h:71
#define MAX_PATH
Definition: compat.h:34
#define swprintf(buf, format,...)
Definition: sprintf.c:56
#define WINAPI
Definition: msvc.h:6
BOOL WINAPI RestoreFile(IN HANDLE hDeletedFile)
Definition: recyclebin.c:366
unsigned short WORD
Definition: ntddk_ex.h:93
unsigned long DWORD
Definition: ntddk_ex.h:95
LPARAM LPFNSVADDPROPSHEETPAGE
Definition: shobjidl.idl:117
HRESULT WINAPI Initialize(DWORD dwFlags)
BOOL HCR_MapTypeToValueW(LPCWSTR szExtension, LPWSTR szFileType, LONG len, BOOL bPrependDot)
Definition: classes.c:46
unsigned __int3264 UINT_PTR
Definition: mstsclib_h.h:274
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
#define SHERB_NOSOUND
Definition: shellapi.h:396
virtual HRESULT WINAPI ReplacePage(EXPPS uPageID, LPFNSVADDPROPSHEETPAGE pfnReplaceWith, LPARAM lParam)
#define MFT_SEPARATOR
Definition: winuser.h:739
#define wcsicmp
Definition: compat.h:15
int ret
DWORD SHCOLSTATEF
Definition: shtypes.idl:142
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
static const columninfo RecycleBinColumns[]
Definition: CRecycleBin.cpp:40
static const WCHAR L[]
Definition: oid.c:1250
LPWSTR WINAPI StrFormatKBSizeW(LONGLONG llBytes, LPWSTR lpszDest, UINT cchMax)
Definition: string.c:1743
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1175
#define MIIM_TYPE
Definition: winuser.h:720
virtual HRESULT WINAPI SetNameOf(HWND hwndOwner, PCUITEMID_CHILD pidl, LPCOLESTR lpName, DWORD dwFlags, PITEMID_CHILD *pPidlOut)
BOOL WINAPI EmptyRecycleBinW(IN LPCWSTR pszRoot OPTIONAL)
Definition: recyclebin.c:145
HRESULT CRecyclerDropTarget_CreateInstance(REFIID riid, LPVOID *ppvOut)
virtual HRESULT WINAPI GetAttributesOf(UINT cidl, PCUITEMID_CHILD_ARRAY apidl, DWORD *rgfInOut)
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLenum GLsizei len
Definition: glext.h:6722
#define IDS_DELETEMULTIPLE_TEXT
Definition: shresdef.h:117
virtual HRESULT WINAPI GetDefaultColumn(DWORD dwRes, ULONG *pSort, ULONG *pDisplay)
#define wcsrchr
Definition: compat.h:16
UINT WINAPI GetDriveTypeW(IN LPCWSTR lpRootPathName)
Definition: disk.c:497
BOOL WINAPI EnumerateRecycleBinW(IN LPCWSTR pszRoot OPTIONAL, IN PENUMERATE_RECYCLEBIN_CALLBACK pFnCallback, IN PVOID Context OPTIONAL)
Definition: recyclebin.c:205
#define IDS_EMPTY_BITBUCKET
Definition: shresdef.h:174
#define IDS_SHV_COLUMN_MODIFIED
Definition: shresdef.h:46
HRESULT WINAPI SHCreateDefaultExtractIcon(REFIID riid, void **ppv)
#define DRIVE_FIXED
Definition: winbase.h:249
INT WINAPI GetDateFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpDateStr, INT cchOut)
Definition: lcformat.c:979
#define PID_DISPLACED_DATE
Definition: shlguid.h:179
#define COLUMN_SIZE
Definition: CRecycleBin.cpp:55
#define ERR(fmt,...)
Definition: debug.h:110
BOOL WINAPI GetVolumeInformationW(IN LPCWSTR lpRootPathName, IN LPWSTR lpVolumeNameBuffer, IN DWORD nVolumeNameSize, OUT LPDWORD lpVolumeSerialNumber OPTIONAL, OUT LPDWORD lpMaximumComponentLength OPTIONAL, OUT LPDWORD lpFileSystemFlags OPTIONAL, OUT LPWSTR lpFileSystemNameBuffer OPTIONAL, IN DWORD nFileSystemNameSize)
Definition: volume.c:226
#define SND_FILENAME
Definition: mmsystem.h:162
#define COLUMN_TYPE
Definition: CRecycleBin.cpp:56
#define S_OK
Definition: intsafe.h:51
#define shell32_hInstance
HRESULT WINAPI SHEmptyRecycleBinW(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags)
LPCWSTR szPath
Definition: env.c:35
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:228
BOOL TRASH_TrashFile(LPCWSTR wszPath)
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
virtual HRESULT WINAPI HandleMenuMsg(UINT uMsg, WPARAM wParam, LPARAM lParam)
#define COM_INTERFACE_ENTRY_IID(iid, x)
Definition: atlcom.h:561
STRSAFEAPI StringCchPrintfW(STRSAFE_LPWSTR pszDest, size_t cchDest, STRSAFE_LPCWSTR pszFormat,...)
Definition: strsafe.h:530
#define E_NOTIMPL
Definition: ddrawi.h:99
#define SHERB_NOCONFIRMATION
Definition: shellapi.h:394
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
#define ShellMessageBoxW
Definition: precomp.h:58
BOOL WINAPI InsertMenuItemW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
#define CWM_GETISHELLBROWSER
Definition: undocshell.h:201
unsigned int UINT
Definition: ndis.h:50
virtual HRESULT WINAPI GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
virtual HRESULT WINAPI GetClassID(CLSID *pClassID)
WINE_DEFAULT_DEBUG_CHANNEL(CRecycleBin)
#define MultiByteToWideChar
Definition: compat.h:110
#define E_UNEXPECTED
Definition: winerror.h:2456
virtual HRESULT WINAPI QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
struct SEARCH_CONTEXT * PSEARCH_CONTEXT
static PIDLRecycleStruct * _ILGetRecycleStruct(LPCITEMIDLIST pidl)
HRESULT QueryInterface([in] REFIID riid, [out, iid_is(riid)] void **ppvObject)
void WINAPI SHFree(LPVOID pv)
Definition: shellole.c:331
const ITEMIDLIST_RELATIVE UNALIGNED * PCUIDLIST_RELATIVE
Definition: shtypes.idl:57
HRESULT WINAPI SHEmptyRecycleBinA(HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags)
#define MB_DEFBUTTON2
Definition: winuser.h:793
virtual HRESULT WINAPI QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
static BOOL WINAPI CBEnumRecycleBin(IN PVOID Context, IN HANDLE hDeletedFile)
int column_name_id
Definition: CRecycleBin.cpp:32
virtual HRESULT WINAPI AddPages(LPFNSVADDPROPSHEETPAGE pfnAddPage, LPARAM lParam)
struct tagContext Context
Definition: acpixf.h:1034
#define HIWORD(l)
Definition: typedefs.h:247
unsigned int ULONG
Definition: retypes.h:1
HRESULT WINAPI SHGetFolderLocation(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
Definition: shellpath.c:2741
BOOL TRASH_CanTrashFile(LPCWSTR wszPath)
#define TIME_NOSECONDS
Definition: winnls.h:275
#define IDS_DELETE
Definition: resource.h:40
#define MAKEINTRESOURCEW(i)
Definition: winuser.h:582
#define IDNO
Definition: winuser.h:830
#define END_COM_MAP()
Definition: atlcom.h:552
#define IDS_SHV_COLUMN_NAME
Definition: resource.h:74
GLfloat GLfloat p
Definition: glext.h:8902
WCHAR * LPWSTR
Definition: xmlstorage.h:184
__int64 i64NumItems
Definition: shellapi.h:379
#define EXTERN_C
Definition: basetyps.h:12
STRSAFEAPI StringCbCopyW(STRSAFE_LPWSTR pszDest, size_t cbDest, STRSAFE_LPCWSTR pszSrc)
Definition: strsafe.h:166
#define GetEnvironmentVariableW(x, y, z)
Definition: compat.h:614
INT WINAPI GetTimeFormatW(LCID lcid, DWORD dwFlags, const SYSTEMTIME *lpTime, LPCWSTR lpFormat, LPWSTR lpTimeStr, INT cchOut)
Definition: lcformat.c:1079
GLuint64EXT * result
Definition: glext.h:11304
#define REG_DWORD
Definition: sdbapi.c:596
ITEMIDLIST UNALIGNED * LPITEMIDLIST
Definition: shtypes.idl:41
static const CLSID *static CLSID *static const GUID VARIANT VARIANT *static IServiceProvider DWORD *static HMENU
Definition: ordinal.c:60
LPARAM lParam
Definition: combotst.c:139
virtual HRESULT WINAPI CompareIDs(LPARAM lParam, PCUIDLIST_RELATIVE pidl1, PCUIDLIST_RELATIVE pidl2)
#define LOWORD(l)
Definition: pedump.c:82
#define SHERB_NOPROGRESSUI
Definition: shellapi.h:395
#define COLUMN_DATEDEL
Definition: CRecycleBin.cpp:54
LPVOID WINAPI SHAlloc(SIZE_T len)
Definition: shellole.c:309
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:594
virtual HRESULT WINAPI MapColumnToSCID(UINT column, SHCOLUMNID *pscid)
PSDBQUERYRESULT_VISTA PVOID DWORD * dwSize
Definition: env.c:54
#define IsEqualIID(riid1, riid2)
Definition: guiddef.h:95
static IShellFolder IShellItem **static IBindCtx LPITEMIDLIST SFGAOF
Definition: ebrowser.c:83
#define SUCCEEDED(hr)
Definition: intsafe.h:49
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
DWORD SHGDNF
Definition: shobjidl.idl:169
BOOL WINAPI PlaySoundW(LPCWSTR pszSoundW, HMODULE hmod, DWORD fdwSound)
Definition: playsound.c:531