ReactOS  0.4.13-dev-982-g9853eab
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  static LPCWSTR szDrive = L"C:\\";
195 
196  if (dwFlags & SHCONTF_NONFOLDERS)
197  {
198  TRACE("Starting Enumeration\n");
199 
200  if (!EnumerateRecycleBinW(szDrive /* FIXME */ , CBEnumRecycleBin, (PVOID)this))
201  {
202  WARN("Error: EnumerateCRecycleBinW failed\n");
203  return E_FAIL;
204  }
205  }
206  else
207  {
208  // do nothing
209  }
210  return S_OK;
211 }
212 
214 {
215  PIDLDATA tmp;
216  LPITEMIDLIST pidl;
217  PIDLRecycleStruct * p;
218  int size0 = (char*)&tmp.u.crecycle.szName - (char*)&tmp.u.crecycle;
219  int size = size0;
220 
221  tmp.type = 0x00;
222  size += (wcslen(pFileDetails->FileName) + 1) * sizeof(WCHAR);
223 
224  pidl = (LPITEMIDLIST)SHAlloc(size + 4);
225  if (!pidl)
226  return pidl;
227 
228  pidl->mkid.cb = size + 2;
229  memcpy(pidl->mkid.abID, &tmp, 2 + size0);
230 
231  p = &((PIDLDATA*)pidl->mkid.abID)->u.crecycle;
232  RtlCopyMemory(p, pFileDetails, sizeof(DELETED_FILE_DETAILS_W));
233  wcscpy(p->szName, pFileDetails->FileName);
234  *(WORD*)((char*)pidl + (size + 2)) = 0;
235  return pidl;
236 }
237 
239 {
240  return static_cast<CRecycleBinEnum *>(Context)->CBEnumRecycleBin(hDeletedFile);
241 }
242 
244 {
245  PDELETED_FILE_DETAILS_W pFileDetails;
246  DWORD dwSize;
247  LPITEMIDLIST pidl = NULL;
248  BOOL ret;
249 
250  if (!GetDeletedFileDetailsW(hDeletedFile,
251  0,
252  NULL,
253  &dwSize) &&
255  {
256  ERR("GetDeletedFileDetailsW failed\n");
257  return FALSE;
258  }
259 
260  pFileDetails = (DELETED_FILE_DETAILS_W *)SHAlloc(dwSize);
261  if (!pFileDetails)
262  {
263  ERR("No memory\n");
264  return FALSE;
265  }
266 
267  if (!GetDeletedFileDetailsW(hDeletedFile,
268  dwSize,
269  pFileDetails,
270  NULL))
271  {
272  ERR("GetDeletedFileDetailsW failed\n");
273  SHFree(pFileDetails);
274  return FALSE;
275  }
276 
277  pidl = _ILCreateRecycleItem(pFileDetails);
278  if (!pidl)
279  {
280  SHFree(pFileDetails);
281  return FALSE;
282  }
283 
284  ret = AddToEnumList(pidl);
285 
286  if (!ret)
287  SHFree(pidl);
288  SHFree(pFileDetails);
289  TRACE("Returning %d\n", ret);
290  CloseRecycleBinHandle(hDeletedFile);
291  return ret;
292 }
293 
294 /**************************************************************************
295 * IContextMenu2 Bitbucket Item Implementation
296 */
297 
299 {
300  apidl = NULL;
301 }
302 
304 {
305  ILFree(apidl);
306 }
307 
309 {
310  apidl = ILClone(pidl);
311  if (apidl == NULL)
312  return E_OUTOFMEMORY;
313  return S_OK;
314 }
315 
317 {
318  WCHAR szBuffer[30] = {0};
319  ULONG Count = 1;
320 
321  TRACE("(%p)->(hmenu=%p indexmenu=%x cmdfirst=%x cmdlast=%x flags=%x )\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags);
322 
323  if (LoadStringW(shell32_hInstance, IDS_RESTORE, szBuffer, _countof(szBuffer)))
324  {
325  szBuffer[_countof(szBuffer)-1] = L'\0';
326  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_ENABLED);
327  Count++;
328  }
329 
330  if (LoadStringW(shell32_hInstance, IDS_CUT, szBuffer, _countof(szBuffer)))
331  {
332  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
333  szBuffer[_countof(szBuffer)-1] = L'\0';
334  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
335  }
336 
337  if (LoadStringW(shell32_hInstance, IDS_DELETE, szBuffer, _countof(szBuffer)))
338  {
339  szBuffer[_countof(szBuffer)-1] = L'\0';
340  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
341  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_STRING, szBuffer, MFS_ENABLED);
342  }
343 
344  if (LoadStringW(shell32_hInstance, IDS_PROPERTIES, szBuffer, _countof(szBuffer)))
345  {
346  szBuffer[_countof(szBuffer)-1] = L'\0';
347  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count++, MFT_SEPARATOR, NULL, MFS_ENABLED);
348  _InsertMenuItemW(hMenu, indexMenu++, TRUE, idCmdFirst + Count, MFT_STRING, szBuffer, MFS_DEFAULT);
349  }
350 
351  return MAKE_HRESULT(SEVERITY_SUCCESS, 0, Count);
352 }
353 
355 {
357  static LPCWSTR szDrive = L"C:\\";
358 
359  TRACE("(%p)->(invcom=%p verb=%p wnd=%p)\n", this, lpcmi, lpcmi->lpVerb, lpcmi->hwnd);
360 
361  if (lpcmi->lpVerb == MAKEINTRESOURCEA(1) || lpcmi->lpVerb == MAKEINTRESOURCEA(5))
362  {
363  Context.pFileDetails = _ILGetRecycleStruct(apidl);
364  Context.bFound = FALSE;
365 
367  if (!Context.bFound)
368  return E_FAIL;
369 
370  if (lpcmi->lpVerb == MAKEINTRESOURCEA(1))
371  {
372  /* restore file */
373  if (RestoreFile(Context.hDeletedFile))
374  return S_OK;
375  else
376  return E_FAIL;
377  }
378  else
379  {
381  return E_NOTIMPL;
382  }
383  }
384  else if (lpcmi->lpVerb == MAKEINTRESOURCEA(3))
385  {
386  FIXME("implement cut\n");
387  return E_NOTIMPL;
388  }
389  else if (lpcmi->lpVerb == MAKEINTRESOURCEA(7))
390  {
391  FIXME("implement properties\n");
392  return E_NOTIMPL;
393  }
394 
395  return S_OK;
396 }
397 
399 {
400  TRACE("(%p)->(idcom=%lx flags=%x %p name=%p len=%x)\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
401 
402  return E_FAIL;
403 }
404 
406 {
407  TRACE("CRecycleBin_IContextMenu2Item_HandleMenuMsg (%p)->(msg=%x wp=%lx lp=%lx)\n", this, uMsg, wParam, lParam);
408 
409  return E_NOTIMPL;
410 }
411 
413 {
414  pidl = NULL;
415 }
416 
418 {
419  SHFree(pidl);
420 }
421 
422 /*************************************************************************
423  * RecycleBin IPersistFolder2 interface
424  */
425 
427 {
428  TRACE("(%p, %p)\n", this, pClassID);
429  if (pClassID == NULL)
430  return E_INVALIDARG;
431  memcpy(pClassID, &CLSID_RecycleBin, sizeof(CLSID));
432  return S_OK;
433 }
434 
436 {
437  TRACE("(%p, %p)\n", this, pidl);
438 
439  SHFree((LPVOID)this->pidl);
440  this->pidl = ILClone(pidl);
441  if (this->pidl == NULL)
442  return E_OUTOFMEMORY;
443  return S_OK;
444 }
445 
447 {
448  TRACE("\n");
449  *ppidl = ILClone(pidl);
450  return S_OK;
451 }
452 
453 /*************************************************************************
454  * RecycleBin IShellFolder2 interface
455  */
456 
458  LPOLESTR pszDisplayName, ULONG *pchEaten, PIDLIST_RELATIVE *ppidl,
459  ULONG *pdwAttributes)
460 {
461  FIXME("stub\n");
462  return E_NOTIMPL;
463 }
464 
465 
468 {
469  return (PDELETED_FILE_DETAILS_W)&pidl->mkid.abID;
470 }
471 
472 HRESULT WINAPI CRecycleBin::EnumObjects(HWND hwndOwner, DWORD dwFlags, LPENUMIDLIST *ppEnumIDList)
473 {
474  return ShellObjectCreatorInit<CRecycleBinEnum>(dwFlags, IID_PPV_ARG(IEnumIDList, ppEnumIDList));
475 }
476 
478 {
479  FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
480  return E_NOTIMPL;
481 }
482 
484 {
485  FIXME("(%p, %p, %p, %s, %p) - stub\n", this, pidl, pbc, debugstr_guid(&riid), ppv);
486  return E_NOTIMPL;
487 }
488 
490 {
491  PIDLRecycleStruct* pData1 = _ILGetRecycleStruct(pidl1);
492  PIDLRecycleStruct* pData2 = _ILGetRecycleStruct(pidl2);
493  LPWSTR pName1, pName2;
494 
495  if(!pData1 || !pData2 || LOWORD(lParam) >= COLUMNS_COUNT)
496  return E_INVALIDARG;
497 
498  SHORT result;
499  LONGLONG diff;
500  switch (LOWORD(lParam))
501  {
502  case 0: /* Name */
503  pName1 = PathFindFileNameW(pData1->szName);
504  pName2 = PathFindFileNameW(pData2->szName);
505  result = wcsicmp(pName1, pName2);
506  break;
507  case 1: /* Orig. Location */
508  result = wcsicmp(pData1->szName, pData2->szName);
509  break;
510  case 2: /* Date Deleted */
511  result = CompareFileTime(&pData1->DeletionTime, &pData2->DeletionTime);
512  break;
513  case 3: /* Size */
514  diff = pData1->FileSize.QuadPart - pData2->FileSize.QuadPart;
515  return MAKE_COMPARE_HRESULT(diff);
516  case 4: /* Type */
517  pName1 = PathFindExtensionW(pData1->szName);
518  pName2 = PathFindExtensionW(pData2->szName);
519  result = wcsicmp(pName1, pName2);
520  break;
521  case 5: /* Modified */
522  result = CompareFileTime(&pData1->LastModification, &pData2->LastModification);
523  break;
524  }
526 }
527 
529 {
530  CComPtr<IShellView> pShellView;
532 
533  TRACE("(%p, %p, %s, %p)\n", this, hwndOwner, debugstr_guid(&riid), ppv);
534 
535  if (!ppv)
536  return hr;
537 
538  *ppv = NULL;
539 
540  if (IsEqualIID (riid, IID_IDropTarget))
541  {
543  }
544  else if (IsEqualIID (riid, IID_IContextMenu) || IsEqualIID (riid, IID_IContextMenu2))
545  {
546  hr = this->QueryInterface(riid, ppv);
547  }
548  else if (IsEqualIID (riid, IID_IShellView))
549  {
550  SFV_CREATE sfvparams = {sizeof(SFV_CREATE), this};
551  hr = SHCreateShellFolderView(&sfvparams, (IShellView**)ppv);
552  }
553  else
554  return hr;
555 
556  TRACE ("-- (%p)->(interface=%p)\n", this, ppv);
557  return hr;
558 
559 }
560 
562  SFGAOF *rgfInOut)
563 {
564  TRACE("(%p, %d, {%p, ...}, {%x})\n", this, cidl, apidl ? apidl[0] : NULL, (unsigned int)*rgfInOut);
565  *rgfInOut &= SFGAO_FOLDER|SFGAO_DROPTARGET|SFGAO_HASPROPSHEET|SFGAO_CANLINK;
566  return S_OK;
567 }
568 
570  REFIID riid, UINT *prgfInOut, void **ppv)
571 {
572  LPVOID pObj = NULL;
574 
575  TRACE ("(%p)->(%p,%u,apidl=%p, %p %p)\n", this,
576  hwndOwner, cidl, apidl, prgfInOut, ppv);
577 
578  if (!ppv)
579  return hr;
580 
581  *ppv = NULL;
582 
583  if ((IsEqualIID (riid, IID_IContextMenu) || IsEqualIID(riid, IID_IContextMenu2)) && (cidl >= 1))
584  {
585  hr = ShellObjectCreatorInit<CRecycleBinItemContextMenu>(apidl[0], riid, &pObj);
586  }
587  else if((IsEqualIID(riid, IID_IExtractIconA) || IsEqualIID(riid, IID_IExtractIconW)) && (cidl == 1))
588  {
589  hr = CRecyclerExtractIcon_CreateInstance(apidl[0], riid, &pObj);
590  }
591  else
592  hr = E_NOINTERFACE;
593 
594  if (SUCCEEDED(hr) && !pObj)
595  hr = E_OUTOFMEMORY;
596 
597  *ppv = pObj;
598  TRACE ("(%p)->hr=0x%08x\n", this, hr);
599  return hr;
600 }
601 
603 {
604  PIDLRecycleStruct *pFileDetails;
605  LPWSTR pFileName;
606 
607  TRACE("(%p, %p, %x, %p)\n", this, pidl, (unsigned int)uFlags, pName);
608 
609  pFileDetails = _ILGetRecycleStruct(pidl);
610  if (!pFileDetails)
611  {
612  pName->cStr[0] = 0;
613  pName->uType = STRRET_CSTR;
614  return E_INVALIDARG;
615  }
616 
617  pFileName = wcsrchr(pFileDetails->szName, L'\\');
618  if (!pFileName)
619  {
620  pName->cStr[0] = 0;
621  pName->uType = STRRET_CSTR;
622  return E_UNEXPECTED;
623  }
624 
625  pName->pOleStr = StrDupW(pFileName + 1);
626  if (pName->pOleStr == NULL)
627  return E_OUTOFMEMORY;
628 
629  pName->uType = STRRET_WSTR;
630  return S_OK;
631 }
632 
634  SHGDNF uFlags, PITEMID_CHILD *ppidlOut)
635 {
636  TRACE("\n");
637  return E_FAIL; /* not supported */
638 }
639 
641 {
642  FIXME("stub\n");
643  return E_NOTIMPL;
644 }
645 
647 {
648  FIXME("stub\n");
649  *ppEnum = NULL;
650  return E_NOTIMPL;
651 }
652 
654 {
655  TRACE("(%p, %x, %p, %p)\n", this, (unsigned int)dwReserved, pSort, pDisplay);
656  if (pSort)
657  *pSort = 0;
658  if (pDisplay)
659  *pDisplay = 0;
660  return S_OK;
661 }
662 
664 {
665  TRACE("(%p, %d, %p)\n", this, iColumn, pcsFlags);
666  if (iColumn >= COLUMNS_COUNT)
667  return E_INVALIDARG;
668  *pcsFlags = RecycleBinColumns[iColumn].pcsFlags;
669  return S_OK;
670 }
671 
673 {
674  FIXME("stub\n");
675  return E_NOTIMPL;
676 }
677 
679 {
680  FILETIME lft;
682  int ret;
683 
684  FileTimeToLocalFileTime(ft, &lft);
685  FileTimeToSystemTime(&lft, &time);
686 
688  if (ret > 0 && ret < size)
689  {
690  /* Append space + time without seconds */
691  buffer[ret-1] = ' ';
693  }
694 
695  return (ret != 0 ? E_FAIL : S_OK);
696 }
697 
699 {
700  PIDLRecycleStruct * pFileDetails;
702  WCHAR szTypeName[100];
703  LPWSTR pszBackslash;
704  UINT Length;
705 
706  TRACE("(%p, %p, %d, %p)\n", this, pidl, iColumn, pDetails);
707  if (iColumn >= COLUMNS_COUNT)
708  return E_FAIL;
709  pDetails->fmt = RecycleBinColumns[iColumn].fmt;
710  pDetails->cxChar = RecycleBinColumns[iColumn].cxChars;
711  if (pidl == NULL)
712  return SHSetStrRet(&pDetails->str, RecycleBinColumns[iColumn].column_name_id);
713 
714  if (iColumn == COLUMN_NAME)
715  return GetDisplayNameOf(pidl, SHGDN_NORMAL, &pDetails->str);
716 
717  pFileDetails = _ILGetRecycleStruct(pidl);
718  switch (iColumn)
719  {
720  case COLUMN_DATEDEL:
721  FormatDateTime(buffer, MAX_PATH, &pFileDetails->DeletionTime);
722  break;
723  case COLUMN_DELFROM:
724  pszBackslash = wcsrchr(pFileDetails->szName, L'\\');
725  Length = (pszBackslash - pFileDetails->szName);
726  memcpy((LPVOID)buffer, pFileDetails->szName, Length * sizeof(WCHAR));
727  buffer[Length] = L'\0';
728  break;
729  case COLUMN_SIZE:
730  StrFormatKBSizeW(pFileDetails->FileSize.QuadPart, buffer, MAX_PATH);
731  break;
732  case COLUMN_MTIME:
733  FormatDateTime(buffer, MAX_PATH, &pFileDetails->LastModification);
734  break;
735  case COLUMN_TYPE:
736  // FIXME: We should in fact use a UNICODE version of _ILGetFileType
737  szTypeName[0] = L'\0';
738  wcscpy(buffer, PathFindExtensionW(pFileDetails->szName));
741  {
742  /* load localized file string */
743  szTypeName[0] = '\0';
745  {
746  szTypeName[63] = '\0';
748  }
749  }
750  return SHSetStrRet(&pDetails->str, szTypeName);
751  default:
752  return E_FAIL;
753  }
754 
755  return SHSetStrRet(&pDetails->str, buffer);
756 }
757 
759 {
760  TRACE("(%p, %d, %p)\n", this, iColumn, pscid);
761  if (iColumn >= COLUMNS_COUNT)
762  return E_INVALIDARG;
763  pscid->fmtid = *RecycleBinColumns[iColumn].fmtId;
764  pscid->pid = RecycleBinColumns[iColumn].pid;
765  return S_OK;
766 }
767 
769 {
770  CComPtr<IEnumIDList> spEnumFiles;
772  if (FAILED(hr))
773  return TRUE;
774  CComHeapPtr<ITEMIDLIST> spPidl;
775  ULONG itemcount;
776  return spEnumFiles->Next(1, &spPidl, &itemcount) != S_OK;
777  }
778 
779 /*************************************************************************
780  * RecycleBin IContextMenu interface
781  */
782 
783 HRESULT WINAPI CRecycleBin::QueryContextMenu(HMENU hMenu, UINT indexMenu, UINT idCmdFirst, UINT idCmdLast, UINT uFlags)
784 {
785  WCHAR szBuffer[100];
786  MENUITEMINFOW mii;
787  int id = 1;
788 
789  TRACE("QueryContextMenu %p %p %u %u %u %u\n", this, hMenu, indexMenu, idCmdFirst, idCmdLast, uFlags );
790 
791  if (!hMenu)
792  return E_INVALIDARG;
793 
794  ZeroMemory(&mii, sizeof(mii));
795  mii.cbSize = sizeof(mii);
796  mii.fMask = MIIM_TYPE | MIIM_ID | MIIM_STATE;
798  szBuffer[0] = L'\0';
800  mii.dwTypeData = szBuffer;
801  mii.cch = wcslen(mii.dwTypeData);
802  mii.wID = idCmdFirst + id++;
803  mii.fType = MFT_STRING;
804  iIdEmpty = 1;
805 
806  if (!InsertMenuItemW(hMenu, indexMenu, TRUE, &mii))
807  return E_FAIL;
808 
809  return MAKE_HRESULT(SEVERITY_SUCCESS, 0, id);
810 }
811 
813 {
814  HRESULT hr;
815  LPSHELLBROWSER lpSB;
816  IShellView * lpSV = NULL;
817 
818  TRACE("%p %p verb %p\n", this, lpcmi, lpcmi->lpVerb);
819 
820  if (LOWORD(lpcmi->lpVerb) == iIdEmpty)
821  {
822  // FIXME
823  // path & flags
824  hr = SHEmptyRecycleBinW(lpcmi->hwnd, L"C:\\", 0);
825  TRACE("result %x\n", hr);
826  if (hr != S_OK)
827  return hr;
828 
829  lpSB = (LPSHELLBROWSER)SendMessageA(lpcmi->hwnd, CWM_GETISHELLBROWSER, 0, 0);
830  if (lpSB && SUCCEEDED(lpSB->QueryActiveShellView(&lpSV)))
831  lpSV->Refresh();
832  }
833  return S_OK;
834 }
835 
836 HRESULT WINAPI CRecycleBin::GetCommandString(UINT_PTR idCommand, UINT uFlags, UINT *lpReserved, LPSTR lpszName, UINT uMaxNameLen)
837 {
838  FIXME("%p %lu %u %p %p %u\n", this, idCommand, uFlags, lpReserved, lpszName, uMaxNameLen);
839 
840  return E_NOTIMPL;
841 }
842 
843 /*************************************************************************
844  * RecycleBin IShellPropSheetExt interface
845  */
846 
848 {
849  FIXME("%p %p %lu\n", this, pfnAddPage, lParam);
850 
851  return E_NOTIMPL;
852 }
853 
855 {
856  FIXME("%p %lu %p %lu\n", this, uPageID, pfnReplaceWith, lParam);
857 
858  return E_NOTIMPL;
859 }
860 
861 /*************************************************************************
862  * RecycleBin IShellExtInit interface
863  */
864 
866 {
867  TRACE("%p %p %p %p\n", this, pidlFolder, pdtobj, hkeyProgID );
868  return S_OK;
869 }
870 
876 BOOL
878 {
879  LONG ret;
880  DWORD dwNukeOnDelete, dwType, VolSerialNumber, MaxComponentLength;
881  DWORD FileSystemFlags, dwSize, dwDisposition;
882  HKEY hKey;
883  WCHAR szBuffer[10];
884  WCHAR szKey[150] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket\\Volume\\";
885 
886  if (wszPath[1] != L':')
887  {
888  /* path is UNC */
889  return FALSE;
890  }
891 
892  // Copy and retrieve the root path from get given string
893  WCHAR wszRootPathName[MAX_PATH];
894  StringCbCopy(wszRootPathName, sizeof(wszRootPathName), wszPath);
895  PathStripToRootW(wszRootPathName);
896 
897  // Test to see if the drive is fixed (non removable)
898  if (GetDriveTypeW(wszRootPathName) != DRIVE_FIXED)
899  {
900  /* no bitbucket on removable media */
901  return FALSE;
902  }
903 
904  if (!GetVolumeInformationW(wszRootPathName, NULL, 0, &VolSerialNumber, &MaxComponentLength, &FileSystemFlags, NULL, 0))
905  {
906  ERR("GetVolumeInformationW failed with %u wszRootPathName=%s\n", GetLastError(), debugstr_w(wszRootPathName));
907  return FALSE;
908  }
909 
910  swprintf(szBuffer, L"%04X-%04X", LOWORD(VolSerialNumber), HIWORD(VolSerialNumber));
911  wcscat(szKey, szBuffer);
912 
913  if (RegCreateKeyExW(HKEY_CURRENT_USER, szKey, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition) != ERROR_SUCCESS)
914  {
915  ERR("RegCreateKeyExW failed\n");
916  return FALSE;
917  }
918 
919  if (dwDisposition & REG_CREATED_NEW_KEY)
920  {
921  /* per default move to bitbucket */
922  dwNukeOnDelete = 0;
923  RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
924  /* per default unlimited size */
925  dwSize = -1;
926  RegSetValueExW(hKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
927  RegCloseKey(hKey);
928  return TRUE;
929  }
930  else
931  {
932  dwSize = sizeof(dwNukeOnDelete);
933  ret = RegQueryValueExW(hKey, L"NukeOnDelete", NULL, &dwType, (LPBYTE)&dwNukeOnDelete, &dwSize);
934  if (ret != ERROR_SUCCESS)
935  {
936  if (ret == ERROR_FILE_NOT_FOUND)
937  {
938  /* restore key and enable bitbucket */
939  dwNukeOnDelete = 0;
940  RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
941  }
942  RegCloseKey(hKey);
943  return TRUE;
944  }
945  else if (dwNukeOnDelete)
946  {
947  /* do not delete to bitbucket */
948  RegCloseKey(hKey);
949  return FALSE;
950  }
951  /* FIXME
952  * check if bitbucket is full
953  */
954  RegCloseKey(hKey);
955  return TRUE;
956  }
957 }
958 
959 BOOL
961 {
962  TRACE("(%s)\n", debugstr_w(wszPath));
963  return DeleteFileToRecycleBin(wszPath);
964 }
965 
966 /*************************************************************************
967  * SHUpdateCRecycleBinIcon [SHELL32.@]
968  *
969  * Undocumented
970  */
972 {
973  FIXME("stub\n");
974 
975  return S_OK;
976 }
977 
978 /*************************************************************************
979  * SHEmptyRecycleBinA (SHELL32.@)
980  */
982 {
983  LPWSTR szRootPathW = NULL;
984  int len;
985  HRESULT hr;
986 
987  TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_a(pszRootPath), dwFlags);
988 
989  if (pszRootPath)
990  {
991  len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
992  if (len == 0)
994  szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
995  if (!szRootPathW)
996  return E_OUTOFMEMORY;
997  if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
998  {
999  HeapFree(GetProcessHeap(), 0, szRootPathW);
1000  return HRESULT_FROM_WIN32(GetLastError());
1001  }
1002  }
1003 
1004  hr = SHEmptyRecycleBinW(hwnd, szRootPathW, dwFlags);
1005  HeapFree(GetProcessHeap(), 0, szRootPathW);
1006 
1007  return hr;
1008 }
1009 
1011 {
1012  WCHAR szPath[MAX_PATH] = {0}, szBuffer[MAX_PATH];
1013  DWORD dwSize, dwType, count;
1014  LONG ret;
1015  IShellFolder *pDesktop, *pRecycleBin;
1016  PIDLIST_ABSOLUTE pidlRecycleBin;
1017  PITEMID_CHILD pidl;
1018  HRESULT hr = S_OK;
1019  LPENUMIDLIST penumFiles;
1020  STRRET StrRet;
1021 
1022  TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_w(pszRootPath), dwFlags);
1023 
1024  if (!(dwFlags & SHERB_NOCONFIRMATION))
1025  {
1026  hr = SHGetDesktopFolder(&pDesktop);
1027  if (FAILED(hr))
1028  return hr;
1029  hr = SHGetFolderLocation(NULL, CSIDL_BITBUCKET, NULL, 0, &pidlRecycleBin);
1030  if (FAILED(hr))
1031  {
1032  pDesktop->Release();
1033  return hr;
1034  }
1035  hr = pDesktop->BindToObject(pidlRecycleBin, NULL, IID_PPV_ARG(IShellFolder, &pRecycleBin));
1036  CoTaskMemFree(pidlRecycleBin);
1037  pDesktop->Release();
1038  if (FAILED(hr))
1039  return hr;
1040  hr = pRecycleBin->EnumObjects(hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penumFiles);
1041  if (FAILED(hr))
1042  {
1043  pRecycleBin->Release();
1044  return hr;
1045  }
1046 
1047  count = 0;
1048  if (hr != S_FALSE)
1049  {
1050  while (penumFiles->Next(1, &pidl, NULL) == S_OK)
1051  {
1052  count++;
1053  pRecycleBin->GetDisplayNameOf(pidl, SHGDN_NORMAL, &StrRet);
1054  StrRetToBuf(&StrRet, pidl, szBuffer, _countof(szBuffer));
1055  CoTaskMemFree(pidl);
1056  }
1057  penumFiles->Release();
1058  }
1059  pRecycleBin->Release();
1060 
1061  switch (count)
1062  {
1063  case 0:
1064  /* no files, don't need confirmation */
1065  break;
1066 
1067  case 1:
1068  /* we have only one item inside the bin, so show a message box with its name */
1070  MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
1071  {
1072  return S_OK;
1073  }
1074  break;
1075 
1076  default:
1077  /* we have more than one item, so show a message box with the count of the items */
1078  StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%u", count);
1080  MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
1081  {
1082  return S_OK;
1083  }
1084  break;
1085  }
1086  }
1087 
1089  {
1090  ret = EmptyRecycleBinW(pszRootPath);
1091  }
1092  else
1093  {
1094  /* FIXME
1095  * show a progress dialog
1096  */
1097  ret = EmptyRecycleBinW(pszRootPath);
1098  }
1099 
1100  if (!ret)
1101  return HRESULT_FROM_WIN32(GetLastError());
1102 
1103  if (!(dwFlags & SHERB_NOSOUND))
1104  {
1105  dwSize = sizeof(szPath);
1107  L"AppEvents\\Schemes\\Apps\\Explorer\\EmptyRecycleBin\\.Current",
1108  NULL,
1109  RRF_RT_REG_SZ,
1110  &dwType,
1111  (PVOID)szPath,
1112  &dwSize);
1113  if (ret != ERROR_SUCCESS)
1114  return S_OK;
1115 
1116  if (dwType != REG_EXPAND_SZ) /* type dismatch */
1117  return S_OK;
1118 
1119  szPath[_countof(szPath)-1] = L'\0';
1121  }
1122  return S_OK;
1123 }
1124 
1126 {
1127  LPWSTR szRootPathW = NULL;
1128  int len;
1129  HRESULT hr;
1130 
1131  TRACE("%s, %p\n", debugstr_a(pszRootPath), pSHQueryRBInfo);
1132 
1133  if (pszRootPath)
1134  {
1135  len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
1136  if (len == 0)
1137  return HRESULT_FROM_WIN32(GetLastError());
1138  szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
1139  if (!szRootPathW)
1140  return E_OUTOFMEMORY;
1141  if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
1142  {
1143  HeapFree(GetProcessHeap(), 0, szRootPathW);
1144  return HRESULT_FROM_WIN32(GetLastError());
1145  }
1146  }
1147 
1148  hr = SHQueryRecycleBinW(szRootPathW, pSHQueryRBInfo);
1149  HeapFree(GetProcessHeap(), 0, szRootPathW);
1150 
1151  return hr;
1152 }
1153 
1155 {
1156  FIXME("%s, %p - stub\n", debugstr_w(pszRootPath), pSHQueryRBInfo);
1157 
1158  if (!(pszRootPath) || (pszRootPath[0] == 0) ||
1159  !(pSHQueryRBInfo) || (pSHQueryRBInfo->cbSize < sizeof(SHQUERYRBINFO)))
1160  {
1161  return E_INVALIDARG;
1162  }
1163 
1164  pSHQueryRBInfo->i64Size = 0;
1165  pSHQueryRBInfo->i64NumItems = 0;
1166 
1167  return S_OK;
1168 }
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:209
const DOCKBAR PVOID HWND HWND * hwnd
Definition: tooldock.h:22
#define IN
Definition: typedefs.h:38
#define MFT_STRING
Definition: winuser.h:741
DWORD cbSize
Definition: shellapi.h:377
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
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:2162
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:422
#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)
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:99
#define _countof(array)
Definition: fontsub.cpp:30
#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:111
#define IDS_RESTORE
Definition: shresdef.h:210
#define LVCFMT_RIGHT
Definition: commctrl.h:2571
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:2570
#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:1059
_Inout_ __drv_aliasesMem PSLIST_ENTRY _Inout_ PSLIST_ENTRY _In_ ULONG Count
Definition: exfuncs.h:1015
#define ZeroMemory
Definition: winbase.h:1635
#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:3243
#define CSIDL_BITBUCKET
Definition: shlobj.h:2013
#define MAKE_COMPARE_HRESULT(x)
Definition: shellutils.h:380
UINT_PTR WPARAM
Definition: windef.h:207
virtual HRESULT WINAPI Initialize(LPCITEMIDLIST pidl)
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:60
#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:211
HRESULT WINAPI SHCreateShellFolderView(const SFV_CREATE *pcsfv, IShellView **ppsv)
Definition: CDefView.cpp:3450
#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:52
#define E_OUTOFMEMORY
Definition: ddrawi.h:100
#define MFS_ENABLED
Definition: winuser.h:745
HINSTANCE shell32_hInstance
Definition: misc.cpp:82
#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
#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
#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:110
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:171
#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
_Check_return_ _CRTIMP _CONST_RETURN wchar_t *__cdecl wcsrchr(_In_z_ const wchar_t *_Str, _In_ wchar_t _Ch)
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:157
#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:66
BOOL WINAPI CloseRecycleBinHandle(IN HANDLE hDeletedFile)
Definition: recyclebin.c:12
#define TRACE(s)
Definition: solgame.cpp:4
virtual HRESULT WINAPI EnumSearches(IEnumExtraSearch **ppenum)
static LPSTR pName
Definition: security.c:75
BOOL WINAPI FileTimeToSystemTime(IN CONST FILETIME *lpFileTime, OUT LPSYSTEMTIME lpSystemTime)
Definition: time.c:178
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:395
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:77
#define COLUMN_NAME
Definition: CRecycleBin.cpp:52
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:35
#define MAX_PATH
Definition: compat.h:26
#define swprintf(buf, format,...)
Definition: sprintf.c:56
#define WINAPI
Definition: msvc.h:8
BOOL WINAPI RestoreFile(IN HANDLE hDeletedFile)
Definition: recyclebin.c:366
int ShellMessageBoxW(HINSTANCE hInstance, HWND hWnd, LPCWSTR lpText, LPCWSTR lpCaption, UINT uType,...)
Definition: shellord.c:337
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
int ret
#define StringCbCopy
Definition: strsafe.h:155
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)
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:173
#define IDS_SHV_COLUMN_MODIFIED
Definition: shresdef.h:46
#define wcsicmp
Definition: string.h:1152
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:109
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:59
HRESULT WINAPI SHEmptyRecycleBinW(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags)
LPCWSTR szPath
Definition: env.c:35
LPITEMIDLIST WINAPI ILClone(LPCITEMIDLIST pidl)
Definition: pidl.c:228
virtual HRESULT WINAPI GetCurFolder(LPITEMIDLIST *pidl)
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)
BOOL WINAPI InsertMenuItemW(_In_ HMENU, _In_ UINT, _In_ BOOL, _In_ LPCMENUITEMINFOW)
#define CWM_GETISHELLBROWSER
Definition: undocshell.h:185
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:100
#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:1012
#define HIWORD(l)
Definition: typedefs.h:246
unsigned int ULONG
Definition: retypes.h:1
HRESULT WINAPI SHGetFolderLocation(HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwReserved, LPITEMIDLIST *ppidl)
Definition: shellpath.c:2598
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
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:394
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:57
#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