CRecycleBin.cpp File Reference

#include <precomp.h>
#include <mmsystem.h>
#include <ntquery.h>
#include "pshpack1.h"
#include "poppack.h"

Include dependency graph for CRecycleBin.cpp:

Go to the source code of this file.

Classes
struct	columninfo
struct	BBITEMDATA
struct	BBITEMFOOTER
class	CRecycleBinItemContextMenu
class	CRecycleBinEnum
struct	_FILEOPDATA

Macros
#define	COLUMN_NAME   0
#define	COLUMN_DELFROM   1
#define	COLUMN_DATEDEL   2
#define	COLUMN_SIZE   3
#define	COLUMN_TYPE   4
#define	COLUMN_MTIME   5
#define	COLUMNS_COUNT   6
#define	BBITEMFILETYPE   (PT_FS | PT_FS_UNICODE_FLAG | PT_FS_FILE_FLAG)
#define	BBITEMFOLDERTYPE   (PT_FS | PT_FS_UNICODE_FLAG | PT_FS_FOLDER_FLAG)

Typedefs
typedef struct _FILEOPDATA	FILEOPDATA

Enumerations
enum	{ IDC_BB_RESTORE = 1 , IDC_BB_CUT , IDC_BB_DELETE , IDC_BB_PROPERTIES }
enum	{ IDC_EMPTYRECYCLEBIN = 1 , IDC_PROPERTIES }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (CRecycleBin)
static BOOL	IsFolder (LPCITEMIDLIST pidl)
static BBITEMDATA *	ValidateItem (LPCITEMIDLIST pidl)
static LPITEMIDLIST	CreateItem (LPCWSTR pszTrash, LPCWSTR pszOrig, const DELETED_FILE_INFO &Details)
static UINT	GetItemFileSize (LPCITEMIDLIST pidl)
static LPCWSTR	GetItemOriginalFullPath (const BBITEMDATA &Data)
static HRESULT	GetItemOriginalFolder (const BBITEMDATA &Data, LPWSTR &Out)
static LPCWSTR	GetItemOriginalFileName (const BBITEMDATA &Data)
static LPCWSTR	GetItemRecycledFullPath (const BBITEMDATA &Data)
static int	GetItemDriveNumber (LPCITEMIDLIST pidl)
static HRESULT	GetItemTypeName (PCUITEMID_CHILD pidl, const BBITEMDATA &Data, SHFILEINFOW &shfi)
static UINT	GetDefaultRecycleDriveNumber ()
static LPCWSTR	GetGlobalRecycleBinPath ()
static BOOL	IsRecycleBinEmpty (IShellFolder *pSF)
static void	CRecycleBin_ChangeNotifyBBItem (_In_ LONG Event, _In_opt_ LPCITEMIDLIST BBItem)
EXTERN_C void	CRecycleBin_NotifyRecycled (LPCWSTR OrigPath, const WIN32_FIND_DATAW *pFind, const RECYCLEBINFILEIDENTITY *pFI)
static void	CRecycleBin_NotifyRemovedFromRecycleBin (LPCITEMIDLIST BBItem)
static HRESULT	CRecyclerExtractIcon_CreateInstance (IShellFolder &FSFolder, LPCITEMIDLIST pidl, REFIID riid, LPVOID *ppvOut)
static BOOL	ConfirmDelete (LPCMINVOKECOMMANDINFO lpcmi, UINT cidl, LPCITEMIDLIST pidl)
static LPWSTR	CreateFileOpStrings (UINT cidl, PCUITEMID_CHILD_ARRAY apidl, BOOL RecycledPath)
static HRESULT CALLBACK	FileOpCallback (FILEOPCALLBACKEVENT Event, LPCWSTR Src, LPCWSTR Dst, UINT Attrib, HRESULT hrOp, void *CallerData)
static HRESULT	CompareCanonical (const BBITEMDATA &Data1, const BBITEMDATA &Data2)
BOOL	TRASH_CanTrashFile (LPCWSTR wszPath)
BOOL	TRASH_TrashFile (LPCWSTR wszPath)
static void	TRASH_PlayEmptyRecycleBinSound ()
EXTERN_C HRESULT WINAPI	SHUpdateRecycleBinIcon (void)
HRESULT WINAPI	SHEmptyRecycleBinA (HWND hwnd, LPCSTR pszRootPath, DWORD dwFlags)
HRESULT WINAPI	SHEmptyRecycleBinW (HWND hwnd, LPCWSTR pszRootPath, DWORD dwFlags)
HRESULT WINAPI	SHQueryRecycleBinA (LPCSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)
HRESULT WINAPI	SHQueryRecycleBinW (LPCWSTR pszRootPath, LPSHQUERYRBINFO pSHQueryRBInfo)

Variables
static const columninfo	RecycleBinColumns []
static const CMVERBMAP	g_BBItemVerbMap []
static const CMVERBMAP	g_BBFolderVerbMap []

Macro Definition Documentation

BBITEMFILETYPE

#define BBITEMFILETYPE   (PT_FS | PT_FS_UNICODE_FLAG | PT_FS_FILE_FLAG)

Definition at line 64 of file CRecycleBin.cpp.

BBITEMFOLDERTYPE

#define BBITEMFOLDERTYPE   (PT_FS | PT_FS_UNICODE_FLAG | PT_FS_FOLDER_FLAG)

Definition at line 65 of file CRecycleBin.cpp.

COLUMN_DATEDEL

#define COLUMN_DATEDEL   2

Definition at line 54 of file CRecycleBin.cpp.

COLUMN_DELFROM

#define COLUMN_DELFROM   1

Definition at line 53 of file CRecycleBin.cpp.

COLUMN_MTIME

#define COLUMN_MTIME   5

Definition at line 57 of file CRecycleBin.cpp.

COLUMN_NAME

#define COLUMN_NAME   0

Definition at line 52 of file CRecycleBin.cpp.

COLUMN_SIZE

#define COLUMN_SIZE   3

Definition at line 55 of file CRecycleBin.cpp.

COLUMN_TYPE

#define COLUMN_TYPE   4

Definition at line 56 of file CRecycleBin.cpp.

COLUMNS_COUNT

#define COLUMNS_COUNT   6

Definition at line 59 of file CRecycleBin.cpp.

Typedef Documentation

FILEOPDATA

typedef struct _FILEOPDATA FILEOPDATA

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
IDC_BB_RESTORE
IDC_BB_CUT
IDC_BB_DELETE
IDC_BB_PROPERTIES

Definition at line 421 of file CRecycleBin.cpp.

{ IDC_BB_RESTORE = 1, IDC_BB_CUT, IDC_BB_DELETE, IDC_BB_PROPERTIES };

anonymous enum

anonymous enum

Enumerator
IDC_EMPTYRECYCLEBIN
IDC_PROPERTIES

Definition at line 1053 of file CRecycleBin.cpp.

{ IDC_EMPTYRECYCLEBIN = 1, IDC_PROPERTIES };

Function Documentation

CompareCanonical()

static HRESULT CompareCanonical ( const BBITEMDATA &  Data1, const BBITEMDATA &  Data2  )

static

Definition at line 730 of file CRecycleBin.cpp.

{
    // This assumes two files with the same original path cannot be deleted at
    // the same time (within the FAT/NTFS FILETIME resolution).
    int result = CompareFileTime(&Data1.DeletionTime, &Data2.DeletionTime);
    if (result == 0)
        result = _wcsicmp(GetItemOriginalFullPath(Data1), GetItemOriginalFullPath(Data2));
    return MAKE_COMPARE_HRESULT(result);
}

Referenced by CRecycleBin::CompareIDs().

ConfirmDelete()

static BOOL ConfirmDelete ( LPCMINVOKECOMMANDINFO  lpcmi, UINT  cidl, LPCITEMIDLIST  pidl  )

static

Definition at line 467 of file CRecycleBin.cpp.

{
    BBITEMDATA *pData;
    if (lpcmi->fMask & CMIC_MASK_FLAG_NO_UI)
    {
        return TRUE;
    }
    else if (cidl == 1 && (pData = ValidateItem(pidl)) != NULL)
    {
        const UINT ask = IsFolder(pidl) ? ASK_DELETE_FOLDER : ASK_DELETE_FILE;
        return SHELL_ConfirmYesNoW(lpcmi->hwnd, ask, GetItemOriginalFileName(*pData));
    }
    WCHAR buf[42];
    wsprintfW(buf, L"%d", cidl);
    return SHELL_ConfirmYesNoW(lpcmi->hwnd, ASK_DELETE_MULTIPLE_ITEM, buf);
}

Referenced by CRecycleBinItemContextMenu::InvokeCommand().

CreateFileOpStrings()

static LPWSTR CreateFileOpStrings ( UINT  cidl, PCUITEMID_CHILD_ARRAY  apidl, BOOL  RecycledPath  )

static

Definition at line 484 of file CRecycleBin.cpp.

{
    PWSTR mem = NULL, newmem;
    for (SIZE_T i = 0, cb = 0, cb2, cbPath; i < cidl; ++i, cb = cb2)
    {
        BBITEMDATA *pData = ValidateItem(apidl[i]);
        if (!pData)
        {
fail:
            LocalFree(mem);
            return NULL;
        }
        LPCWSTR path = RecycledPath ? GetItemRecycledFullPath(*pData) : GetItemOriginalFullPath(*pData);
        cbPath = (lstrlenW(path) + 1) * sizeof(WCHAR);
        cb2 = cb + cbPath;
        SIZE_T cbTot = cb2 + sizeof(WCHAR); // \0\0 termination
        newmem = (PWSTR)(i ? LocalReAlloc(mem, cbTot, LMEM_MOVEABLE) : LocalAlloc(LPTR, cbTot));
        if (!newmem)
            goto fail;
        mem = newmem;
        CopyMemory((char*)mem + cb, path, cbPath);
        *(PWSTR)((char*)mem + cb + cbPath) = UNICODE_NULL;
    }
    return mem;
}

Referenced by CRecycleBinItemContextMenu::InvokeCommand().

CreateItem()

static LPITEMIDLIST CreateItem ( LPCWSTR  pszTrash, LPCWSTR  pszOrig, const DELETED_FILE_INFO &  Details  )

static

Definition at line 105 of file CRecycleBin.cpp.

{
    const BOOL folder = Details.Attributes & FILE_ATTRIBUTE_DIRECTORY;
    LPCWSTR pszName = PathFindFileNameW(pszTrash);
    SIZE_T ofsName = (SIZE_T)(pszName - pszTrash);
    SIZE_T cchName = wcslen(pszName) + 1, cbName = cchName * sizeof(WCHAR);
    SIZE_T cbFSNames = cbName + sizeof("") + 1; // Empty short name + 1 for WORD alignment
    SIZE_T cbFS = sizeof(WORD) + FIELD_OFFSET(PIDLDATA, u.file.szNames) + cbFSNames;
    SIZE_T cchTrash = ofsName + cchName, cbTrash = cchTrash * sizeof(WCHAR);
    SIZE_T cchOrig = wcslen(pszOrig) + 1, cbOrig = cchOrig * sizeof(WCHAR);
    SIZE_T cbData = FIELD_OFFSET(BBITEMDATA, OriginalLocation) + cbOrig + cbTrash;
    SIZE_T cb = cbFS + cbData + sizeof(BBITEMFOOTER);
    if (cb > 0xffff)
        return NULL;
    LPITEMIDLIST pidl = (LPITEMIDLIST)SHAlloc(cb + sizeof(WORD));
    if (!pidl)
        return pidl;
 
    pidl->mkid.cb = cb;
    pidl->mkid.abID[0] = folder ? BBITEMFOLDERTYPE : BBITEMFILETYPE;
    ILGetNext(pidl)->mkid.cb = 0; // Terminator
    FileStruct &fsitem = ((PIDLDATA*)pidl->mkid.abID)->u.file;
    fsitem.dummy = 0;
    C_ASSERT(sizeof(RECYCLEBINFILESIZETYPE) <= sizeof(fsitem.dwFileSize));
    fsitem.dwFileSize = Details.FileSize;
    fsitem.uFileAttribs = LOWORD(Details.Attributes);
    FileTimeToDosDateTime(&Details.LastModification, &fsitem.uFileDate, &fsitem.uFileTime);
    CopyMemory(fsitem.szNames, pszName, cbName);
    LPSTR pszShort = const_cast<LPSTR>(&fsitem.szNames[cbName]);
    pszShort[0] = '\0';
    pszShort[1] = '\0'; // Fill alignment padding (for ILIsEqual memcmp)
 
    BBITEMFOOTER *footer = (BBITEMFOOTER*)((BYTE*)pidl + cb - sizeof(BBITEMFOOTER));
    footer->DataSize = cbData;
    footer->EndSignature = BBITEMFOOTER::ENDSIG;
 
    BBITEMDATA *data = (BBITEMDATA*)((BYTE*)footer - footer->DataSize);
    data->DeletionTime = Details.DeletionTime;
#ifdef COLUMN_FATTS
    data->AttribsHi = HIWORD(Details.Attributes);
#endif
    data->RecycledPathOffset = FIELD_OFFSET(BBITEMDATA, OriginalLocation) + cbOrig;
    CopyMemory(data->OriginalLocation, pszOrig, cbOrig);
    CopyMemory((BYTE*)data + data->RecycledPathOffset, pszTrash, cbTrash);
 
    assert(!(((SIZE_T)&fsitem.szNames) & 1)); // WORD aligned please
    C_ASSERT(!(FIELD_OFFSET(BBITEMDATA, OriginalLocation) & 1)); // WORD aligned please
    assert(!(((SIZE_T)data) & 1)); // WORD aligned please
    assert(_ILGetFSType(pidl));
    assert(_ILIsPidlSimple(pidl));
    assert(*(WORD*)((BYTE*)pidl + pidl->mkid.cb - sizeof(WORD)) & 1); // ENDSIG bit
    assert(_ILGetFileStructW(pidl) == NULL); // Our custom footer is incompatible with WinXP pidl data
    assert(ValidateItem(pidl) == data);
    return pidl;
}

Referenced by CRecycleBinEnum::CBEnumRecycleBin(), and CRecycleBin_NotifyRecycled().

CRecycleBin_ChangeNotifyBBItem()

static void CRecycleBin_ChangeNotifyBBItem ( _In_ LONG  Event, _In_opt_ LPCITEMIDLIST  BBItem  )

static

Definition at line 242 of file CRecycleBin.cpp.

{
    LPITEMIDLIST pidlFolder = SHCloneSpecialIDList(NULL, CSIDL_BITBUCKET, FALSE);
    if (!pidlFolder)
        return;
    if (BBItem)
    {
        assert(ValidateItem(BBItem));
        if (LPITEMIDLIST pidlFull = ILCombine(pidlFolder, BBItem))
        {
            // Send notification for [Desktop][RecycleBin][BBItem]
            // FIXME: Windows monitors each RecycleBin FS folder on every drive
            //        instead of manually sending these?
            SHChangeNotify(Event, SHCNF_IDLIST, pidlFull, NULL);
            ILFree(pidlFull);
        }
    }
    else
    {
        SHChangeNotify(Event, SHCNF_IDLIST, pidlFolder, NULL);
    }
    ILFree(pidlFolder);
}

Referenced by CRecycleBin_NotifyRecycled(), CRecycleBin_NotifyRemovedFromRecycleBin(), and SHEmptyRecycleBinW().

CRecycleBin_NotifyRecycled()

EXTERN_C void CRecycleBin_NotifyRecycled	(	LPCWSTR	OrigPath,
		const WIN32_FIND_DATAW *	pFind,
		const RECYCLEBINFILEIDENTITY *	pFI
	)

Definition at line 266 of file CRecycleBin.cpp.

{
    DELETED_FILE_INFO info;
    info.LastModification = pFind->ftLastWriteTime;
    info.DeletionTime = pFI->DeletionTime;
    info.FileSize = pFind->nFileSizeLow;
    info.Attributes = pFind->dwFileAttributes;
    if (LPITEMIDLIST pidl = CreateItem(pFI->RecycledFullPath, OrigPath, info))
    {
        CRecycleBin_ChangeNotifyBBItem(IsFolder(pidl) ? SHCNE_MKDIR : SHCNE_CREATE, pidl);
        ILFree(pidl);
    }
}

Referenced by RecycleBin5::DeleteFile().

CRecycleBin_NotifyRemovedFromRecycleBin()

static void CRecycleBin_NotifyRemovedFromRecycleBin ( LPCITEMIDLIST  BBItem )

static

Definition at line 281 of file CRecycleBin.cpp.

{
    CRecycleBin_ChangeNotifyBBItem(IsFolder(BBItem) ? SHCNE_RMDIR : SHCNE_DELETE, BBItem);
}

Referenced by FileOpCallback().

CRecyclerExtractIcon_CreateInstance()

static HRESULT CRecyclerExtractIcon_CreateInstance ( IShellFolder &  FSFolder, LPCITEMIDLIST  pidl, REFIID  riid, LPVOID *  ppvOut  )

static

Definition at line 286 of file CRecycleBin.cpp.

{
    HRESULT hr = FSFolder.GetUIObjectOf(NULL, 1, &pidl, riid, NULL, ppvOut);
    if (SUCCEEDED(hr))
        return hr;
 
    // In case the search fails we use a default icon
    ERR("Recycler could not retrieve the icon, this shouldn't happen\n");
 
    if (IsFolder(pidl))
        return SHELL_CreateFallbackExtractIconForFolder(riid, ppvOut);
    else
        return SHELL_CreateFallbackExtractIconForNoAssocFile(riid, ppvOut);
}

Referenced by CRecycleBin::GetUIObjectOf().

FileOpCallback()

static HRESULT CALLBACK FileOpCallback ( FILEOPCALLBACKEVENT  Event, LPCWSTR  Src, LPCWSTR  Dst, UINT  Attrib, HRESULT  hrOp, void *  CallerData  )

static

Definition at line 516 of file CRecycleBin.cpp.

{
    FILEOPDATA &data = *(FILEOPDATA*)CallerData;
    if ((Event == FOCE_POSTDELETEITEM || Event == FOCE_POSTMOVEITEM) && SUCCEEDED(hrOp))
    {
        for (UINT i = 0; i < data.cidl; ++i)
        {
            BBITEMDATA *pItem = ValidateItem(data.apidl[i]);
            if (pItem && !_wcsicmp(Src, GetItemRecycledFullPath(*pItem)))
            {
                RECYCLEBINFILEIDENTITY identity = { pItem->DeletionTime, GetItemRecycledFullPath(*pItem) };
                RemoveFromRecycleBinDatabase(&identity);
                CRecycleBin_NotifyRemovedFromRecycleBin(data.apidl[i]);
                break;
            }
        }
    }
    else if (Event == FOCE_FINISHOPERATIONS)
    {
        CComHeapPtr<ITEMIDLIST> pidlBB(SHCloneSpecialIDList(NULL, CSIDL_BITBUCKET, FALSE));
        CComPtr<IShellFolder> pSF;
        if (pidlBB && SUCCEEDED(SHBindToObject(NULL, pidlBB, IID_PPV_ARG(IShellFolder, &pSF))))
        {
            if (IsRecycleBinEmpty(pSF))
                SHUpdateRecycleBinIcon();
        }
    }
    return S_OK;
}

Referenced by CRecycleBinItemContextMenu::InvokeCommand().

GetDefaultRecycleDriveNumber()

static UINT GetDefaultRecycleDriveNumber ( )

static

Definition at line 219 of file CRecycleBin.cpp.

{
    int drive = 0;
    WCHAR buf[MAX_PATH];
    if (GetWindowsDirectoryW(buf, _countof(buf)))
        drive = PathGetDriveNumberW(buf);
    return max(0, drive);
}

Referenced by CRecycleBin::GetFSFolderForItem().

GetGlobalRecycleBinPath()

static LPCWSTR GetGlobalRecycleBinPath ( )

inlinestatic

Definition at line 228 of file CRecycleBin.cpp.

{
    return NULL;
}

Referenced by CRecycleBinEnum::Initialize().

GetItemDriveNumber()

static int GetItemDriveNumber ( LPCITEMIDLIST  pidl )

static

Definition at line 197 of file CRecycleBin.cpp.

{
    if (BBITEMDATA *pData = ValidateItem(pidl))
        return PathGetDriveNumberW(GetItemRecycledFullPath(*pData));
    WCHAR buf[MAX_PATH];
    return _ILSimpleGetTextW(pidl, buf, _countof(buf)) ? PathGetDriveNumberW(buf) : -1;
}

Referenced by CRecycleBin::GetFSFolderForItem().

GetItemFileSize()

static UINT GetItemFileSize ( LPCITEMIDLIST  pidl )

inlinestatic

Definition at line 161 of file CRecycleBin.cpp.

{
    return _ILGetFSType(pidl) ? ((PIDLDATA*)pidl->mkid.abID)->u.file.dwFileSize : 0;
}

Referenced by CRecycleBin::CompareIDs(), and CRecycleBin::GetDetailsOf().

GetItemOriginalFileName()

static LPCWSTR GetItemOriginalFileName ( const BBITEMDATA &  Data )

static

Definition at line 179 of file CRecycleBin.cpp.

{
    return PathFindFileNameW(GetItemOriginalFullPath(Data));
}

Referenced by CRecycleBin::CompareIDs(), ConfirmDelete(), and CRecycleBin::GetDisplayNameOf().

GetItemOriginalFolder()

static HRESULT GetItemOriginalFolder ( const BBITEMDATA &  Data, LPWSTR &  Out  )

static

Definition at line 171 of file CRecycleBin.cpp.

{
    HRESULT hr = SHStrDupW(GetItemOriginalFullPath(Data), &Out);
    if (SUCCEEDED(hr))
        PathRemoveFileSpecW(Out);
    return hr;
}

Referenced by CRecycleBin::CompareIDs(), and CRecycleBin::GetDetailsOf().

GetItemOriginalFullPath()

static LPCWSTR GetItemOriginalFullPath ( const BBITEMDATA &  Data )

inlinestatic

Definition at line 166 of file CRecycleBin.cpp.

{
    return Data.OriginalLocation;
}

Referenced by CompareCanonical(), CreateFileOpStrings(), CRecycleBin::GetDisplayNameOf(), GetItemOriginalFileName(), and GetItemOriginalFolder().

GetItemRecycledFullPath()

static LPCWSTR GetItemRecycledFullPath ( const BBITEMDATA &  Data )

inlinestatic

Definition at line 184 of file CRecycleBin.cpp.

{
    return (LPCWSTR)((BYTE*)&Data + Data.RecycledPathOffset);
}

Referenced by CreateFileOpStrings(), FileOpCallback(), CRecycleBin::GetDisplayNameOf(), GetItemDriveNumber(), and GetItemTypeName().

GetItemTypeName()

static HRESULT GetItemTypeName ( PCUITEMID_CHILD  pidl, const BBITEMDATA &  Data, SHFILEINFOW &  shfi  )

static

Definition at line 205 of file CRecycleBin.cpp.

{
    LPCWSTR path = GetItemRecycledFullPath(Data);
    UINT attribs = ((PIDLDATA*)pidl->mkid.abID)->u.file.uFileAttribs;
    if (SHGetFileInfoW(path, attribs, &shfi, sizeof(shfi), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES))
        return S_OK;
    shfi.szTypeName[0] = UNICODE_NULL;
    return E_FAIL;
}

Referenced by CRecycleBin::CompareIDs(), and CRecycleBin::GetDetailsOf().

IsFolder()

static BOOL IsFolder ( LPCITEMIDLIST  pidl )

inlinestatic

Definition at line 84 of file CRecycleBin.cpp.

{
    return _ILGetFSType(pidl) & PT_FS_FOLDER_FLAG;
}

Referenced by CCommonFolder< TSelf, TItemId, TExtractIcon >::CompareName(), ConfirmDelete(), CRecycleBin_NotifyRecycled(), CRecycleBin_NotifyRemovedFromRecycleBin(), CRecyclerExtractIcon_CreateInstance(), CRecycleBin::GetDetailsOf(), CRecycleBin::GetDisplayNameOf(), CCommonFolder< TSelf, TItemId, TExtractIcon >::GetUIObjectOf(), and CCommonFolder< TSelf, TItemId, TExtractIcon >::STDMETHOD_().

IsRecycleBinEmpty()

static BOOL IsRecycleBinEmpty ( IShellFolder *  pSF )

static

Definition at line 233 of file CRecycleBin.cpp.

{
    CComPtr<IEnumIDList> spEnumFiles;
    HRESULT hr = pSF->EnumObjects(NULL, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS, &spEnumFiles);
    CComHeapPtr<ITEMIDLIST> spPidl;
    ULONG itemcount;
    return FAILED(hr) || spEnumFiles->Next(1, &spPidl, &itemcount) != S_OK;
}

Referenced by FileOpCallback(), and CRecycleBin::QueryContextMenu().

SHEmptyRecycleBinA()

HRESULT WINAPI SHEmptyRecycleBinA	(	HWND	hwnd,
		LPCSTR	pszRootPath,
		DWORD	dwFlags
	)

Definition at line 1303 of file CRecycleBin.cpp.

{
    LPWSTR szRootPathW = NULL;
    int len;
    HRESULT hr;
 
    TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_a(pszRootPath), dwFlags);
 
    if (pszRootPath)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
        if (len == 0)
            return HRESULT_FROM_WIN32(GetLastError());
        szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        if (!szRootPathW)
            return E_OUTOFMEMORY;
        if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
        {
            HeapFree(GetProcessHeap(), 0, szRootPathW);
            return HRESULT_FROM_WIN32(GetLastError());
        }
    }
 
    hr = SHEmptyRecycleBinW(hwnd, szRootPathW, dwFlags);
    HeapFree(GetProcessHeap(), 0, szRootPathW);
 
    return hr;
}

SHEmptyRecycleBinW()

HRESULT WINAPI SHEmptyRecycleBinW	(	HWND	hwnd,
		LPCWSTR	pszRootPath,
		DWORD	dwFlags
	)

Definition at line 1332 of file CRecycleBin.cpp.

{
    WCHAR szBuffer[MAX_PATH];
    DWORD count;
    LONG ret;
    IShellFolder *pDesktop, *pRecycleBin;
    PIDLIST_ABSOLUTE pidlRecycleBin;
    PITEMID_CHILD pidl;
    HRESULT hr = S_OK;
    LPENUMIDLIST penumFiles;
    STRRET StrRet;
 
    TRACE("%p, %s, 0x%08x\n", hwnd, debugstr_w(pszRootPath), dwFlags);
 
    if (!(dwFlags & SHERB_NOCONFIRMATION))
    {
        hr = SHGetDesktopFolder(&pDesktop);
        if (FAILED(hr))
            return hr;
        hr = SHGetFolderLocation(NULL, CSIDL_BITBUCKET, NULL, 0, &pidlRecycleBin);
        if (FAILED(hr))
        {
            pDesktop->Release();
            return hr;
        }
        hr = pDesktop->BindToObject(pidlRecycleBin, NULL, IID_PPV_ARG(IShellFolder, &pRecycleBin));
        CoTaskMemFree(pidlRecycleBin);
        pDesktop->Release();
        if (FAILED(hr))
            return hr;
        hr = pRecycleBin->EnumObjects(hwnd, SHCONTF_FOLDERS | SHCONTF_NONFOLDERS | SHCONTF_INCLUDEHIDDEN, &penumFiles);
        if (FAILED(hr))
        {
            pRecycleBin->Release();
            return hr;
        }
 
        count = 0;
        if (hr != S_FALSE)
        {
            while (penumFiles->Next(1, &pidl, NULL) == S_OK)
            {
                count++;
                pRecycleBin->GetDisplayNameOf(pidl, SHGDN_NORMAL | SHGDN_INFOLDER, &StrRet);
                StrRetToBuf(&StrRet, pidl, szBuffer, _countof(szBuffer));
                CoTaskMemFree(pidl);
            }
            penumFiles->Release();
        }
        pRecycleBin->Release();
 
        switch (count)
        {
            case 0:
                /* no files, don't need confirmation */
                break;
 
            case 1:
                /* we have only one item inside the bin, so show a message box with its name */
                if (ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_DELETEITEM_TEXT), MAKEINTRESOURCEW(IDS_EMPTY_BITBUCKET),
                                   MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
                {
                    return S_OK;
                }
                break;
 
            default:
                /* we have more than one item, so show a message box with the count of the items */
                StringCbPrintfW(szBuffer, sizeof(szBuffer), L"%u", count);
                if (ShellMessageBoxW(shell32_hInstance, hwnd, MAKEINTRESOURCEW(IDS_DELETEMULTIPLE_TEXT), MAKEINTRESOURCEW(IDS_EMPTY_BITBUCKET),
                                   MB_ICONEXCLAMATION | MB_YESNO | MB_DEFBUTTON2, szBuffer) == IDNO)
                {
                    return S_OK;
                }
                break;
        }
    }
 
    if (dwFlags & SHERB_NOPROGRESSUI)
    {
        ret = EmptyRecycleBinW(pszRootPath);
    }
    else
    {
       /* FIXME
        * show a progress dialog
        */
        ret = EmptyRecycleBinW(pszRootPath);
    }
 
    if (!ret)
        return HRESULT_FROM_WIN32(GetLastError());
 
    CRecycleBin_ChangeNotifyBBItem(SHCNE_UPDATEDIR, NULL);
    if (!(dwFlags & SHERB_NOSOUND))
    {
        TRASH_PlayEmptyRecycleBinSound();
    }
    return S_OK;
}

Referenced by CRecycleBin::InvokeCommand(), CRecycleBinCleaner::Purge(), and SHEmptyRecycleBinA().

SHQueryRecycleBinA()

HRESULT WINAPI SHQueryRecycleBinA	(	LPCSTR	pszRootPath,
		LPSHQUERYRBINFO	pSHQueryRBInfo
	)

Definition at line 1433 of file CRecycleBin.cpp.

{
    LPWSTR szRootPathW = NULL;
    int len;
    HRESULT hr;
 
    TRACE("%s, %p\n", debugstr_a(pszRootPath), pSHQueryRBInfo);
 
    if (pszRootPath)
    {
        len = MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, NULL, 0);
        if (len == 0)
            return HRESULT_FROM_WIN32(GetLastError());
        szRootPathW = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
        if (!szRootPathW)
            return E_OUTOFMEMORY;
        if (MultiByteToWideChar(CP_ACP, 0, pszRootPath, -1, szRootPathW, len) == 0)
        {
            HeapFree(GetProcessHeap(), 0, szRootPathW);
            return HRESULT_FROM_WIN32(GetLastError());
        }
    }
 
    hr = SHQueryRecycleBinW(szRootPathW, pSHQueryRBInfo);
    HeapFree(GetProcessHeap(), 0, szRootPathW);
 
    return hr;
}

SHQueryRecycleBinW()

HRESULT WINAPI SHQueryRecycleBinW	(	LPCWSTR	pszRootPath,
		LPSHQUERYRBINFO	pSHQueryRBInfo
	)

Definition at line 1462 of file CRecycleBin.cpp.

{
    TRACE("%s, %p\n", debugstr_w(pszRootPath), pSHQueryRBInfo);
 
    if (!pszRootPath || (pszRootPath[0] == 0) ||
        !pSHQueryRBInfo || (pSHQueryRBInfo->cbSize < sizeof(SHQUERYRBINFO)))
    {
        return E_INVALIDARG;
    }
 
    pSHQueryRBInfo->i64Size = 0;
    pSHQueryRBInfo->i64NumItems = 0;
 
    CComPtr<IRecycleBin> spRecycleBin;
    HRESULT hr;
    if (FAILED_UNEXPECTEDLY((hr = GetDefaultRecycleBin(pszRootPath, &spRecycleBin))))
        return hr;
 
    CComPtr<IRecycleBinEnumList> spEnumList;
    hr = spRecycleBin->EnumObjects(&spEnumList);
    if (!SUCCEEDED(hr))
        return hr;
 
    while (TRUE)
    {
        CComPtr<IRecycleBinFile> spFile;
        hr = spEnumList->Next(1, &spFile, NULL);
        if (hr == S_FALSE)
            return S_OK;
 
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
 
        ULARGE_INTEGER Size = {};
        if (FAILED_UNEXPECTEDLY((hr = spFile->GetFileSize(&Size))))
            return hr;
 
        pSHQueryRBInfo->i64Size += Size.QuadPart;
        pSHQueryRBInfo->i64NumItems++;
    }
 
    return S_OK;
}

Referenced by CRecycleBinCleaner::GetSpaceUsed(), and SHQueryRecycleBinA().

SHUpdateRecycleBinIcon()

EXTERN_C HRESULT WINAPI SHUpdateRecycleBinIcon

(

void

)

Definition at line 1288 of file CRecycleBin.cpp.

{
    FIXME("stub\n");
 
    // HACK! This dwItem2 should be the icon index in the system image list that has changed.
    // FIXME: Call SHMapPIDLToSystemImageListIndex
    DWORD dwItem2 = -1;
 
    SHChangeNotify(SHCNE_UPDATEIMAGE, SHCNF_DWORD, NULL, &dwItem2);
    return S_OK;
}

Referenced by RecycleBin5::Delete(), FileOpCallback(), RecycleBin5::Restore(), and SHELL32_FileOperation().

TRASH_CanTrashFile()

BOOL TRASH_CanTrashFile

(

LPCWSTR

wszPath

)

Tests whether a file can be trashed

Parameters

wszPath

Path to the file to be trash

Returns

TRUE if the file can be trashed, FALSE otherwise

Definition at line 1154 of file CRecycleBin.cpp.

{
    LONG ret;
    DWORD dwNukeOnDelete, dwType, VolSerialNumber, MaxComponentLength;
    DWORD FileSystemFlags, dwSize, dwDisposition;
    HKEY hKey;
    WCHAR szBuffer[10];
    WCHAR szKey[150] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket\\Volume\\";
 
    if (wszPath[1] != L':')
    {
        /* path is UNC */
        return FALSE;
    }
 
    // Copy and retrieve the root path from get given string
    WCHAR wszRootPathName[MAX_PATH];
    StringCbCopyW(wszRootPathName, sizeof(wszRootPathName), wszPath);
    PathStripToRootW(wszRootPathName);
 
    // Test to see if the drive is fixed (non removable)
    if (GetDriveTypeW(wszRootPathName) != DRIVE_FIXED)
    {
        /* no bitbucket on removable media */
        return FALSE;
    }
 
    if (!GetVolumeInformationW(wszRootPathName, NULL, 0, &VolSerialNumber, &MaxComponentLength, &FileSystemFlags, NULL, 0))
    {
        ERR("GetVolumeInformationW failed with %u wszRootPathName=%s\n", GetLastError(), debugstr_w(wszRootPathName));
        return FALSE;
    }
 
    swprintf(szBuffer, L"%04X-%04X", LOWORD(VolSerialNumber), HIWORD(VolSerialNumber));
    wcscat(szKey, szBuffer);
 
    if (RegCreateKeyExW(HKEY_CURRENT_USER, szKey, 0, NULL, 0, KEY_READ | KEY_WRITE, NULL, &hKey, &dwDisposition) != ERROR_SUCCESS)
    {
        ERR("RegCreateKeyExW failed\n");
        return FALSE;
    }
 
    if (dwDisposition  & REG_CREATED_NEW_KEY)
    {
        /* per default move to bitbucket */
        dwNukeOnDelete = 0;
        RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
        /* per default unlimited size */
        dwSize = -1;
        RegSetValueExW(hKey, L"MaxCapacity", 0, REG_DWORD, (LPBYTE)&dwSize, sizeof(DWORD));
    }
    else
    {
        dwSize = sizeof(dwNukeOnDelete);
        ret = RegQueryValueExW(hKey, L"NukeOnDelete", NULL, &dwType, (LPBYTE)&dwNukeOnDelete, &dwSize);
        if (ret != ERROR_SUCCESS)
        {
            dwNukeOnDelete = 0;
            if (ret == ERROR_FILE_NOT_FOUND)
            {
                /* restore key and enable bitbucket */
                RegSetValueExW(hKey, L"NukeOnDelete", 0, REG_DWORD, (LPBYTE)&dwNukeOnDelete, sizeof(DWORD));
            }
        }
    }
    BOOL bCanTrash = !dwNukeOnDelete;
    // FIXME: Check if bitbucket is full (CORE-13743)
    RegCloseKey(hKey);
    return bCanTrash;
}

Referenced by delete_files().

TRASH_PlayEmptyRecycleBinSound()

static void TRASH_PlayEmptyRecycleBinSound ( )

static

Definition at line 1232 of file CRecycleBin.cpp.

{
    CRegKey regKey;
    CHeapPtr<WCHAR> pszValue;
    CHeapPtr<WCHAR> pszSndPath;
    DWORD dwType, dwSize;
    LONG lError;
 
    lError = regKey.Open(HKEY_CURRENT_USER,
                         L"AppEvents\\Schemes\\Apps\\Explorer\\EmptyRecycleBin\\.Current",
                         KEY_READ);
    if (lError != ERROR_SUCCESS)
        return;
 
    lError = regKey.QueryValue(NULL, &dwType, NULL, &dwSize);
    if (lError != ERROR_SUCCESS)
        return;
 
    if (!pszValue.AllocateBytes(dwSize))
        return;
 
    lError = regKey.QueryValue(NULL, &dwType, pszValue, &dwSize);
    if (lError != ERROR_SUCCESS)
        return;
 
    if (dwType == REG_EXPAND_SZ)
    {
        dwSize = ExpandEnvironmentStringsW(pszValue, NULL, 0);
        if (dwSize == 0)
            return;
 
        if (!pszSndPath.Allocate(dwSize))
            return;
 
        if (ExpandEnvironmentStringsW(pszValue, pszSndPath, dwSize) == 0)
            return;
    }
    else if (dwType == REG_SZ)
    {
        /* The type is REG_SZ, no need to expand */
        pszSndPath.Attach(pszValue.Detach());
    }
    else
    {
        /* Invalid type */
        return;
    }
 
    PlaySoundW(pszSndPath, NULL, SND_FILENAME | SND_ASYNC | SND_NODEFAULT);
}

Referenced by SHEmptyRecycleBinW().

TRASH_TrashFile()

BOOL TRASH_TrashFile

(

LPCWSTR

wszPath

)

Definition at line 1226 of file CRecycleBin.cpp.

{
    TRACE("(%s)\n", debugstr_w(wszPath));
    return DeleteFileToRecycleBin(wszPath);
}

Referenced by delete_files().

ValidateItem()

static BBITEMDATA * ValidateItem ( LPCITEMIDLIST  pidl )

static

Definition at line 89 of file CRecycleBin.cpp.

{
    const UINT minstringsize = sizeof(L"X") + sizeof(""); // PT_FS strings
    const UINT minfs = sizeof(WORD) + FIELD_OFFSET(PIDLDATA, u.file.szNames) + minstringsize;
    const UINT mindatasize = FIELD_OFFSET(BBITEMDATA, OriginalLocation) + (sizeof(L"C:\\X") * 2);
    const UINT minsize = minfs + mindatasize + sizeof(BBITEMFOOTER);
    const BYTE type = _ILGetType(pidl);
    if ((type == BBITEMFILETYPE || type == BBITEMFOLDERTYPE) && pidl->mkid.cb >= minsize)
    {
        BBITEMFOOTER *pEnd = (BBITEMFOOTER*)((BYTE*)pidl + pidl->mkid.cb - sizeof(BBITEMFOOTER));
        if (pEnd->EndSignature == BBITEMFOOTER::ENDSIG && pEnd->DataSize >= mindatasize)
            return (BBITEMDATA*)((BYTE*)pEnd - pEnd->DataSize);
    }
    return NULL;
}

Referenced by ConfirmDelete(), CreateFileOpStrings(), CreateItem(), CRecycleBin_ChangeNotifyBBItem(), FileOpCallback(), and GetItemDriveNumber().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

CRecycleBin

)

Variable Documentation

g_BBFolderVerbMap

const CMVERBMAP g_BBFolderVerbMap[]

static

Initial value:

=
{
    { "empty", IDC_EMPTYRECYCLEBIN },
    { "properties", IDC_PROPERTIES },
    { NULL }
}

Definition at line 1054 of file CRecycleBin.cpp.

Referenced by CRecycleBin::GetCommandString(), and CRecycleBin::InvokeCommand().

g_BBItemVerbMap

const CMVERBMAP g_BBItemVerbMap[]

static

Initial value:

=
{
    { "undelete", IDC_BB_RESTORE },
    { "cut", IDC_BB_CUT },
    { "delete", IDC_BB_DELETE },
    { "properties", IDC_BB_PROPERTIES },
    { NULL }
}

Definition at line 422 of file CRecycleBin.cpp.

Referenced by CRecycleBinItemContextMenu::GetCommandString(), and CRecycleBinItemContextMenu::InvokeCommand().

RecycleBinColumns

const columninfo RecycleBinColumns[]

static

Initial value:

=
{
    {IDS_SHV_COLUMN_NAME,     &FMTID_Storage,   PID_STG_NAME,        SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  25},
    {IDS_SHV_COLUMN_DELFROM,  &FMTID_Displaced, PID_DISPLACED_FROM,  SHCOLSTATE_TYPE_STR | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  35},
    {IDS_SHV_COLUMN_DELDATE,  &FMTID_Displaced, PID_DISPLACED_DATE,  SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  15},
    {IDS_SHV_COLUMN_SIZE,     &FMTID_Storage,   PID_STG_SIZE,        SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_RIGHT, 10},
    {IDS_SHV_COLUMN_TYPE,     &FMTID_Storage,   PID_STG_STORAGETYPE, SHCOLSTATE_TYPE_INT | SHCOLSTATE_ONBYDEFAULT,  LVCFMT_LEFT,  15},
    {IDS_SHV_COLUMN_MODIFIED, &FMTID_Storage,   PID_STG_WRITETIME,   SHCOLSTATE_TYPE_DATE | SHCOLSTATE_ONBYDEFAULT, LVCFMT_LEFT,  15},
    
    
}

Definition at line 40 of file CRecycleBin.cpp.

Referenced by CRecycleBin::GetDefaultColumnState(), CRecycleBin::GetDetailsOf(), and CRecycleBin::MapColumnToSCID().