dlls/shell32/recyclebin.c

   1 /*
   2  * Trash virtual folder support
   3  *
   4  * Copyright (C) 2006 Mikolaj Zalewski
   5  * Copyright 2011 Jay Yang
   6  * Copyright 2021 Alexandre Julliard
   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 #define COBJMACROS
  24
  25 #include <stdarg.h>
  26
  27 #include "winerror.h"
  28 #include "windef.h"
  29 #include "winbase.h"
  30 #include "winternl.h"
  31 #include "winreg.h"
  32 #include "winuser.h"
  33 #include "shlwapi.h"
  34 #include "ntquery.h"
  35 #include "shlobj.h"
  36 #include "shresdef.h"
  37 #include "shellfolder.h"
  38 #include "shellapi.h"
  39 #include "knownfolders.h"
  40 #include "wine/debug.h"
  41
  42 #include "shell32_main.h"
  43 #include "pidl.h"
  44 #include "shfldr.h"
  45
  46 WINE_DEFAULT_DEBUG_CHANNEL(recyclebin);
  47
  48 static const shvheader RecycleBinColumns[] =
  49 {
  50     {&FMTID_Storage,   PID_STG_NAME,       IDS_SHV_COLUMN1,        SHCOLSTATE_TYPE_STR|SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  30},
  51     {&FMTID_Displaced, PID_DISPLACED_FROM, IDS_SHV_COLUMN_DELFROM, SHCOLSTATE_TYPE_STR|SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  30},
  52     {&FMTID_Displaced, PID_DISPLACED_DATE, IDS_SHV_COLUMN_DELDATE, SHCOLSTATE_TYPE_DATE|SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  20},
  53     {&FMTID_Storage,   PID_STG_SIZE,       IDS_SHV_COLUMN2,        SHCOLSTATE_TYPE_INT|SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 20},
  54     {&FMTID_Storage,   PID_STG_STORAGETYPE,IDS_SHV_COLUMN3,        SHCOLSTATE_TYPE_INT|SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  20},
  55     {&FMTID_Storage,   PID_STG_WRITETIME,  IDS_SHV_COLUMN4,        SHCOLSTATE_TYPE_DATE|SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  20},
  56 /*    {&FMTID_Storage,   PID_STG_CREATETIME, "creation time",  SHCOLSTATE_TYPE_DATE,                        LVCFMT_LEFT,  20}, */
  57 /*    {&FMTID_Storage,   PID_STG_ATTRIBUTES, "attribs",        SHCOLSTATE_TYPE_STR,                         LVCFMT_LEFT,  20},       */
  58 };
  59
  60 #define COLUMN_NAME    0
  61 #define COLUMN_DELFROM 1
  62 #define COLUMN_DATEDEL 2
  63 #define COLUMN_SIZE    3
  64 #define COLUMN_TYPE    4
  65 #define COLUMN_MTIME   5
  66
  67 #define COLUMNS_COUNT  6
  68
  69 static const WIN32_FIND_DATAW *get_trash_item_data( LPCITEMIDLIST id )
  70 {
  71     if (id->mkid.cb < 2 + 1 + sizeof(WIN32_FIND_DATAW) + 2) return NULL;
  72     if (id->mkid.abID[0] != 0) return NULL;
  73     return (const WIN32_FIND_DATAW *)(id->mkid.abID + 1);
  74 }
  75
  76 static INIT_ONCE trash_dir_once;
  77 static WCHAR *trash_dir;
  78 static WCHAR *trash_info_dir;
  79 static ULONG random_seed;
  80
  81 extern void CDECL wine_get_host_version( const char **sysname, const char **release );
  82
  83 static BOOL is_macos(void)
  84 {
  85     const char *sysname;
  86
  87     wine_get_host_version( &sysname, NULL );
  88     return !strcmp( sysname, "Darwin" );
  89 }
  90
  91 static BOOL WINAPI init_trash_dirs( INIT_ONCE *once, void *param, void **context )
  92 {
  93     const WCHAR *home = _wgetenv( L"WINEHOMEDIR" );
  94     WCHAR *info = NULL, *files = NULL;
  95     ULONG len;
  96
  97     if (!home) return TRUE;
  98     if (is_macos())
  99     {
 100         files = malloc( (wcslen(home) + ARRAY_SIZE(L"\\.Trash")) * sizeof(WCHAR) );
 101         lstrcpyW( files, home );
 102         lstrcatW( files, L"\\.Trash" );
 103         files[1] = '\\';  /* change \??\ to \\?\ */
 104     }
 105     else
 106     {
 107         const WCHAR *data_home = _wgetenv( L"XDG_DATA_HOME" );
 108         const WCHAR *fmt = L"%s/.local/share/Trash";
 109         WCHAR *p;
 110
 111         if (data_home && data_home[0] == '/')
 112         {
 113             home = data_home;
 114             fmt = L"\\??\\unix%s/Trash";
 115         }
 116         len = lstrlenW(home) + lstrlenW(fmt) + 7;
 117         files = malloc( len * sizeof(WCHAR) );
 118         swprintf( files, len, fmt, home );
 119         files[1] = '\\';  /* change \??\ to \\?\ */
 120         for (p = files; *p; p++) if (*p == '/') *p = '\\';
 121         CreateDirectoryW( files, NULL );
 122         info = malloc( len * sizeof(WCHAR) );
 123         lstrcpyW( info, files );
 124         lstrcatW( files, L"\\files" );
 125         lstrcatW( info, L"\\info" );
 126         if (!CreateDirectoryW( info, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS) goto done;
 127         trash_info_dir = info;
 128     }
 129
 130     if (!CreateDirectoryW( files, NULL ) && GetLastError() != ERROR_ALREADY_EXISTS) goto done;
 131     trash_dir = files;
 132     random_seed = GetTickCount();
 133     return TRUE;
 134
 135 done:
 136     free( files );
 137     free( info );
 138     return TRUE;
 139 }
 140
 141 BOOL is_trash_available(void)
 142 {
 143     InitOnceExecuteOnce( &trash_dir_once, init_trash_dirs, NULL, NULL );
 144     return trash_dir != NULL;
 145 }
 146
 147 static void encode( const char *src, char *dst )
 148 {
 149     static const char escape_chars[] = "^&`{}|[]'<>\\#%\"+";
 150     static const char hexchars[] = "0123456789ABCDEF";
 151
 152     for ( ; *src; src++)
 153     {
 154         if (*src <= 0x20 || *src >= 0x7f || strchr( escape_chars, *src ))
 155         {
 156             *dst++ = '%';
 157             *dst++ = hexchars[(unsigned char)*src / 16];
 158             *dst++ = hexchars[(unsigned char)*src % 16];
 159         }
 160         else *dst++ = *src;
 161     }
 162     *dst = 0;
 163 }
 164
 165 static char *decode( char *buf )
 166 {
 167     const char *src = buf;
 168     char *dst = buf;  /* decode in place */
 169
 170     while (*src)
 171     {
 172         if (*src == '%')
 173         {
 174             unsigned char v;
 175
 176             if (src[1] >= '0' && src[1] <= '9') v = src[1] - '0';
 177             else if (src[1] >= 'A' && src[1] <= 'F') v = src[1] - 'A' + 10;
 178             else if (src[1] >= 'a' && src[1] <= 'f') v = src[1] - 'a' + 10;
 179             else goto next;
 180             v <<= 4;
 181             if (src[2] >= '0' && src[2] <= '9') v += src[2] - '0';
 182             else if (src[2] >= 'A' && src[2] <= 'F') v += src[2] - 'A' + 10;
 183             else if (src[2] >= 'a' && src[2] <= 'f') v += src[2] - 'a' + 10;
 184             else goto next;
 185             *dst++ = v;
 186         next:
 187             if (src[1] && src[2]) src += 3;
 188             else break;
 189         }
 190         else *dst++ = *src++;
 191     }
 192     *dst = 0;
 193     return buf;
 194 }
 195
 196 static BOOL write_trashinfo_file( HANDLE handle, const WCHAR *orig_path )
 197 {
 198     char *path, *buffer;
 199     SYSTEMTIME now;
 200
 201     if (!(path = wine_get_unix_file_name( orig_path ))) return FALSE;
 202     GetLocalTime( &now );
 203
 204     buffer = malloc( strlen(path) * 3 + 128 );
 205     strcpy( buffer, "[Trash Info]\nPath=" );
 206     encode( path, buffer + strlen(buffer) );
 207     sprintf( buffer + strlen(buffer), "\nDeletionDate=%04u-%02u-%02uT%02u:%02u:%02u\n",
 208              now.wYear, now.wMonth, now.wDay, now.wHour, now.wMinute, now.wSecond);
 209     WriteFile( handle, buffer, strlen(buffer), NULL, NULL );
 210     heap_free( path );
 211     free( buffer );
 212     return TRUE;
 213 }
 214
 215 static void read_trashinfo_file( HANDLE handle, WIN32_FIND_DATAW *data )
 216 {
 217     ULONG size;
 218     WCHAR *path;
 219     char *buffer, *next, *p;
 220     int header = 0;
 221
 222     size = GetFileSize( handle, NULL );
 223     if (!(buffer = malloc( size + 1 ))) return;
 224     if (!ReadFile( handle, buffer, size, &size, NULL )) size = 0;
 225     buffer[size] = 0;
 226     next = buffer;
 227     while (next)
 228     {
 229         p = next;
 230         if ((next = strchr( next, '\n' ))) *next++ = 0;
 231         while (*p == ' ' || *p == '\t') p++;
 232         if (!strncmp( p, "[Trash Info]", 12 ))
 233         {
 234             header++;
 235             continue;
 236         }
 237         if (header && !strncmp( p, "Path=", 5 ))
 238         {
 239             p += 5;
 240             if ((path = wine_get_dos_file_name( decode( p ))))
 241             {
 242                 lstrcpynW( data->cFileName, path, MAX_PATH );
 243                 heap_free( path );
 244             }
 245             else
 246             {
 247                 /* show only the file name */
 248                 char *file = strrchr( p, '/' );
 249                 if (!file) file = p;
 250                 else file++;
 251                 MultiByteToWideChar( CP_UNIXCP, 0, file, -1, data->cFileName, MAX_PATH );
 252             }
 253             continue;
 254         }
 255         if (header && !strncmp( p, "DeletionDate=", 13 ))
 256         {
 257             int year, mon, day, hour, min, sec;
 258             if (sscanf( p + 13, "%d-%d-%dT%d:%d:%d", &year, &mon, &day, &hour, &min, &sec ) == 6)
 259             {
 260                 SYSTEMTIME time = { year, mon, 0, day, hour, min, sec };
 261                 FILETIME ft;
 262                 if (SystemTimeToFileTime( &time, &ft ))
 263                     LocalFileTimeToFileTime( &ft, &data->ftLastAccessTime );
 264             }
 265         }
 266     }
 267     free( buffer );
 268 }
 269
 270
 271 BOOL trash_file( const WCHAR *path )
 272 {
 273     WCHAR *dest = NULL, *file = PathFindFileNameW( path );
 274     BOOL ret = TRUE;
 275     ULONG i, len;
 276
 277     InitOnceExecuteOnce( &trash_dir_once, init_trash_dirs, NULL, NULL );
 278     if (!trash_dir) return FALSE;
 279
 280     len = lstrlenW(trash_dir) + lstrlenW(file) + 11;
 281     dest = malloc( len * sizeof(WCHAR) );
 282
 283     if (trash_info_dir)
 284     {
 285         HANDLE handle;
 286         ULONG infolen = lstrlenW(trash_info_dir) + lstrlenW(file) + 21;
 287         WCHAR *info = malloc( infolen * sizeof(WCHAR) );
 288
 289         swprintf( info, infolen, L"%s\\%s.trashinfo", trash_info_dir, file );
 290         for (i = 0; i < 1000; i++)
 291         {
 292             handle = CreateFileW( info, GENERIC_WRITE, 0, NULL, CREATE_NEW, 0, 0 );
 293             if (handle != INVALID_HANDLE_VALUE) break;
 294             swprintf( info, infolen, L"%s\\%s-%08x.trashinfo", trash_info_dir, file, RtlRandom( &random_seed ));
 295         }
 296         if (handle != INVALID_HANDLE_VALUE)
 297         {
 298             if ((ret = write_trashinfo_file( handle, path )))
 299             {
 300                 ULONG namelen = lstrlenW(info) - lstrlenW(trash_info_dir) - 10 /* .trashinfo */;
 301                 swprintf( dest, len, L"%s%.*s", trash_dir, namelen, info + lstrlenW(trash_info_dir) );
 302                 ret = MoveFileW( path, dest );
 303             }
 304             CloseHandle( handle );
 305             if (!ret) DeleteFileW( info );
 306         }
 307     }
 308     else
 309     {
 310         swprintf( dest, len, L"%s\\%s", trash_dir, file );
 311         for (i = 0; i < 1000; i++)
 312         {
 313             ret = MoveFileW( path, dest );
 314             if (ret || GetLastError() != ERROR_ALREADY_EXISTS) break;
 315             swprintf( dest, len, L"%s\\%s-%08x", trash_dir, file, RtlRandom( &random_seed ));
 316         }
 317     }
 318     if (ret) TRACE( "%s -> %s\n", debugstr_w(path), debugstr_w(dest) );
 319     free( dest );
 320     return ret;
 321 }
 322
 323 static BOOL get_trash_item_info( const WCHAR *filename, WIN32_FIND_DATAW *data )
 324 {
 325     if (!trash_info_dir)
 326     {
 327         return !!wcscmp( filename, L".DS_Store" );
 328     }
 329     else
 330     {
 331         HANDLE handle;
 332         ULONG len = lstrlenW(trash_info_dir) + lstrlenW(filename) + 12;
 333         WCHAR *info = malloc( len * sizeof(WCHAR) );
 334
 335         swprintf( info, len, L"%s\\%s.trashinfo", trash_info_dir, filename );
 336         handle = CreateFileW( info, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0 );
 337         free( info );
 338         if (handle == INVALID_HANDLE_VALUE) return FALSE;
 339         read_trashinfo_file( handle, data );
 340         CloseHandle( handle );
 341         return TRUE;
 342     }
 343 }
 344
 345 static HRESULT add_trash_item( WIN32_FIND_DATAW *orig_data, LPITEMIDLIST **pidls,
 346                                ULONG *count, ULONG *size )
 347 {
 348     ITEMIDLIST *pidl;
 349     WIN32_FIND_DATAW *data;
 350     const WCHAR *filename = orig_data->cFileName;
 351     ULONG len = offsetof( ITEMIDLIST, mkid.abID[1 + sizeof(*data) + (lstrlenW(filename)+1) * sizeof(WCHAR)]);
 352
 353     if (!(pidl = SHAlloc( len + 2 ))) return E_OUTOFMEMORY;
 354     pidl->mkid.cb = len;
 355     pidl->mkid.abID[0] = 0;
 356     data = (WIN32_FIND_DATAW *)(pidl->mkid.abID + 1);
 357     memcpy( data, orig_data, sizeof(*data) );
 358     lstrcpyW( (WCHAR *)(data + 1), filename );
 359     *(USHORT *)((char *)pidl + len) = 0;
 360
 361     if (get_trash_item_info( filename, data ))
 362     {
 363         if (*count == *size)
 364         {
 365             LPITEMIDLIST *new;
 366
 367             *size = max( *size * 2, 32 );
 368             new = realloc( *pidls, *size * sizeof(**pidls) );
 369             if (!new)
 370             {
 371                 SHFree( pidl );
 372                 return E_OUTOFMEMORY;
 373             }
 374             *pidls = new;
 375         }
 376         (*pidls)[(*count)++] = pidl;
 377     }
 378     else SHFree( pidl );  /* ignore it */
 379     return S_OK;
 380 }
 381
 382 static HRESULT enum_trash_items( LPITEMIDLIST **pidls, int *ret_count )
 383 {
 384     HANDLE handle;
 385     WCHAR *file;
 386     WIN32_FIND_DATAW data;
 387     LPITEMIDLIST *ret = NULL;
 388     ULONG count = 0, size = 0;
 389     HRESULT hr = S_OK;
 390
 391     InitOnceExecuteOnce( &trash_dir_once, init_trash_dirs, NULL, NULL );
 392     if (!trash_dir) return E_FAIL;
 393
 394     *pidls = NULL;
 395     file = malloc( (wcslen(trash_dir) + ARRAY_SIZE(L"\\*")) * sizeof(WCHAR) );
 396     lstrcpyW( file, trash_dir );
 397     lstrcatW( file, L"\\*" );
 398     handle = FindFirstFileW( file, &data );
 399     if (handle != INVALID_HANDLE_VALUE)
 400     {
 401         do
 402         {
 403             if (!wcscmp( data.cFileName, L"." )) continue;
 404             if (!wcscmp( data.cFileName, L".." )) continue;
 405             hr = add_trash_item( &data, &ret, &count, &size );
 406         } while (hr == S_OK && FindNextFileW( handle, &data ));
 407         FindClose( handle );
 408     }
 409
 410     if (FAILED(hr)) while (count) SHFree( &ret[--count] );
 411     else if (count)
 412     {
 413         *pidls = SHAlloc( count * sizeof(**pidls) );
 414         memcpy( *pidls, ret, count * sizeof(**pidls) );
 415     }
 416     free( ret );
 417     *ret_count = count;
 418     return hr;
 419 }
 420
 421 static void remove_trashinfo( const WCHAR *filename )
 422 {
 423     WCHAR *info;
 424     ULONG len;
 425
 426     if (!trash_info_dir) return;
 427     len = lstrlenW(trash_info_dir) + lstrlenW(filename) + 12;
 428     info = malloc( len * sizeof(WCHAR) );
 429     swprintf( info, len, L"%s\\%s.trashinfo", trash_info_dir, filename );
 430     DeleteFileW( info );
 431     free( info );
 432 }
 433
 434 static HRESULT restore_trash_item( LPCITEMIDLIST pidl )
 435 {
 436     const WIN32_FIND_DATAW *data = get_trash_item_data( pidl );
 437     WCHAR *from, *filename = (WCHAR *)(data + 1);
 438     ULONG len;
 439
 440     if (!wcschr( data->cFileName, '\\' ))
 441     {
 442         FIXME( "original name for %s not available\n", debugstr_w(data->cFileName) );
 443         return E_NOTIMPL;
 444     }
 445     len = lstrlenW(trash_dir) + lstrlenW(filename) + 2;
 446     from = malloc( len * sizeof(WCHAR) );
 447     swprintf( from, len, L"%s\\%s", trash_dir, filename );
 448     if (MoveFileW( from, data->cFileName )) remove_trashinfo( filename );
 449     else WARN( "failed to restore %s to %s\n", debugstr_w(from), debugstr_w(data->cFileName) );
 450     free( from );
 451     return S_OK;
 452 }
 453
 454 static HRESULT erase_trash_item( LPCITEMIDLIST pidl )
 455 {
 456     const WIN32_FIND_DATAW *data = get_trash_item_data( pidl );
 457     WCHAR *from, *filename = (WCHAR *)(data + 1);
 458     ULONG len = lstrlenW(trash_dir) + lstrlenW(filename) + 2;
 459
 460     from = malloc( len * sizeof(WCHAR) );
 461     swprintf( from, len, L"%s\\%s", trash_dir, filename );
 462     if (DeleteFileW( from )) remove_trashinfo( filename );
 463     free( from );
 464     return S_OK;
 465 }
 466
 467
 468 static HRESULT FormatDateTime(LPWSTR buffer, int size, FILETIME ft)
 469 {
 470     FILETIME lft;
 471     SYSTEMTIME time;
 472     int ret;
 473
 474     FileTimeToLocalFileTime(&ft, &lft);
 475     FileTimeToSystemTime(&lft, &time);
 476
 477     ret = GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &time, NULL, buffer, size);
 478     if (ret>0 && ret<size)
 479     {
 480         /* Append space + time without seconds */
 481         buffer[ret-1] = ' ';
 482         GetTimeFormatW(LOCALE_USER_DEFAULT, TIME_NOSECONDS, &time, NULL, &buffer[ret], size - ret);
 483     }
 484
 485     return (ret!=0 ? E_FAIL : S_OK);
 486 }
 487
 488 typedef struct tagRecycleBinMenu
 489 {
 490     IContextMenu2 IContextMenu2_iface;
 491     LONG refCount;
 492
 493     UINT cidl;
 494     LPITEMIDLIST *apidl;
 495     IShellFolder2 *folder;
 496 } RecycleBinMenu;
 497
 498 static const IContextMenu2Vtbl recycleBinMenuVtbl;
 499
 500 static RecycleBinMenu *impl_from_IContextMenu2(IContextMenu2 *iface)
 501 {
 502     return CONTAINING_RECORD(iface, RecycleBinMenu, IContextMenu2_iface);
 503 }
 504
 505 static IContextMenu2* RecycleBinMenu_Constructor(UINT cidl, LPCITEMIDLIST *apidl, IShellFolder2 *folder)
 506 {
 507     RecycleBinMenu *This = SHAlloc(sizeof(RecycleBinMenu));
 508     TRACE("(%u,%p)\n",cidl,apidl);
 509     This->IContextMenu2_iface.lpVtbl = &recycleBinMenuVtbl;
 510     This->cidl = cidl;
 511     This->apidl = _ILCopyaPidl(apidl,cidl);
 512     IShellFolder2_AddRef(folder);
 513     This->folder = folder;
 514     This->refCount = 1;
 515     return &This->IContextMenu2_iface;
 516 }
 517
 518 static HRESULT WINAPI RecycleBinMenu_QueryInterface(IContextMenu2 *iface,
 519                                                     REFIID riid,
 520                                                     void **ppvObject)
 521 {
 522     RecycleBinMenu *This = impl_from_IContextMenu2(iface);
 523     TRACE("(%p, %s, %p) - stub\n", This, debugstr_guid(riid), ppvObject);
 524     return E_NOTIMPL;
 525 }
 526
 527 static ULONG WINAPI RecycleBinMenu_AddRef(IContextMenu2 *iface)
 528 {
 529     RecycleBinMenu *This = impl_from_IContextMenu2(iface);
 530     TRACE("(%p)\n", This);
 531     return InterlockedIncrement(&This->refCount);
 532
 533 }
 534
 535 static ULONG WINAPI RecycleBinMenu_Release(IContextMenu2 *iface)
 536 {
 537     RecycleBinMenu *This = impl_from_IContextMenu2(iface);
 538     UINT result;
 539     TRACE("(%p)\n", This);
 540     result = InterlockedDecrement(&This->refCount);
 541     if (result == 0)
 542     {
 543         TRACE("Destroying object\n");
 544         _ILFreeaPidl(This->apidl,This->cidl);
 545         IShellFolder2_Release(This->folder);
 546         SHFree(This);
 547     }
 548     return result;
 549 }
 550
 551 static HRESULT WINAPI RecycleBinMenu_QueryContextMenu(IContextMenu2 *iface,
 552                                                       HMENU hmenu,
 553                                                       UINT indexMenu,
 554                                                       UINT idCmdFirst,
 555                                                       UINT idCmdLast,
 556                                                       UINT uFlags)
 557 {
 558     HMENU menures = LoadMenuW(shell32_hInstance,MAKEINTRESOURCEW(MENU_RECYCLEBIN));
 559     if(uFlags & CMF_DEFAULTONLY)
 560         return E_NOTIMPL;
 561     else{
 562         UINT idMax = Shell_MergeMenus(hmenu,GetSubMenu(menures,0),indexMenu,idCmdFirst,idCmdLast,MM_SUBMENUSHAVEIDS);
 563         TRACE("Added %d id(s)\n",idMax-idCmdFirst);
 564         return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, idMax-idCmdFirst+1);
 565     }
 566 }
 567
 568 static void DoErase(RecycleBinMenu *This)
 569 {
 570     ISFHelper *helper;
 571     IShellFolder2_QueryInterface(This->folder,&IID_ISFHelper,(void**)&helper);
 572     if(helper)
 573         ISFHelper_DeleteItems(helper,This->cidl,(LPCITEMIDLIST*)This->apidl);
 574 }
 575
 576 static void DoRestore(RecycleBinMenu *This)
 577 {
 578
 579     /*TODO add prompts*/
 580     UINT i;
 581     for(i=0;i<This->cidl;i++)
 582     {
 583         const WIN32_FIND_DATAW *data = get_trash_item_data( This->apidl[i] );
 584
 585         if(PathFileExistsW(data->cFileName))
 586         {
 587             PIDLIST_ABSOLUTE dest_pidl = ILCreateFromPathW(data->cFileName);
 588             WCHAR message[100];
 589             WCHAR caption[50];
 590             if(_ILIsFolder(ILFindLastID(dest_pidl)))
 591                 LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_OVERWRITEFOLDER, message, ARRAY_SIZE(message));
 592             else
 593                 LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_OVERWRITEFILE, message, ARRAY_SIZE(message));
 594             LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_OVERWRITE_CAPTION, caption, ARRAY_SIZE(caption));
 595
 596             if(ShellMessageBoxW(shell32_hInstance,GetActiveWindow(),message,
 597                                 caption,MB_YESNO|MB_ICONEXCLAMATION,
 598                                 data->cFileName)!=IDYES)
 599                 continue;
 600         }
 601         if(SUCCEEDED(restore_trash_item(This->apidl[i])))
 602         {
 603             IPersistFolder2 *persist;
 604             LPITEMIDLIST root_pidl;
 605             PIDLIST_ABSOLUTE dest_pidl = ILCreateFromPathW(data->cFileName);
 606             BOOL is_folder = _ILIsFolder(ILFindLastID(dest_pidl));
 607             IShellFolder2_QueryInterface(This->folder,&IID_IPersistFolder2,
 608                                          (void**)&persist);
 609             IPersistFolder2_GetCurFolder(persist,&root_pidl);
 610             SHChangeNotify(is_folder ? SHCNE_RMDIR : SHCNE_DELETE,
 611                            SHCNF_IDLIST,ILCombine(root_pidl,This->apidl[i]),0);
 612             SHChangeNotify(is_folder ? SHCNE_MKDIR : SHCNE_CREATE,
 613                            SHCNF_IDLIST,dest_pidl,0);
 614             ILFree(dest_pidl);
 615             ILFree(root_pidl);
 616         }
 617     }
 618 }
 619
 620 static HRESULT WINAPI RecycleBinMenu_InvokeCommand(IContextMenu2 *iface,
 621                                                    LPCMINVOKECOMMANDINFO pici)
 622 {
 623     RecycleBinMenu *This = impl_from_IContextMenu2(iface);
 624     LPCSTR verb = pici->lpVerb;
 625     if(IS_INTRESOURCE(verb))
 626     {
 627         switch(LOWORD(verb))
 628         {
 629         case IDM_RECYCLEBIN_ERASE:
 630             DoErase(This);
 631             break;
 632         case IDM_RECYCLEBIN_RESTORE:
 633             DoRestore(This);
 634             break;
 635         default:
 636             return E_NOTIMPL;
 637         }
 638     }
 639     return S_OK;
 640 }
 641
 642 static HRESULT WINAPI RecycleBinMenu_GetCommandString(IContextMenu2 *iface,
 643                                                       UINT_PTR idCmd,
 644                                                       UINT uType,
 645                                                       UINT *pwReserved,
 646                                                       LPSTR pszName,
 647                                                       UINT cchMax)
 648 {
 649     TRACE("(%p, %Iu, %u, %p, %s, %u) - stub\n",iface,idCmd,uType,pwReserved,debugstr_a(pszName),cchMax);
 650     return E_NOTIMPL;
 651 }
 652
 653 static HRESULT WINAPI RecycleBinMenu_HandleMenuMsg(IContextMenu2 *iface,
 654                                                    UINT uMsg, WPARAM wParam,
 655                                                    LPARAM lParam)
 656 {
 657     TRACE("(%p, %u, 0x%Ix, 0x%Ix) - stub\n",iface,uMsg,wParam,lParam);
 658     return E_NOTIMPL;
 659 }
 660
 661
 662 static const IContextMenu2Vtbl recycleBinMenuVtbl =
 663 {
 664     RecycleBinMenu_QueryInterface,
 665     RecycleBinMenu_AddRef,
 666     RecycleBinMenu_Release,
 667     RecycleBinMenu_QueryContextMenu,
 668     RecycleBinMenu_InvokeCommand,
 669     RecycleBinMenu_GetCommandString,
 670     RecycleBinMenu_HandleMenuMsg,
 671 };
 672
 673 /*
 674  * Recycle Bin folder
 675  */
 676
 677 typedef struct tagRecycleBin
 678 {
 679     IShellFolder2 IShellFolder2_iface;
 680     IPersistFolder2 IPersistFolder2_iface;
 681     ISFHelper ISFHelper_iface;
 682     LONG refCount;
 683
 684     LPITEMIDLIST pidl;
 685 } RecycleBin;
 686
 687 static const IShellFolder2Vtbl recycleBinVtbl;
 688 static const IPersistFolder2Vtbl recycleBinPersistVtbl;
 689 static const ISFHelperVtbl sfhelperVtbl;
 690
 691 static inline RecycleBin *impl_from_IShellFolder2(IShellFolder2 *iface)
 692 {
 693     return CONTAINING_RECORD(iface, RecycleBin, IShellFolder2_iface);
 694 }
 695
 696 static RecycleBin *impl_from_IPersistFolder2(IPersistFolder2 *iface)
 697 {
 698     return CONTAINING_RECORD(iface, RecycleBin, IPersistFolder2_iface);
 699 }
 700
 701 static RecycleBin *impl_from_ISFHelper(ISFHelper *iface)
 702 {
 703     return CONTAINING_RECORD(iface, RecycleBin, ISFHelper_iface);
 704 }
 705
 706 static void RecycleBin_Destructor(RecycleBin *This);
 707
 708 HRESULT WINAPI RecycleBin_Constructor(IUnknown *pUnkOuter, REFIID riid, LPVOID *ppOutput)
 709 {
 710     RecycleBin *obj;
 711     HRESULT ret;
 712     if (pUnkOuter)
 713         return CLASS_E_NOAGGREGATION;
 714
 715     obj = SHAlloc(sizeof(RecycleBin));
 716     if (obj == NULL)
 717         return E_OUTOFMEMORY;
 718     ZeroMemory(obj, sizeof(RecycleBin));
 719     obj->IShellFolder2_iface.lpVtbl = &recycleBinVtbl;
 720     obj->IPersistFolder2_iface.lpVtbl = &recycleBinPersistVtbl;
 721     obj->ISFHelper_iface.lpVtbl = &sfhelperVtbl;
 722     if (FAILED(ret = IPersistFolder2_QueryInterface(&obj->IPersistFolder2_iface, riid, ppOutput)))
 723     {
 724         RecycleBin_Destructor(obj);
 725         return ret;
 726     }
 727 /*    InterlockedIncrement(&objCount);*/
 728     return S_OK;
 729 }
 730
 731 static void RecycleBin_Destructor(RecycleBin *This)
 732 {
 733 /*    InterlockedDecrement(&objCount);*/
 734     SHFree(This->pidl);
 735     SHFree(This);
 736 }
 737
 738 static HRESULT WINAPI RecycleBin_QueryInterface(IShellFolder2 *iface, REFIID riid, void **ppvObject)
 739 {
 740     RecycleBin *This = impl_from_IShellFolder2(iface);
 741     TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppvObject);
 742
 743     *ppvObject = NULL;
 744     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IShellFolder)
 745             || IsEqualGUID(riid, &IID_IShellFolder2))
 746         *ppvObject = &This->IShellFolder2_iface;
 747
 748     if (IsEqualGUID(riid, &IID_IPersist) || IsEqualGUID(riid, &IID_IPersistFolder)
 749             || IsEqualGUID(riid, &IID_IPersistFolder2))
 750         *ppvObject = &This->IPersistFolder2_iface;
 751     if (IsEqualGUID(riid, &IID_ISFHelper))
 752         *ppvObject = &This->ISFHelper_iface;
 753
 754     if (*ppvObject != NULL)
 755     {
 756         IUnknown_AddRef((IUnknown *)*ppvObject);
 757         return S_OK;
 758     }
 759     WARN("no interface %s\n", debugstr_guid(riid));
 760     return E_NOINTERFACE;
 761 }
 762
 763 static ULONG WINAPI RecycleBin_AddRef(IShellFolder2 *iface)
 764 {
 765     RecycleBin *This = impl_from_IShellFolder2(iface);
 766     TRACE("(%p)\n", This);
 767     return InterlockedIncrement(&This->refCount);
 768 }
 769
 770 static ULONG WINAPI RecycleBin_Release(IShellFolder2 *iface)
 771 {
 772     RecycleBin *This = impl_from_IShellFolder2(iface);
 773     LONG result;
 774
 775     TRACE("(%p)\n", This);
 776     result = InterlockedDecrement(&This->refCount);
 777     if (result == 0)
 778     {
 779         TRACE("Destroy object\n");
 780         RecycleBin_Destructor(This);
 781     }
 782     return result;
 783 }
 784
 785 static HRESULT WINAPI RecycleBin_ParseDisplayName(IShellFolder2 *This, HWND hwnd, LPBC pbc,
 786             LPOLESTR pszDisplayName, ULONG *pchEaten, LPITEMIDLIST *ppidl,
 787             ULONG *pdwAttributes)
 788 {
 789     FIXME("stub\n");
 790     return E_NOTIMPL;
 791 }
 792
 793 static HRESULT WINAPI RecycleBin_EnumObjects(IShellFolder2 *iface, HWND hwnd, SHCONTF grfFlags, IEnumIDList **ppenumIDList)
 794 {
 795     RecycleBin *This = impl_from_IShellFolder2(iface);
 796     IEnumIDListImpl *list;
 797     LPITEMIDLIST *pidls;
 798     HRESULT ret = E_OUTOFMEMORY;
 799     int pidls_count = 0;
 800     int i=0;
 801
 802     TRACE("(%p, %p, %lx, %p)\n", This, hwnd, grfFlags, ppenumIDList);
 803
 804     *ppenumIDList = NULL;
 805     list = IEnumIDList_Constructor();
 806     if (!list)
 807         return E_OUTOFMEMORY;
 808
 809     if (grfFlags & SHCONTF_NONFOLDERS)
 810     {
 811         if (FAILED(ret = enum_trash_items(&pidls, &pidls_count)))
 812             goto failed;
 813         for (i=0; i<pidls_count; i++)
 814             if (!AddToEnumList(list, pidls[i]))
 815                 goto failed;
 816     }
 817
 818     *ppenumIDList = &list->IEnumIDList_iface;
 819     return S_OK;
 820
 821 failed:
 822     IEnumIDList_Release(&list->IEnumIDList_iface);
 823     for (; i<pidls_count; i++)
 824         ILFree(pidls[i]);
 825     SHFree(pidls);
 826     return ret;
 827 }
 828
 829 static HRESULT WINAPI RecycleBin_BindToObject(IShellFolder2 *This, LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
 830 {
 831     FIXME("(%p, %p, %p, %s, %p) - stub\n", This, pidl, pbc, debugstr_guid(riid), ppv);
 832     return E_NOTIMPL;
 833 }
 834
 835 static HRESULT WINAPI RecycleBin_BindToStorage(IShellFolder2 *This, LPCITEMIDLIST pidl, LPBC pbc, REFIID riid, void **ppv)
 836 {
 837     FIXME("(%p, %p, %p, %s, %p) - stub\n", This, pidl, pbc, debugstr_guid(riid), ppv);
 838     return E_NOTIMPL;
 839 }
 840
 841 static HRESULT WINAPI RecycleBin_CompareIDs(IShellFolder2 *iface, LPARAM lParam, LPCITEMIDLIST pidl1, LPCITEMIDLIST pidl2)
 842 {
 843     RecycleBin *This = impl_from_IShellFolder2(iface);
 844     int ret;
 845
 846     /* TODO */
 847     TRACE("(%p, %p, %p, %p)\n", This, (void *)lParam, pidl1, pidl2);
 848     if (pidl1->mkid.cb != pidl2->mkid.cb)
 849         return MAKE_HRESULT(SEVERITY_SUCCESS, 0, pidl1->mkid.cb - pidl2->mkid.cb);
 850     /* Looks too complicated, but in optimized memcpy we might get
 851      * a 32bit wide difference and would truncate it to 16 bit, so
 852      * erroneously returning equality. */
 853     ret = memcmp(pidl1->mkid.abID, pidl2->mkid.abID, pidl1->mkid.cb);
 854     if (ret < 0) ret = -1;
 855     if (ret > 0) ret =  1;
 856     return MAKE_HRESULT(SEVERITY_SUCCESS, 0, (unsigned short)ret);
 857 }
 858
 859 static HRESULT WINAPI RecycleBin_CreateViewObject(IShellFolder2 *iface, HWND hwndOwner, REFIID riid, void **ppv)
 860 {
 861     RecycleBin *This = impl_from_IShellFolder2(iface);
 862     HRESULT ret;
 863     TRACE("(%p, %p, %s, %p)\n", This, hwndOwner, debugstr_guid(riid), ppv);
 864
 865     *ppv = NULL;
 866     if (IsEqualGUID(riid, &IID_IShellView))
 867     {
 868         IShellView *tmp;
 869         CSFV sfv;
 870
 871         ZeroMemory(&sfv, sizeof(sfv));
 872         sfv.cbSize = sizeof(sfv);
 873         sfv.pshf = (IShellFolder *)&This->IShellFolder2_iface;
 874
 875         TRACE("Calling SHCreateShellFolderViewEx\n");
 876         ret = SHCreateShellFolderViewEx(&sfv, &tmp);
 877         TRACE("Result: %08x, output: %p\n", (unsigned int)ret, tmp);
 878         *ppv = tmp;
 879         return ret;
 880     }
 881     else
 882         FIXME("invalid/unsupported interface %s\n", debugstr_guid(riid));
 883
 884     return E_NOINTERFACE;
 885 }
 886
 887 static HRESULT WINAPI RecycleBin_GetAttributesOf(IShellFolder2 *This, UINT cidl, LPCITEMIDLIST *apidl,
 888                                    SFGAOF *rgfInOut)
 889 {
 890     TRACE("(%p, %d, {%p, ...}, {%lx})\n", This, cidl, apidl[0], *rgfInOut);
 891     *rgfInOut &= SFGAO_CANMOVE|SFGAO_CANDELETE|SFGAO_HASPROPSHEET|SFGAO_FILESYSTEM;
 892     return S_OK;
 893 }
 894
 895 static HRESULT WINAPI RecycleBin_GetUIObjectOf(IShellFolder2 *iface, HWND hwndOwner, UINT cidl, LPCITEMIDLIST *apidl,
 896                       REFIID riid, UINT *rgfReserved, void **ppv)
 897 {
 898     RecycleBin *This = impl_from_IShellFolder2(iface);
 899     *ppv = NULL;
 900     if(IsEqualGUID(riid, &IID_IContextMenu) || IsEqualGUID(riid, &IID_IContextMenu2))
 901     {
 902         TRACE("(%p, %p, %d, {%p, ...}, %s, %p, %p)\n", This, hwndOwner, cidl, apidl[0], debugstr_guid(riid), rgfReserved, ppv);
 903         *ppv = RecycleBinMenu_Constructor(cidl,apidl,&(This->IShellFolder2_iface));
 904         return S_OK;
 905     }
 906     FIXME("(%p, %p, %d, {%p, ...}, %s, %p, %p): stub!\n", iface, hwndOwner, cidl, apidl[0], debugstr_guid(riid), rgfReserved, ppv);
 907
 908     return E_NOTIMPL;
 909 }
 910
 911 static HRESULT WINAPI RecycleBin_GetDisplayNameOf(IShellFolder2 *This, LPCITEMIDLIST pidl, SHGDNF uFlags, STRRET *pName)
 912 {
 913     const WIN32_FIND_DATAW *data = get_trash_item_data( pidl );
 914
 915     TRACE("(%p, %p, %lx, %p)\n", This, pidl, uFlags, pName);
 916     pName->uType = STRRET_WSTR;
 917     return SHStrDupW(PathFindFileNameW(data->cFileName), &pName->pOleStr);
 918 }
 919
 920 static HRESULT WINAPI RecycleBin_SetNameOf(IShellFolder2 *This, HWND hwnd, LPCITEMIDLIST pidl, LPCOLESTR pszName,
 921             SHGDNF uFlags, LPITEMIDLIST *ppidlOut)
 922 {
 923     TRACE("\n");
 924     return E_FAIL; /* not supported */
 925 }
 926
 927 static HRESULT WINAPI RecycleBin_GetClassID(IPersistFolder2 *This, CLSID *pClassID)
 928 {
 929     TRACE("(%p, %p)\n", This, pClassID);
 930     if (This == NULL || pClassID == NULL)
 931         return E_INVALIDARG;
 932     *pClassID = CLSID_RecycleBin;
 933     return S_OK;
 934 }
 935
 936 static HRESULT WINAPI RecycleBin_Initialize(IPersistFolder2 *iface, LPCITEMIDLIST pidl)
 937 {
 938     RecycleBin *This = impl_from_IPersistFolder2(iface);
 939     TRACE("(%p, %p)\n", This, pidl);
 940
 941     This->pidl = ILClone(pidl);
 942     if (This->pidl == NULL)
 943         return E_OUTOFMEMORY;
 944     return S_OK;
 945 }
 946
 947 static HRESULT WINAPI RecycleBin_GetCurFolder(IPersistFolder2 *iface, LPITEMIDLIST *ppidl)
 948 {
 949     RecycleBin *This = impl_from_IPersistFolder2(iface);
 950     TRACE("\n");
 951     *ppidl = ILClone(This->pidl);
 952     return S_OK;
 953 }
 954
 955 static HRESULT WINAPI RecycleBin_GetDefaultSearchGUID(IShellFolder2 *iface, GUID *guid)
 956 {
 957     RecycleBin *This = impl_from_IShellFolder2(iface);
 958     TRACE("(%p)->(%p)\n", This, guid);
 959     return E_NOTIMPL;
 960 }
 961
 962 static HRESULT WINAPI RecycleBin_EnumSearches(IShellFolder2 *iface, IEnumExtraSearch **ppEnum)
 963 {
 964     FIXME("stub\n");
 965     *ppEnum = NULL;
 966     return E_NOTIMPL;
 967 }
 968
 969 static HRESULT WINAPI RecycleBin_GetDefaultColumn(IShellFolder2 *iface, DWORD reserved, ULONG *sort, ULONG *display)
 970 {
 971     RecycleBin *This = impl_from_IShellFolder2(iface);
 972
 973     TRACE("(%p)->(%#lx, %p, %p)\n", This, reserved, sort, display);
 974
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI RecycleBin_GetDefaultColumnState(IShellFolder2 *iface, UINT iColumn, SHCOLSTATEF *pcsFlags)
 979 {
 980     RecycleBin *This = impl_from_IShellFolder2(iface);
 981     TRACE("(%p, %d, %p)\n", This, iColumn, pcsFlags);
 982     if (iColumn >= COLUMNS_COUNT)
 983         return E_INVALIDARG;
 984     *pcsFlags = RecycleBinColumns[iColumn].pcsFlags;
 985     return S_OK;
 986 }
 987
 988 static HRESULT WINAPI RecycleBin_GetDetailsEx(IShellFolder2 *iface, LPCITEMIDLIST pidl, const SHCOLUMNID *pscid, VARIANT *pv)
 989 {
 990     FIXME("stub\n");
 991     return E_NOTIMPL;
 992 }
 993
 994 static HRESULT WINAPI RecycleBin_GetDetailsOf(IShellFolder2 *iface, LPCITEMIDLIST pidl, UINT iColumn, LPSHELLDETAILS pDetails)
 995 {
 996     RecycleBin *This = impl_from_IShellFolder2(iface);
 997     const WIN32_FIND_DATAW *data;
 998     WCHAR buffer[MAX_PATH];
 999
1000     TRACE("(%p, %p, %d, %p)\n", This, pidl, iColumn, pDetails);
1001     if (iColumn >= COLUMNS_COUNT)
1002         return E_FAIL;
1003
1004     if (!pidl) return SHELL32_GetColumnDetails( RecycleBinColumns, iColumn, pDetails );
1005
1006     if (iColumn == COLUMN_NAME)
1007         return RecycleBin_GetDisplayNameOf(iface, pidl, SHGDN_NORMAL, &pDetails->str);
1008
1009     data = get_trash_item_data( pidl );
1010     switch (iColumn)
1011     {
1012         case COLUMN_DATEDEL:
1013             FormatDateTime(buffer, MAX_PATH, data->ftLastAccessTime);
1014             break;
1015         case COLUMN_DELFROM:
1016             lstrcpyW(buffer, data->cFileName);
1017             PathRemoveFileSpecW(buffer);
1018             break;
1019         case COLUMN_SIZE:
1020             StrFormatKBSizeW(((LONGLONG)data->nFileSizeHigh<<32)|data->nFileSizeLow, buffer, MAX_PATH);
1021             break;
1022         case COLUMN_MTIME:
1023             FormatDateTime(buffer, MAX_PATH, data->ftLastWriteTime);
1024             break;
1025         case COLUMN_TYPE:
1026             /* TODO */
1027             buffer[0] = 0;
1028             break;
1029         default:
1030             return E_FAIL;
1031     }
1032
1033     pDetails->str.uType = STRRET_WSTR;
1034     return SHStrDupW(buffer, &pDetails->str.pOleStr);
1035 }
1036
1037 static HRESULT WINAPI RecycleBin_MapColumnToSCID(IShellFolder2 *iface, UINT iColumn, SHCOLUMNID *pscid)
1038 {
1039     RecycleBin *This = impl_from_IShellFolder2(iface);
1040     TRACE("(%p, %d, %p)\n", This, iColumn, pscid);
1041     if (iColumn>=COLUMNS_COUNT)
1042         return E_INVALIDARG;
1043
1044     return shellfolder_map_column_to_scid(RecycleBinColumns, iColumn, pscid);
1045 }
1046
1047 static const IShellFolder2Vtbl recycleBinVtbl =
1048 {
1049     /* IUnknown */
1050     RecycleBin_QueryInterface,
1051     RecycleBin_AddRef,
1052     RecycleBin_Release,
1053
1054     /* IShellFolder */
1055     RecycleBin_ParseDisplayName,
1056     RecycleBin_EnumObjects,
1057     RecycleBin_BindToObject,
1058     RecycleBin_BindToStorage,
1059     RecycleBin_CompareIDs,
1060     RecycleBin_CreateViewObject,
1061     RecycleBin_GetAttributesOf,
1062     RecycleBin_GetUIObjectOf,
1063     RecycleBin_GetDisplayNameOf,
1064     RecycleBin_SetNameOf,
1065
1066     /* IShellFolder2 */
1067     RecycleBin_GetDefaultSearchGUID,
1068     RecycleBin_EnumSearches,
1069     RecycleBin_GetDefaultColumn,
1070     RecycleBin_GetDefaultColumnState,
1071     RecycleBin_GetDetailsEx,
1072     RecycleBin_GetDetailsOf,
1073     RecycleBin_MapColumnToSCID
1074 };
1075
1076 static HRESULT WINAPI RecycleBin_IPersistFolder2_QueryInterface(IPersistFolder2 *iface, REFIID riid,
1077         void **ppvObject)
1078 {
1079     RecycleBin *This = impl_from_IPersistFolder2(iface);
1080
1081     return IShellFolder2_QueryInterface(&This->IShellFolder2_iface, riid, ppvObject);
1082 }
1083
1084 static ULONG WINAPI RecycleBin_IPersistFolder2_AddRef(IPersistFolder2 *iface)
1085 {
1086     RecycleBin *This = impl_from_IPersistFolder2(iface);
1087
1088     return IShellFolder2_AddRef(&This->IShellFolder2_iface);
1089 }
1090
1091 static ULONG WINAPI RecycleBin_IPersistFolder2_Release(IPersistFolder2 *iface)
1092 {
1093     RecycleBin *This = impl_from_IPersistFolder2(iface);
1094
1095     return IShellFolder2_Release(&This->IShellFolder2_iface);
1096 }
1097
1098 static const IPersistFolder2Vtbl recycleBinPersistVtbl =
1099 {
1100     /* IUnknown */
1101     RecycleBin_IPersistFolder2_QueryInterface,
1102     RecycleBin_IPersistFolder2_AddRef,
1103     RecycleBin_IPersistFolder2_Release,
1104
1105     /* IPersist */
1106     RecycleBin_GetClassID,
1107     /* IPersistFolder */
1108     RecycleBin_Initialize,
1109     /* IPersistFolder2 */
1110     RecycleBin_GetCurFolder
1111 };
1112
1113 static HRESULT WINAPI RecycleBin_ISFHelper_QueryInterface(ISFHelper *iface, REFIID riid,
1114         void **ppvObject)
1115 {
1116     RecycleBin *This = impl_from_ISFHelper(iface);
1117
1118     return IShellFolder2_QueryInterface(&This->IShellFolder2_iface, riid, ppvObject);
1119 }
1120
1121 static ULONG WINAPI RecycleBin_ISFHelper_AddRef(ISFHelper *iface)
1122 {
1123     RecycleBin *This = impl_from_ISFHelper(iface);
1124
1125     return IShellFolder2_AddRef(&This->IShellFolder2_iface);
1126 }
1127
1128 static ULONG WINAPI RecycleBin_ISFHelper_Release(ISFHelper *iface)
1129 {
1130     RecycleBin *This = impl_from_ISFHelper(iface);
1131
1132     return IShellFolder2_Release(&This->IShellFolder2_iface);
1133 }
1134
1135 static HRESULT WINAPI RecycleBin_GetUniqueName(ISFHelper *iface,LPWSTR lpName,
1136                                                UINT  uLen)
1137 {
1138     return E_NOTIMPL;
1139 }
1140
1141 static HRESULT WINAPI RecycleBin_AddFolder(ISFHelper * iface, HWND hwnd,
1142                                            LPCWSTR pwszName,
1143                                            LPITEMIDLIST * ppidlOut)
1144 {
1145     /*Adding folders doesn't make sense in the recycle bin*/
1146     return E_NOTIMPL;
1147 }
1148
1149 static HRESULT erase_items(HWND parent,const LPCITEMIDLIST * apidl, UINT cidl, BOOL confirm)
1150 {
1151     UINT i=0;
1152     HRESULT ret = S_OK;
1153     LPITEMIDLIST recyclebin;
1154
1155     if(confirm)
1156     {
1157         WCHAR arg[MAX_PATH];
1158         WCHAR message[100];
1159         WCHAR caption[50];
1160         switch(cidl)
1161         {
1162         case 0:
1163             return S_OK;
1164         case 1:
1165             {
1166                 const WIN32_FIND_DATAW *data = get_trash_item_data( apidl[0] );
1167                 lstrcpynW(arg,data->cFileName,MAX_PATH);
1168                 LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_ERASEITEM, message, ARRAY_SIZE(message));
1169                 break;
1170             }
1171         default:
1172             {
1173                 LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_ERASEMULTIPLE, message, ARRAY_SIZE(message));
1174                 swprintf(arg, ARRAY_SIZE(arg), L"%u", cidl);
1175                 break;
1176             }
1177
1178         }
1179         LoadStringW(shell32_hInstance, IDS_RECYCLEBIN_ERASE_CAPTION, caption, ARRAY_SIZE(caption));
1180         if(ShellMessageBoxW(shell32_hInstance,parent,message,caption,
1181                             MB_YESNO|MB_ICONEXCLAMATION,arg)!=IDYES)
1182             return ret;
1183
1184     }
1185     SHGetFolderLocation(parent,CSIDL_BITBUCKET,0,0,&recyclebin);
1186     for (; i<cidl; i++)
1187     {
1188         if(SUCCEEDED(erase_trash_item(apidl[i])))
1189             SHChangeNotify(SHCNE_DELETE,SHCNF_IDLIST,
1190                            ILCombine(recyclebin,apidl[i]),0);
1191     }
1192     ILFree(recyclebin);
1193     return S_OK;
1194 }
1195
1196 static HRESULT WINAPI RecycleBin_DeleteItems(ISFHelper * iface, UINT cidl,
1197                                              LPCITEMIDLIST * apidl)
1198 {
1199     TRACE("(%p,%u,%p)\n",iface,cidl,apidl);
1200     return erase_items(GetActiveWindow(),apidl,cidl,TRUE);
1201 }
1202
1203 static HRESULT WINAPI RecycleBin_CopyItems(ISFHelper * iface,
1204                                            IShellFolder * pSFFrom,
1205                                            UINT cidl, LPCITEMIDLIST * apidl)
1206 {
1207     return E_NOTIMPL;
1208 }
1209
1210 static const ISFHelperVtbl sfhelperVtbl =
1211 {
1212     RecycleBin_ISFHelper_QueryInterface,
1213     RecycleBin_ISFHelper_AddRef,
1214     RecycleBin_ISFHelper_Release,
1215     RecycleBin_GetUniqueName,
1216     RecycleBin_AddFolder,
1217     RecycleBin_DeleteItems,
1218     RecycleBin_CopyItems
1219 };
1220
1221 HRESULT WINAPI SHQueryRecycleBinA(LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
1222 {
1223     WCHAR wszRootPath[MAX_PATH];
1224     MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, wszRootPath, MAX_PATH);
1225     return SHQueryRecycleBinW(wszRootPath, pSHQueryRBInfo);
1226 }
1227
1228 HRESULT WINAPI SHQueryRecycleBinW(LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
1229 {
1230     LPITEMIDLIST *apidl;
1231     INT cidl;
1232     INT i=0;
1233     HRESULT hr;
1234
1235     TRACE("(%s, %p)\n", debugstr_w(pszRootPath), pSHQueryRBInfo);
1236
1237     hr = enum_trash_items(&apidl, &cidl);
1238     if (FAILED(hr))
1239         return hr;
1240     pSHQueryRBInfo->i64NumItems = cidl;
1241     pSHQueryRBInfo->i64Size = 0;
1242     for (; i<cidl; i++)
1243     {
1244         const WIN32_FIND_DATAW *data = get_trash_item_data( apidl[i] );
1245         pSHQueryRBInfo->i64Size += ((DWORDLONG)data->nFileSizeHigh << 32) + data->nFileSizeLow;
1246         ILFree(apidl[i]);
1247     }
1248     SHFree(apidl);
1249     return S_OK;
1250 }
1251
1252 HRESULT WINAPI SHEmptyRecycleBinA(HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags)
1253 {
1254     WCHAR wszRootPath[MAX_PATH];
1255     MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, wszRootPath, MAX_PATH);
1256     return SHEmptyRecycleBinW(hwnd, wszRootPath, dwFlags);
1257 }
1258
1259 #define SHERB_NOCONFIRMATION 1
1260 #define SHERB_NOPROGRESSUI   2
1261 #define SHERB_NOSOUND        4
1262
1263 HRESULT WINAPI SHEmptyRecycleBinW(HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags)
1264 {
1265     LPITEMIDLIST *apidl;
1266     INT cidl;
1267     INT i=0;
1268     HRESULT ret;
1269
1270     TRACE("(%p, %s, 0x%08lx)\n", hwnd, debugstr_w(pszRootPath) , dwFlags);
1271
1272     ret = enum_trash_items(&apidl, &cidl);
1273     if (FAILED(ret))
1274         return ret;
1275
1276     ret = erase_items(hwnd,(const LPCITEMIDLIST*)apidl,cidl,!(dwFlags & SHERB_NOCONFIRMATION));
1277     for (;i<cidl;i++)
1278         ILFree(apidl[i]);
1279     SHFree(apidl);
1280     return ret;
1281 }
1282
1283 /*************************************************************************
1284  * SHUpdateRecycleBinIcon                                [SHELL32.@]
1285  *
1286  * Undocumented
1287  */
1288 HRESULT WINAPI SHUpdateRecycleBinIcon(void)
1289 {
1290     FIXME("stub\n");
1291     return S_OK;
1292 }