8443 lines
289 KiB
C
8443 lines
289 KiB
C
// Copyright (c) <1995-1999> Microsoft Corporation
|
|
|
|
#include "shellprv.h"
|
|
#pragma hdrstop
|
|
|
|
#include <msi.h>
|
|
#include <msip.h>
|
|
|
|
#include <aclapi.h> // for TreeResetNamedSecurityInfo
|
|
|
|
#include "shlwapip.h" // for SHGlobalCounterDecrement
|
|
#include "ynlist.h"
|
|
|
|
#define INTERNAL_COPY_ENGINE
|
|
#include "copy.h"
|
|
#include "shell32p.h"
|
|
#include "control.h"
|
|
#include "cdburn.h"
|
|
#include "propsht.h"
|
|
#include "prshtcpp.h"
|
|
|
|
#define REG_VAL_GENERAL_RENAMEHTMLFILE TEXT("RenameHtmlFile")
|
|
|
|
#define TF_DEBUGCOPY 0x00800000
|
|
|
|
#define VERBOSE_STATUS
|
|
|
|
// REVIEW, we should tune this size down as small as we can
|
|
// to get smoother multitasking (without effecting performance)
|
|
#define COPYMAXBUFFERSIZE 0x10000 // 0xFFFF this is 32-bit code!
|
|
#define MIN_MINTIME4FEEDBACK 5 // is it worth showing estimated time to completion feedback?
|
|
#define MS_RUNAVG 10000 // ms, window for running average time to completion estimate
|
|
#define MS_TIMESLICE 2000 // ms, (MUST be > 1000!) first average time to completion estimate
|
|
|
|
#define MAXDIRDEPTH 128 // # of directories we will deal with recursivly
|
|
|
|
#define SHOW_PROGRESS_TIMEOUT 1000 // 1 second
|
|
#define MINSHOWTIME 1000 // 1 sec
|
|
|
|
// progress dialog message
|
|
#define PDM_SHUTDOWN WM_APP
|
|
#define PDM_NOOP (WM_APP + 1)
|
|
#define PDM_UPDATE (WM_APP + 2)
|
|
|
|
|
|
#define OPER_MASK 0x0F00
|
|
#define OPER_ENTERDIR 0x0100
|
|
#define OPER_LEAVEDIR 0x0200
|
|
#define OPER_DOFILE 0x0300
|
|
#define OPER_ERROR 0x0400
|
|
|
|
#define FOFuncToStringID(wFunc) (IDS_UNDO_FILEOP + wFunc)
|
|
|
|
//
|
|
// The following is a list of folder suffixes in all international languages. This list is NOT
|
|
// read from a resource because we do NOT want the strings in this list to be mistakenly localized.
|
|
// This list will allow NT5 shell to operate on files created by any international version of
|
|
// office 9.
|
|
// This list is taken from "http://officeweb/specs/webclient/files.htm"
|
|
//
|
|
// WARNING: Do not localize the strings in this table. Do not make any changes to this table
|
|
// without consulting AlanRa (Office9 PM)
|
|
//
|
|
static const LPCTSTR c_apszSuffixes[] =
|
|
{
|
|
TEXT(".files"),
|
|
TEXT("_files"),
|
|
TEXT("-Dateien"),
|
|
TEXT("_fichiers"),
|
|
TEXT("_bestanden"),
|
|
TEXT("_file"),
|
|
TEXT("_archivos"),
|
|
TEXT("-filer"),
|
|
TEXT("_tiedostot"),
|
|
TEXT("_pliki"),
|
|
TEXT("_soubory"),
|
|
TEXT("_elemei"),
|
|
TEXT("_ficheiros"),
|
|
TEXT("_arquivos"),
|
|
TEXT("_dosyalar"),
|
|
TEXT("_datoteke"),
|
|
TEXT("_fitxers"),
|
|
TEXT("_failid"),
|
|
TEXT("_fails"),
|
|
TEXT("_bylos"),
|
|
TEXT("_fajlovi"),
|
|
TEXT("_fitxategiak"),
|
|
};
|
|
|
|
// The reg value under HKCU\REGSTR_PATH_EXPLORER that specifies Connection ON/OFF switch
|
|
#define REG_VALUE_NO_FILEFOLDER_CONNECTION TEXT("NoFileFolderConnection")
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
///// directory tree cache.
|
|
|
|
|
|
// this is set if pdtnChild has not been traversed (as opposed to NULL which means
|
|
// there are no children
|
|
#define DTN_DELAYED ((PDIRTREENODE)-1)
|
|
|
|
|
|
// DIRTREENODE is a node in a linked list/tree cache of the directory structure.
|
|
// except for the top level (which is specified by the caller of the api), the order
|
|
// are all files first, then all directories.
|
|
|
|
typedef struct _dirtreenode {
|
|
|
|
struct _dirtreenode *pdtnNext; // sibling
|
|
struct _dirtreenode *pdtnChild; // head of children linked list
|
|
struct _dirtreenode *pdtnParent;
|
|
|
|
DWORD dwFileAttributes;
|
|
FILETIME ftCreationTime;
|
|
FILETIME ftLastWriteTime;
|
|
DWORD nFileSizeLow;
|
|
DWORD nFileSizeHigh;
|
|
|
|
LARGE_INTEGER liFileSizeCopied;
|
|
BOOL fNewRoot : 1;
|
|
BOOL fDummy : 1; // this marks the node as a dummy node (a wildcard that didn't match anything)
|
|
BOOL fConnectedElement : 1; // this marks the node as an element that was implicitly added
|
|
// to the Move/Copy source list because of an office9 type of
|
|
// connection established in the registry.
|
|
|
|
//The following is a union because not all nodes need all the fields.
|
|
union {
|
|
// The following is valid only if fConnectedElement is FALSE.
|
|
struct _dirtreenode *pdtnConnected;
|
|
|
|
// The following structure is valid only if fConnectedElemet is TRUE.
|
|
struct {
|
|
LPTSTR pFromConnected; // if fNewRoot && fConnectedElement, then these two elements
|
|
LPTSTR pToConnected; // have the pFrom and pTo.
|
|
DWORD dwConfirmation; // The result of confirnation given by end-user
|
|
} ConnectedInfo;
|
|
};
|
|
|
|
TCHAR szShortName[14];
|
|
TCHAR szName[1]; // this struct is dynamic
|
|
|
|
} DIRTREENODE, *PDIRTREENODE;
|
|
|
|
typedef struct {
|
|
BOOL fChanged;
|
|
DWORD dwFiles; // number of files
|
|
DWORD dwFolders; // number of folders
|
|
LARGE_INTEGER liSize; // total size of all files
|
|
} DIRTOTALS, *PDIRTOTALS;
|
|
|
|
typedef struct {
|
|
UINT oper;
|
|
DIRTOTALS dtAll; // totals for all files
|
|
DIRTOTALS dtDone; // totals of what's done
|
|
BOOL fChangePosted;
|
|
|
|
PDIRTREENODE pdtn; // first directory tree node
|
|
PDIRTREENODE pdtnCurrent;
|
|
PDIRTREENODE pdtnConnectedItems; //Pointer to the begining of connected elements node.
|
|
TCHAR bDiskCheck[26];
|
|
|
|
// how much does each operation cost in the progress...
|
|
int iFilePoints;
|
|
int iFolderPoints;
|
|
int iSizePoints;
|
|
|
|
|
|
LPTSTR pTo; // this holds the top level target list
|
|
LPTSTR pFrom; // this holds the top level source list
|
|
BOOL fMultiDest;
|
|
|
|
TCHAR szSrcPath[MAX_PATH];
|
|
TCHAR szDestPath[MAX_PATH]; // this is the current destination for pdtn and all it's children (not siblings)
|
|
// lpszDestPath includes pdtn's first path component
|
|
|
|
HDSA hdsaRenamePairs;
|
|
|
|
} DIRTREEHEADER, *PDIRTREEHEADER;
|
|
|
|
// We spend a lot of time creating simple PIDLs, so use this cache
|
|
// to speed things up.
|
|
typedef struct SIMPLEPIDLCACHE {
|
|
IBindCtx *pbcFile; // Empty filesys bind context for files
|
|
IBindCtx *pbcFolder; // Empty filesys bind context for folders
|
|
IShellFolder *psfDesktop; // Desktop folder (for ParseDisplayName)
|
|
int iInit; // 0 = not inited; 1 = inited; -1 = init failed
|
|
IShellFolder *psf; // Current folder
|
|
LPITEMIDLIST pidlFolder; // Current folder
|
|
TCHAR szFolder[MAX_PATH]; // Current folder
|
|
} SIMPLEPIDLCACHE, *PSIMPLEPIDLCACHE;
|
|
|
|
typedef struct {
|
|
int nRef; // struct reference count
|
|
|
|
int nSourceFiles;
|
|
LPTSTR lpCopyBuffer; // global file copy buffer
|
|
UINT uSize; // size of this buffer
|
|
FILEOP_FLAGS fFlags; // from SHFILEOPSTRUCT
|
|
HWND hwndProgress; // dialog/progress window
|
|
HWND hwndDlgParent; // parent window for message boxes
|
|
CONFIRM_DATA cd; // confirmation stuff
|
|
|
|
UNDOATOM *lpua; // the undo atom that this file operation will make
|
|
BOOL fNoConfirmRecycle;
|
|
BOOL bAbort;
|
|
BOOL fMerge; // are we doing a merge of folders
|
|
|
|
BOOL fDone;
|
|
BOOL fProgressOk;
|
|
BOOL fDTBuilt;
|
|
BOOL fLostEncryptOk;
|
|
BOOL fFromCDRom; // Clear readonly bits if copying from CDRom
|
|
|
|
// folowing fields are used for giving estimated time for completion
|
|
// feedback to the user during longer than MINTIME4FEEDBACK operations
|
|
BOOL fFlushWrites; // Should we flush writes for destinations on slow links
|
|
|
|
DWORD dwPreviousTime; // calculate transfer rate
|
|
int iLastProgressPoints; // how many progress points we had the last time we updated the time est
|
|
DWORD dwPointsPerSec;
|
|
LPCTSTR lpszProgressTitle;
|
|
LPSHFILEOPSTRUCT lpfo;
|
|
|
|
DIRTREEHEADER dth;
|
|
BOOL fInitialize;
|
|
const WIN32_FIND_DATA* pfd;
|
|
BOOL bStreamLossPossible; // Could stream loss happen in this directory?
|
|
|
|
SIMPLEPIDLCACHE spc;
|
|
} COPY_STATE, *LPCOPY_STATE;
|
|
|
|
// we have a seperate struct that we pass off to the FOUIThread so that he can get to the pcs,
|
|
// but since the FOUIThread can outlive the main thread (!!) in some cases, we can't let him have a
|
|
// ref to pcs->lpfo since it is owned by SHFileOperations caller and we crash if we try to refrence
|
|
// it after SHFileOperation returns and the caller has freed the memory. The only two things the
|
|
// FOUIThread uses out of the pcs->lpfo are the wFunc and the lpszProgressTitle (to see if the
|
|
// recycle bin was being emptied or not), so we make private copies of that info for the thread.
|
|
typedef struct {
|
|
COPY_STATE* pcs;
|
|
UINT wFunc;
|
|
BOOL bIsEmptyRBOp;
|
|
} FOUITHREADINFO, *PFOUITHREADINFO;
|
|
|
|
// Information to determine folder's movability to the recycle bin
|
|
typedef struct {
|
|
BOOL bProcessedRoot; // tells if we are the first call in the recursive chain and we need to do root-specific processing
|
|
int cchBBDir; // count of characters in the recycle bin dir (eg "C:\Recycler\<sid>")
|
|
int cchDelta; // count of characters that the path will increase (or decrease if negative) by when moved under the recycle bin directory
|
|
ULONGLONG cbSize; // size of the folder
|
|
TCHAR szNonDeletableFile[MAX_PATH]; // an output buffer that holds the name of the file that cannot be deleted, if one exists
|
|
TCHAR szPath[MAX_PATH]; // scratch buffer for stack savings when recursing
|
|
WIN32_FIND_DATA fd; // also for stack savings
|
|
} FOLDERDELETEINFO;
|
|
|
|
|
|
// function declarations
|
|
void _ProcessNameMappings(LPTSTR pszTarget, HDSA hdsaRenamePairs);
|
|
int GetNameDialog(HWND hwnd, COPY_STATE *pcs, BOOL fMultiple,UINT wOp, LPTSTR pFrom, LPTSTR pTo);
|
|
void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs);
|
|
BOOL FOQueryAbort(COPY_STATE *pcs);
|
|
UINT DTAllocConnectedItemNodes(PDIRTREEHEADER pdth, COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR pszPath, BOOL fRecurse, PDIRTREENODE *ppdtnConnectedItems);
|
|
void CALLBACK FOUndo_Invoke(UNDOATOM *lpua);
|
|
LONG CheckFolderSizeAndDeleteability(LPCTSTR pszDir, FOLDERDELETEINFO* pfdi, LPCOPY_STATE pcs);
|
|
BOOL DeleteFileBB(LPTSTR pszFile, INT *piReturn, COPY_STATE *pcs, BOOL fIsDir, WIN32_FIND_DATA *pfd, HDPA *phdpaDeletedFiles);
|
|
|
|
|
|
BOOL DTDiskCheck(PDIRTREEHEADER pdth, COPY_STATE *pcs, LPTSTR pszPath)
|
|
{
|
|
int iDrive = PathGetDriveNumber(pszPath);
|
|
|
|
if (iDrive != -1)
|
|
{
|
|
if (!pdth->bDiskCheck[iDrive])
|
|
{
|
|
HWND hwnd = pcs->hwndDlgParent;
|
|
TCHAR szDrive[] = TEXT("A:\\");
|
|
szDrive[0] += (CHAR)iDrive;
|
|
|
|
// Sometimes pszPath is a dir and sometimes it's a file. All we really care about is if the
|
|
// drive is ready (inserted, formated, net path mapped, etc). We know that we don't have a
|
|
// UNC path because PathGetDriveNumber would have failed and we are already busted in terms
|
|
// of mounted volumes, again because we use PathGetDriveNumber, so we don't have to worry about
|
|
// these two cases. As such we build the root path and use that instead.
|
|
pdth->bDiskCheck[iDrive] = SUCCEEDED(SHPathPrepareForWrite(((pcs->fFlags & FOF_NOERRORUI) ? NULL : hwnd), NULL, szDrive, 0));
|
|
}
|
|
return pdth->bDiskCheck[iDrive];
|
|
}
|
|
|
|
return TRUE; // always succeed for net drives
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
// Simple pidl cache stuff
|
|
//--------------------------------------------------------------------------------------------
|
|
|
|
void SimplePidlCache_Release(SIMPLEPIDLCACHE *pspc)
|
|
{
|
|
ATOMICRELEASE(pspc->pbcFile);
|
|
ATOMICRELEASE(pspc->pbcFolder);
|
|
ATOMICRELEASE(pspc->psfDesktop);
|
|
ATOMICRELEASE(pspc->psf);
|
|
ILFree(pspc->pidlFolder);
|
|
}
|
|
|
|
const WIN32_FIND_DATA c_fdFolder = { FILE_ATTRIBUTE_DIRECTORY };
|
|
|
|
BOOL SimplePidlCache_Init(SIMPLEPIDLCACHE *pspc)
|
|
{
|
|
ASSERT(pspc->iInit == 0);
|
|
|
|
if (SUCCEEDED(SHCreateFileSysBindCtx(NULL, &pspc->pbcFile)) &&
|
|
SUCCEEDED(SHCreateFileSysBindCtx(&c_fdFolder, &pspc->pbcFolder)) &&
|
|
SUCCEEDED(SHGetDesktopFolder(&pspc->psfDesktop)))
|
|
{
|
|
pspc->psf = pspc->psfDesktop;
|
|
pspc->psf->lpVtbl->AddRef(pspc->psf);
|
|
// It's okay to leave pidlFolder as NULL; ILCombine won't barf
|
|
|
|
pspc->iInit = 1;
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
pspc->iInit = -1;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
LPITEMIDLIST SimplePidlCache_GetFilePidl(SIMPLEPIDLCACHE *pspc, LPCTSTR pszFile)
|
|
{
|
|
LPITEMIDLIST pidlChild;
|
|
LPITEMIDLIST pidlRet;
|
|
LPTSTR pszFileName;
|
|
TCHAR szFolder[MAX_PATH];
|
|
USES_CONVERSION;
|
|
|
|
if (pspc->iInit < 0)
|
|
return NULL; // Initialization failed
|
|
|
|
if (!pspc->iInit && !SimplePidlCache_Init(pspc))
|
|
return NULL;
|
|
|
|
// If this file is in a different folder from the one we cached,
|
|
// need to dump the old one and get a new one.
|
|
|
|
lstrcpyn(szFolder, pszFile, ARRAYSIZE(szFolder));
|
|
PathRemoveFileSpec(szFolder);
|
|
|
|
// We use StrCmpC instead of lstrcmpi because the vast majority
|
|
// of the time, the path will match even in case, and if we get
|
|
// it wrong, it's no big whoop: we just don't use the cache.
|
|
|
|
if (StrCmpC(pspc->szFolder, szFolder) != 0)
|
|
{
|
|
LPITEMIDLIST pidlFolder = NULL; // In case it's on the desktop
|
|
IShellFolder *psf;
|
|
|
|
if (szFolder[0]) // An actual folder
|
|
{
|
|
// Get a simple pidl to the folder.
|
|
if (FAILED(pspc->psfDesktop->lpVtbl->ParseDisplayName(pspc->psfDesktop, NULL,
|
|
pspc->pbcFolder, T2W(szFolder), NULL, &pidlFolder, NULL)))
|
|
return NULL;
|
|
}
|
|
else // Going for the desktop
|
|
{
|
|
/* pidlFolder already preinitialized to NULL */
|
|
}
|
|
|
|
// Bind to that folder
|
|
if (FAILED(SHBindToObject(pspc->psfDesktop, IID_X_PPV_ARG(IShellFolder, pidlFolder, &psf))))
|
|
{
|
|
ILFree(pidlFolder);
|
|
return NULL;
|
|
}
|
|
|
|
// Woo-hoo, everybody is happy. Save the results into our cache.
|
|
|
|
ATOMICRELEASE(pspc->psf);
|
|
pspc->psf = psf;
|
|
|
|
ILFree(pspc->pidlFolder);
|
|
pspc->pidlFolder = pidlFolder;
|
|
|
|
lstrcpyn(pspc->szFolder, szFolder, ARRAYSIZE(pspc->szFolder));
|
|
|
|
}
|
|
|
|
// Get a simple pidl to the filename
|
|
pszFileName = PathFindFileName(pszFile); // T2W is a macro with multiple evaluation
|
|
if (FAILED(pspc->psf->lpVtbl->ParseDisplayName(pspc->psf, NULL, pspc->pbcFile,
|
|
T2W(pszFileName), NULL, &pidlChild, NULL)))
|
|
return NULL;
|
|
|
|
// Combine it with the parent
|
|
pidlRet = ILCombine(pspc->pidlFolder, pidlChild);
|
|
ILFree(pidlChild);
|
|
|
|
return pidlRet;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
// ConvertToConnectedItemname:
|
|
// Given a file/folder name, this function checks to see if it has any connection and if
|
|
// there is a connection, then it will convert the given name to that of the connected element
|
|
// and return length of the prefix. If no connection exists, it returns zero.
|
|
// The fDirectory parameter specifies if the given filename is a FOLDER or not!
|
|
//
|
|
// dwBuffSize: The size of pszFileName buffer in CHARACTERS.
|
|
//
|
|
// Examples:
|
|
// "foo.htm" => "foo*" (returns 3 because the prefix("foo") length is 3)
|
|
// "foobar files" => "foobar.htm?" (returns 6 as the prefix length)
|
|
//
|
|
//--------------------------------------------------------------------------------------------
|
|
int ConvertToConnectedItemName(LPTSTR pszFileName, DWORD dwBuffSize, BOOL fDirectory)
|
|
{
|
|
LPTSTR pszDest, pszConnectedElemSuffix;
|
|
int iPrefixLength;
|
|
|
|
if (fDirectory)
|
|
{
|
|
// Look for a suffix which is one of the standard suffixes.
|
|
if (!(pszDest = (LPTSTR)PathFindSuffixArray(pszFileName, c_apszSuffixes, ARRAYSIZE(c_apszSuffixes))))
|
|
return FALSE;
|
|
|
|
// " files" suffix is found. Replace it with ".htm?"
|
|
pszConnectedElemSuffix = TEXT(".htm?");
|
|
}
|
|
else
|
|
{
|
|
// Look for the extension ".htm" or ".html" and replace it with "*".
|
|
if (!(pszDest = PathFindExtension(pszFileName)))
|
|
return FALSE;
|
|
|
|
if (lstrcmpi(pszDest, TEXT(".htm")) && (lstrcmpi(pszDest, TEXT(".html"))))
|
|
return FALSE;
|
|
|
|
// Extension ".htm" or ".html" is found. Replace it with "*"
|
|
pszConnectedElemSuffix = (LPTSTR)c_szStar;
|
|
}
|
|
|
|
iPrefixLength = (int)(pszDest - pszFileName);
|
|
|
|
//Check if the input buffer is big enough to over-write the suffix in-place
|
|
if ((((int)dwBuffSize - iPrefixLength) - 1) < lstrlen(pszConnectedElemSuffix))
|
|
return 0;
|
|
|
|
//Replace the source suffix with the connected element's suffix.
|
|
lstrcpy(pszDest, pszConnectedElemSuffix);
|
|
|
|
return(iPrefixLength);
|
|
}
|
|
|
|
PDIRTREENODE DTAllocNode(PDIRTREEHEADER pdth, WIN32_FIND_DATA* pfd, PDIRTREENODE pdtnParent, PDIRTREENODE pdtnNext, BOOL fConnectedElement)
|
|
{
|
|
int iLen = pfd ? lstrlen(pfd->cFileName) * sizeof(TCHAR) : 0;
|
|
PDIRTREENODE pdtn = (PDIRTREENODE)LocalAlloc(LPTR, sizeof(DIRTREENODE) + iLen);
|
|
if (pdtn)
|
|
{
|
|
pdtn->fConnectedElement = fConnectedElement;
|
|
|
|
// Initializing the following to NULL is not needed because of the LPTR (zero init) done
|
|
// above.
|
|
// if (fConnectedElement)
|
|
//{
|
|
// pdtn->ConnectedInfo.pFromConnected = pdtn->ConnectedInfo.pToConnected = NULL;
|
|
// pdtn->ConnectedInfo.dwConfirmation = 0;
|
|
//}
|
|
//else
|
|
// pdtn->pdtnConnected = NULL;
|
|
|
|
pdtn->pdtnParent = pdtnParent;
|
|
pdtn->pdtnNext = pdtnNext;
|
|
|
|
if (pfd)
|
|
{
|
|
pdtn->dwFileAttributes = pfd->dwFileAttributes;
|
|
pdtn->ftCreationTime = pfd->ftCreationTime;
|
|
pdtn->ftLastWriteTime = pfd->ftLastWriteTime;
|
|
pdtn->nFileSizeLow = pfd->nFileSizeLow;
|
|
pdtn->nFileSizeHigh = pfd->nFileSizeHigh;
|
|
|
|
// only the stuff we care about
|
|
lstrcpy(pdtn->szShortName, pfd->cAlternateFileName);
|
|
lstrcpy(pdtn->szName, pfd->cFileName);
|
|
|
|
|
|
if (ISDIRFINDDATA(*pfd))
|
|
{
|
|
pdth->dtAll.dwFolders++;
|
|
pdtn->pdtnChild = DTN_DELAYED;
|
|
}
|
|
else
|
|
{
|
|
LARGE_INTEGER li;
|
|
|
|
li.LowPart = pfd->nFileSizeLow;
|
|
li.HighPart = pfd->nFileSizeHigh;
|
|
|
|
pdth->dtAll.liSize.QuadPart += li.QuadPart;
|
|
pdth->dtAll.dwFiles++;
|
|
}
|
|
// increment the header stats
|
|
pdth->dtAll.fChanged = TRUE;
|
|
}
|
|
}
|
|
|
|
return pdtn;
|
|
}
|
|
|
|
#if defined(DEBUG) /// && defined(DEBUGCOPY)
|
|
void DebugDumpPDTN(PDIRTREENODE pdtn, LPTSTR ptext)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("***** PDTN %x (%s)"), pdtn, ptext);
|
|
//Safe-guard against pdtn being NULL!
|
|
if (pdtn)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("** %s %s"), pdtn->szShortName, pdtn->szName);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("** %x %d"), pdtn->dwFileAttributes, pdtn->nFileSizeLow);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("** %x %x %x"), pdtn->pdtnParent, pdtn->pdtnNext, pdtn->pdtnChild);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("** NewRoot:%x, Connected:%x, Dummy:%x"), pdtn->fNewRoot, pdtn->fConnectedElement, pdtn->fDummy);
|
|
if (pdtn->fConnectedElement)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("**** Connected: pFromConnected:%s, pToConnected:%s, dwConfirmation:%x"), pdtn->ConnectedInfo.pFromConnected,
|
|
pdtn->ConnectedInfo.pToConnected, pdtn->ConnectedInfo.dwConfirmation);
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("**** Origin: pdtnConnected:%x"), pdtn->pdtnConnected);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("** NULL pointer(PDTN)"));
|
|
}
|
|
}
|
|
#else
|
|
#define DebugDumpPDTN(p, x) 0
|
|
#endif
|
|
|
|
BOOL DoesSuffixMatch(LPTSTR lpSuffix, const LPCTSTR *apSuffixes, int iArraySize)
|
|
{
|
|
while (iArraySize--)
|
|
{
|
|
// Note: This must be a case sensitive compare, because we don't want to pickup
|
|
// "Program Files".
|
|
if (!lstrcmp(lpSuffix, *apSuffixes++))
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------------------------
|
|
//
|
|
// DTPathToDTNode:
|
|
// This function is used to build a list of nodes that correspond to the given pszPath.
|
|
// This list is built under "ppdtn". If ppdtnConnectedItems is given, another list of nodes that
|
|
// correspond to the connected elements(files/folders) of the nodes in the first list is also built
|
|
// under "ppdtnConnectedItems".
|
|
//
|
|
// WARNING: This parties directly on pszPath and pfd so that it doesn't need to allocate
|
|
// on the stack. This recurses, so we want to use as little stack as possible
|
|
//
|
|
// this will wack off one component from pszPath
|
|
//
|
|
//
|
|
// ppdtn: Points to where the header of the list being built will be stored.
|
|
// ppdtnConnectedItems: If this is NULL, then we are not interested in finding and building the
|
|
// connected elements. If this is NOT null, it points to where the header of
|
|
// the connected items list will be stored.
|
|
// fConnectedElement: Each node being built under ppdtn needs to be marked with this bit.
|
|
// iPrefixLength: This parameter is zero if fConnectedElement is FALSE. Otherwise, it contains the
|
|
// Length of the prefix part of the file or foldername (path is NOT included).
|
|
// For example, if "c:\windows\foo*" is passed in, iPrefixLength is 3 (length of "foo")
|
|
//
|
|
// dwFilesOrFolders parameter can specify if we need to look for only FILES or FOLDERs or BOTH.
|
|
|
|
#define DTF_FILES_ONLY 0x00000001 //Operate only on Files.
|
|
#define DTF_FOLDERS_ONLY 0x00000002 //Operate only on Folders.
|
|
#define DTF_FILES_AND_FOLDERS (DTF_FILES_ONLY | DTF_FOLDERS_ONLY) //Operate on files AND folders.
|
|
|
|
UINT DTPathToDTNode(PDIRTREEHEADER pdth, COPY_STATE *pcs, LPTSTR pszPath, BOOL fRecurse,
|
|
DWORD dwFilesOrFolders, PDIRTREENODE* ppdtn, WIN32_FIND_DATA *pfd,
|
|
PDIRTREENODE pdtnParent, PDIRTREENODE* ppdtnConnectedItems, BOOL fConnectedElement,
|
|
int iPrefixLength)
|
|
{
|
|
int iError = 0;
|
|
|
|
// this points to the var where all items are inserted.
|
|
// folders are placed after it, files are placed before
|
|
|
|
// keep the stack vars to a minimum because this is recursive
|
|
PDIRTREENODE *ppdtnMiddle = ppdtn;
|
|
BOOL fNeedToFindNext = TRUE;
|
|
HANDLE hfind = FindFirstFile(pszPath, pfd);
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTPathToDTNode Entering %s"), pszPath);
|
|
*ppdtnMiddle = NULL; // in case there are no children
|
|
|
|
if (hfind == INVALID_HANDLE_VALUE)
|
|
{
|
|
// this is allowable only if the path is wild...
|
|
// and the parent exists
|
|
if (PathIsWild(pszPath))
|
|
{
|
|
PathRemoveFileSpec(pszPath);
|
|
if (PathFileExists(pszPath))
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
return OPER_ERROR | ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
//Remove the filespec before passing it onto DTAllocConnectedItemNodes.
|
|
PathRemoveFileSpec(pszPath);
|
|
|
|
do
|
|
{
|
|
// We skip the following files:
|
|
// "." and ".." filenames
|
|
// Folders when DTF_FILES_ONLY is set
|
|
// Files when DTF_FOLDERS_ONLY is set
|
|
|
|
if (!PathIsDotOrDotDot(pfd->cFileName) &&
|
|
(((dwFilesOrFolders & DTF_FILES_ONLY) && !ISDIRFINDDATA(*pfd)) ||
|
|
((dwFilesOrFolders & DTF_FOLDERS_ONLY) && ISDIRFINDDATA(*pfd))))
|
|
{
|
|
//Check if we are looking for connected elements
|
|
if ((!pdtnParent) && fConnectedElement)
|
|
{
|
|
// We found what we are looking for. If we are looking for a top-level connected item and
|
|
// if it is a folder, then we need to make sure that the suffix exactly matches one of the
|
|
// suffixes in the array c_apszSuffixes[].
|
|
LPTSTR lpSuffix = (LPTSTR)(pfd->cFileName + iPrefixLength);
|
|
|
|
if (ISDIRFINDDATA(*pfd))
|
|
{
|
|
// What we found is a directory!
|
|
// See if it has one of the standard suffixes for connected folders.
|
|
if (!DoesSuffixMatch(lpSuffix, c_apszSuffixes, ARRAYSIZE(c_apszSuffixes)))
|
|
continue; //This is not what we look for. So, find next.
|
|
}
|
|
else
|
|
{
|
|
// What we found is a file (i.e Not a directory)
|
|
// See if it has one of the standard suffixes for html files.
|
|
if (lstrcmpi(lpSuffix, TEXT(".htm")) && lstrcmpi(lpSuffix, TEXT(".html")))
|
|
continue; //This is not what we look for. So, find next.
|
|
}
|
|
|
|
// Now we know that we found the connected element that we looked for.
|
|
// So, no need to FindNext again. We can get out of the loop after processing
|
|
// it once.
|
|
fNeedToFindNext = FALSE;
|
|
}
|
|
|
|
*ppdtnMiddle = DTAllocNode(pdth, pfd, pdtnParent, *ppdtnMiddle, fConnectedElement);
|
|
|
|
if (!*ppdtnMiddle)
|
|
{
|
|
FindClose(hfind);
|
|
return OPER_ERROR | ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
// make sure that the parent's pointer always points to the head of
|
|
// this linked list
|
|
if (*ppdtn == (*ppdtnMiddle)->pdtnNext)
|
|
*ppdtn = (*ppdtnMiddle);
|
|
|
|
DebugDumpPDTN(*ppdtnMiddle, TEXT("DTPathToDTNode, DTAllocNode"));
|
|
|
|
//We need to check for Connected elements only for the top level items
|
|
if ((!(pcs->fFlags & FOF_NO_CONNECTED_ELEMENTS)) && ppdtnConnectedItems)
|
|
{
|
|
//Make sure this is a top level item
|
|
ASSERT(!pdtnParent);
|
|
|
|
//Create a list of connected items and attach it to the head of the list.
|
|
iError = DTAllocConnectedItemNodes(pdth, pcs, pfd, pszPath, fRecurse, ppdtnConnectedItems);
|
|
|
|
DebugDumpPDTN(*ppdtnConnectedItems, TEXT("DTPathToDTNode, DTAllocConnectedNodes"));
|
|
|
|
// It is possible that the connected files do not exist. That condition is not really
|
|
// an error. So, we check for insufficient memory error condition alone here.
|
|
if (iError == (OPER_ERROR | ERROR_NOT_ENOUGH_MEMORY))
|
|
{
|
|
FindClose(hfind);
|
|
return(iError);
|
|
}
|
|
|
|
//If a connected item exists, then make the origin item point to this connected item.
|
|
if (*ppdtnConnectedItems)
|
|
{
|
|
(*ppdtnMiddle)->pdtnConnected = *ppdtnConnectedItems;
|
|
// Also by default, set the Confirmation result to NO so that the connected element
|
|
// will not be copied/moved etc., in case of a conflict. However, if the origin had
|
|
// a conflict, we would put up a confirmation dlg and the result of that dlg will
|
|
// over-write this value.
|
|
(*ppdtnConnectedItems)->ConnectedInfo.dwConfirmation = IDNO;
|
|
}
|
|
|
|
//Move to the last node in the connected items list.
|
|
while (*ppdtnConnectedItems)
|
|
ppdtnConnectedItems = &((*ppdtnConnectedItems)->pdtnNext);
|
|
}
|
|
else
|
|
{
|
|
// This should have been initialized to zero during allocation, but lets be paranoid
|
|
ASSERT(NULL == (*ppdtnMiddle)->pdtnConnected);
|
|
}
|
|
|
|
// if this is not a directory, move the ppdtnMiddle up one
|
|
if (!ISDIRFINDDATA(*pfd))
|
|
{
|
|
ppdtnMiddle = &(*ppdtnMiddle)->pdtnNext;
|
|
}
|
|
|
|
}
|
|
|
|
} while (fNeedToFindNext && !FOQueryAbort(pcs) && FindNextFile(hfind, pfd));
|
|
|
|
iError = 0; //It is possible that iError contains other errors value now! So, reset it!
|
|
|
|
FindClose(hfind);
|
|
|
|
// now go and recurse into folders (if desired)
|
|
// we don't have to check to see if these pdtn's are dirs, because the
|
|
// way we inserted them above ensures that everything in from of
|
|
// ppdtnMiddle are folders
|
|
|
|
// we're going to tack on a specific child
|
|
// then add the *.* after that
|
|
|
|
while (!FOQueryAbort(pcs) && *ppdtnMiddle)
|
|
{
|
|
BOOL fRecurseThisItem = fRecurse;
|
|
|
|
if ((*ppdtnMiddle)->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
|
|
{
|
|
// Recurse into reparse points unless they asked not to
|
|
if (pcs->fFlags & FOF_NORECURSEREPARSE)
|
|
{
|
|
fRecurseThisItem = FALSE;
|
|
}
|
|
}
|
|
|
|
if (fRecurseThisItem)
|
|
{
|
|
if (PathAppend(pszPath, (*ppdtnMiddle)->szName))
|
|
{
|
|
if (PathAppend(pszPath, c_szStarDotStar))
|
|
{
|
|
|
|
// NULL indicates that we do not want to get the connected elements.
|
|
// This is because we want the connected elements only for the top-level items.
|
|
iError = DTPathToDTNode(pdth, pcs, pszPath, TRUE, DTF_FILES_AND_FOLDERS,
|
|
&((*ppdtnMiddle)->pdtnChild), pfd, *ppdtnMiddle, NULL, fConnectedElement, 0);
|
|
|
|
}
|
|
else
|
|
{
|
|
iError = OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
|
|
PathRemoveFileSpec(pszPath);
|
|
}
|
|
else
|
|
{
|
|
iError = OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if we don't want to recurse, just mark them all as having no children
|
|
(*ppdtnMiddle)->pdtnChild = NULL;
|
|
}
|
|
|
|
if (iError)
|
|
{
|
|
return iError;
|
|
}
|
|
|
|
ppdtnMiddle = &(*ppdtnMiddle)->pdtnNext;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
UINT DTAllocConnectedItemNodes(PDIRTREEHEADER pdth, COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR pszPath, BOOL fRecurse, PDIRTREENODE *ppdtnConnectedItems)
|
|
{
|
|
// Since DTAllocConnectedItemNodes() gets called only for the top-level items in the src list,
|
|
// there is no danger of this function getting called recursively. Hence, I didn't worry about
|
|
// allocating the following on the stack.
|
|
// If "too-much-stack-is-used" problem arises, we can optimize the stack usage by splitting
|
|
// the following function into two such that the most common case (of no connection)
|
|
// doesn't use much stack.
|
|
DWORD dwFileOrFolder;
|
|
TCHAR szFullPath[MAX_PATH];
|
|
TCHAR szFileName[MAX_PATH];
|
|
WIN32_FIND_DATA fd;
|
|
int iPrefixLength; //This is the length of "foo" if the filename is "foo.htm" or "foo files"
|
|
|
|
//Make a copy of the filename; This copy will get munged by ConvertToConnectedItemName().
|
|
lstrcpy(szFileName, pfd->cFileName);
|
|
// Convert the given file/foder name into the connected item's name with wild card characters.
|
|
if (!(iPrefixLength = ConvertToConnectedItemName(szFileName, ARRAYSIZE(szFileName), ISDIRFINDDATA(*pfd))))
|
|
return 0; //No connections exist for the given folder/file.
|
|
|
|
// Now szFileName has the name of connected element with wildcard character.
|
|
|
|
// If the given element is a directory, we want to look for connected FILES only and
|
|
// if the given element is a file, we want to look for connected FOLDERS only.
|
|
dwFileOrFolder = ISDIRFINDDATA(*pfd) ? DTF_FILES_ONLY : DTF_FOLDERS_ONLY;
|
|
|
|
// Form the file/folder name with the complete path!
|
|
lstrcpy(szFullPath, pszPath);
|
|
PathAppend(szFullPath, szFileName);
|
|
|
|
// The file-element has some "connected" items.
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTAllocConnectedItemNodes Looking for %s"), szFullPath);
|
|
|
|
return(DTPathToDTNode(pdth, pcs, szFullPath, fRecurse, dwFileOrFolder, ppdtnConnectedItems, &fd, NULL, NULL, TRUE, iPrefixLength));
|
|
}
|
|
|
|
void DTInitProgressPoints(PDIRTREEHEADER pdth, COPY_STATE *pcs)
|
|
{
|
|
pdth->iFilePoints = 1;
|
|
pdth->iFolderPoints = 1;
|
|
|
|
switch (pcs->lpfo->wFunc)
|
|
{
|
|
case FO_RENAME:
|
|
case FO_DELETE:
|
|
pdth->iSizePoints = 0;
|
|
break;
|
|
|
|
case FO_COPY:
|
|
pdth->iSizePoints = 1;
|
|
break;
|
|
|
|
case FO_MOVE:
|
|
if (PathIsSameRoot(pcs->lpfo->pFrom, pcs->lpfo->pTo))
|
|
{
|
|
pdth->iSizePoints = 0;
|
|
}
|
|
else
|
|
{
|
|
// if it's across volumes, these points increase
|
|
// because we need to nuke the source as well as
|
|
// create the target...
|
|
// whereas we don't need to nuke the "size" of the source
|
|
pdth->iFilePoints = 2;
|
|
pdth->iFolderPoints = 2;
|
|
pdth->iSizePoints = 1;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
UINT DTBuild(COPY_STATE* pcs)
|
|
{
|
|
PDIRTREEHEADER pdth = &pcs->dth;
|
|
WIN32_FIND_DATA fd;
|
|
TCHAR szPath[MAX_PATH];
|
|
PDIRTREENODE *ppdtn;
|
|
PDIRTREENODE *ppdtnConnectedItems;
|
|
int iError = 0;
|
|
|
|
pcs->dth.pFrom = (LPTSTR)pcs->lpfo->pFrom;
|
|
pcs->dth.pTo = (LPTSTR)pcs->lpfo->pTo;
|
|
// A tree of original items will be built under ppdtn.
|
|
ppdtn = &pdth->pdtn;
|
|
// A tree of items "connected" to the orginal items will be built under ppdtnConnectedItems.
|
|
ppdtnConnectedItems = &pdth->pdtnConnectedItems;
|
|
|
|
DTInitProgressPoints(pdth, pcs);
|
|
while (!FOQueryAbort(pcs) && *pdth->pFrom)
|
|
{
|
|
BOOL fRecurse = TRUE;
|
|
|
|
switch (pcs->lpfo->wFunc)
|
|
{
|
|
case FO_MOVE:
|
|
// The move operation doesn't need to recurse if we are moving from and to the same
|
|
// volume. In this case we know that we don't need to display any warnings for
|
|
// things like LFN to 8.3 filename conversion or stream loss. Instead, we can do
|
|
// the operation with one single win32 file operation that just does a rename.
|
|
|
|
// NTRAID89119-2000/02/25-toddb
|
|
// This is only true if we don't cross a mount point! If we cross
|
|
// a mount point then we might have to warn about these things.
|
|
|
|
if ((pcs->fFlags & FOF_NORECURSION) || PathIsSameRoot(pdth->pFrom, pdth->pTo))
|
|
{
|
|
fRecurse = FALSE;
|
|
}
|
|
break;
|
|
|
|
case FO_COPY:
|
|
// For a copy we always recurse unless we're told not to.
|
|
if (pcs->fFlags & FOF_NORECURSION)
|
|
{
|
|
fRecurse = FALSE;
|
|
}
|
|
break;
|
|
|
|
case FO_RENAME:
|
|
// for a rename we never recurse
|
|
fRecurse = FALSE;
|
|
break;
|
|
|
|
case FO_DELETE:
|
|
// for a delete we don't need to recurse IF the recycle bin will be able to handle
|
|
// the given item. If the recycle bin handles the delete then we can undo from
|
|
// the recycle bin if we need to.
|
|
if ((pcs->fFlags & FOF_ALLOWUNDO) && BBWillRecycle(pdth->pFrom, NULL))
|
|
{
|
|
fRecurse = FALSE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
lstrcpy(szPath, pdth->pFrom);
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTBuild: %s"), szPath);
|
|
|
|
// If the file is on removable media, we need to check for media in the drive.
|
|
// Prompt the user to insert the media if it's missing.
|
|
if (!DTDiskCheck(pdth, pcs, szPath))
|
|
{
|
|
iError = ERROR_CANCELLED;
|
|
break;
|
|
}
|
|
|
|
iError = DTPathToDTNode(pdth, pcs, szPath, fRecurse,
|
|
((PathIsWild(pdth->pFrom) && (pcs->lpfo->fFlags & FOF_FILESONLY)) ? DTF_FILES_ONLY : DTF_FILES_AND_FOLDERS),
|
|
ppdtn,&fd, NULL, ppdtnConnectedItems, FALSE, 0);
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTBuild: returned %d"), iError);
|
|
|
|
// FEATURE: If an error occured we should allow the user to skip the file that caused the error. That way
|
|
// if one of the source files doesn't exists the rest will still get copied. Do this only in the multi-
|
|
// source case, blah blah blah. This helps in the case where one of the source files cannot be moved or
|
|
// copied (usually due to Access Denied, could be insuffecent permissions or file is in use, etc).
|
|
|
|
if (iError)
|
|
break;
|
|
|
|
if (!(*ppdtn) && PathIsWild(pdth->pFrom))
|
|
{
|
|
// no files are associated with this path... this
|
|
// can happen when we have wildcards...
|
|
// alloc a dummy node
|
|
*ppdtn = DTAllocNode(pdth, NULL, NULL, NULL, FALSE);
|
|
if (*ppdtn)
|
|
{
|
|
(*ppdtn)->fDummy = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
if (*ppdtn)
|
|
{
|
|
// mark this as the start of a root spec... this is
|
|
// necessary in case we have several wild specs
|
|
(*ppdtn)->fNewRoot = TRUE;
|
|
}
|
|
|
|
if (*ppdtnConnectedItems)
|
|
{
|
|
// Mark this as the start of a root spec.
|
|
(*ppdtnConnectedItems)->fNewRoot = TRUE;
|
|
// For connected items, we need to remember the path.
|
|
(*ppdtnConnectedItems)->ConnectedInfo.pFromConnected = pdth->pFrom;
|
|
(*ppdtnConnectedItems)->ConnectedInfo.pToConnected = pdth->pTo;
|
|
}
|
|
|
|
|
|
while (*ppdtn)
|
|
{
|
|
ppdtn = &(*ppdtn)->pdtnNext;
|
|
}
|
|
|
|
while (*ppdtnConnectedItems)
|
|
{
|
|
ppdtnConnectedItems = &(*ppdtnConnectedItems)->pdtnNext;
|
|
}
|
|
|
|
pdth->pFrom += lstrlen(pdth->pFrom) + 1;
|
|
if (pcs->lpfo->wFunc != FO_DELETE && (pcs->lpfo->fFlags & FOF_MULTIDESTFILES))
|
|
{
|
|
pdth->pTo += lstrlen(pdth->pTo) + 1;
|
|
}
|
|
}
|
|
|
|
//Attach the "ConnectedElements" Tree to the end of the source element tree.
|
|
*ppdtn = pcs->dth.pdtnConnectedItems;
|
|
|
|
pcs->dth.pFrom = (LPTSTR)pcs->lpfo->pFrom;
|
|
pcs->dth.pTo = (LPTSTR)pcs->lpfo->pTo;
|
|
pcs->fDTBuilt = TRUE;
|
|
|
|
// set up the initial time information
|
|
pcs->dwPreviousTime = GetTickCount();
|
|
pcs->dwPointsPerSec = 0;
|
|
pcs->iLastProgressPoints = 0;
|
|
return iError;
|
|
}
|
|
|
|
#define DTNIsRootNode(pdtn) ((pdtn)->pdtnParent == NULL)
|
|
#define DTNIsDirectory(pdtn) (pdtn->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
// This macro determines if the given node is an "Origin" of a connection. i.e. Does this node
|
|
// point to a connected element that needs to be moved/copied etc., along with it?
|
|
// For example, if "foo.htm" is moved, "foo files" is also moved.
|
|
// Here, "foo.htm" is the "Connect origin" (fConnectedElement = FALSE; pdtnConnected is valid)
|
|
// and "foo files" is the "connected element". (fConnectedElement = TRUE;)
|
|
#define DTNIsConnectOrigin(pdtn) ((!pdtn->fConnectedElement) && (pdtn->pdtnConnected != NULL))
|
|
#define DTNIsConnected(pdtn) (pdtn && (pdtn->fConnectedElement))
|
|
|
|
//
|
|
UINT DTEnumChildren(PDIRTREEHEADER pdth, COPY_STATE *pcs, BOOL fRecurse, DWORD dwFileOrFolder)
|
|
{
|
|
int iError = 0;
|
|
if (pdth->pdtnCurrent->pdtnChild == DTN_DELAYED)
|
|
{
|
|
WIN32_FIND_DATA fd;
|
|
|
|
// fill in all the children and update the stats in pdth
|
|
if (PathAppend(pdth->szSrcPath, c_szStarDotStar))
|
|
{
|
|
iError = DTPathToDTNode(pdth, pcs, pdth->szSrcPath, fRecurse, dwFileOrFolder,
|
|
&pdth->pdtnCurrent->pdtnChild, &fd, pdth->pdtnCurrent, NULL, pdth->pdtnCurrent->fConnectedElement, 0);
|
|
}
|
|
else
|
|
{
|
|
iError = OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
|
|
// If we get "File Not Found" Error now and if it is a connected item, then this item
|
|
// must have already been moved/renamed/deleted etc., So, this is not really an error.
|
|
// All this means is that this connected item was also explicitly selected and hence appeared
|
|
// as or "Origin" item earlier in the list and it had already been operated upon.
|
|
// So, reset the error here.
|
|
// (Example: If end-user selects "foo.htm" AND "foo files" folder and moves them, then we
|
|
// will get a file-not-found error when we attempt to move the connected items. To avoid
|
|
// this error dialog, we reset the error here.)
|
|
|
|
if (DTNIsConnected(pdth->pdtnCurrent) && (iError == (OPER_ERROR | ERROR_FILE_NOT_FOUND)))
|
|
iError = 0;
|
|
}
|
|
return iError;
|
|
}
|
|
|
|
//
|
|
// DTNGetConfirmationResult:
|
|
// When a file("foo.htm") is moved/copied, we may put up a confirmation dialog in case
|
|
// of a conflict and the end-user might have responded saying "Yes", "no" etc., When the
|
|
// corresponding connected element ("foo files") is also moved/copied etc., we should NOT put up
|
|
// a confirmation dialog again. We must simply store the answer to the original confirmation and
|
|
// use it later.
|
|
// This function retries the result of the original confirmation from the top-level connected
|
|
// element.
|
|
int DTNGetConfirmationResult(PDIRTREENODE pdtn)
|
|
{
|
|
//Confirmation results are saved only for Connected items; Not for Connection Origins.
|
|
if (!pdtn || !DTNIsConnected(pdtn))
|
|
return 0;
|
|
|
|
//Confirmation results are stored only at the top-level node. So, go there.
|
|
while (pdtn->pdtnParent)
|
|
pdtn = pdtn->pdtnParent;
|
|
|
|
return(pdtn->ConnectedInfo.dwConfirmation);
|
|
}
|
|
|
|
void DTGetWin32FindData(PDIRTREENODE pdtn, WIN32_FIND_DATA* pfd)
|
|
{
|
|
// only the stuff we care about
|
|
lstrcpy(pfd->cAlternateFileName, pdtn->szShortName);
|
|
lstrcpy(pfd->cFileName, pdtn->szName);
|
|
|
|
pfd->dwFileAttributes = pdtn->dwFileAttributes;
|
|
pfd->ftCreationTime = pdtn->ftCreationTime;
|
|
pfd->ftLastWriteTime = pdtn->ftLastWriteTime;
|
|
pfd->nFileSizeLow = pdtn->nFileSizeLow;
|
|
pfd->nFileSizeHigh = pdtn->nFileSizeHigh;
|
|
}
|
|
|
|
void DTSetFileCopyProgress(PDIRTREEHEADER pdth, LARGE_INTEGER liRead)
|
|
{
|
|
LARGE_INTEGER liDelta;
|
|
|
|
liDelta.QuadPart = (liRead.QuadPart - pdth->pdtnCurrent->liFileSizeCopied.QuadPart);
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTSetFileCopyProgress %d %d %d"), liDelta.LowPart, liRead.LowPart, pdth->dtDone.liSize.QuadPart);
|
|
pdth->pdtnCurrent->liFileSizeCopied.QuadPart += liDelta.QuadPart;
|
|
pdth->dtDone.liSize.QuadPart += liDelta.QuadPart;
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("DTSetFileCopyProgress %d %d"), liDelta.LowPart, pdth->dtDone.liSize.LowPart);
|
|
pdth->dtDone.fChanged = TRUE;
|
|
}
|
|
|
|
void DTFreeNode(PDIRTREEHEADER pdth, PDIRTREENODE pdtn)
|
|
{
|
|
if (pdth)
|
|
{
|
|
ASSERT(pdtn->pdtnChild == NULL || pdtn->pdtnChild == DTN_DELAYED);
|
|
|
|
// we're done with this node.. update the header totals
|
|
if (DTNIsDirectory(pdtn))
|
|
{
|
|
pdth->dtDone.dwFolders++;
|
|
}
|
|
else
|
|
{
|
|
LARGE_INTEGER li;
|
|
|
|
li.LowPart = pdtn->nFileSizeLow;
|
|
li.HighPart = pdtn->nFileSizeHigh;
|
|
|
|
pdth->dtDone.dwFiles++;
|
|
pdth->dtDone.liSize.QuadPart += (li.QuadPart - pdtn->liFileSizeCopied.QuadPart);
|
|
}
|
|
|
|
pdth->dtDone.fChanged = TRUE;
|
|
|
|
// repoint parent pointer
|
|
if (!pdtn->pdtnParent)
|
|
{
|
|
|
|
// no parent... must be a root type thing
|
|
ASSERT(pdth->pdtn == pdtn);
|
|
pdth->pdtn = pdtn->pdtnNext;
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
ASSERT(pdtn->pdtnParent->pdtnChild == pdtn);
|
|
if (pdtn->pdtnParent->pdtnChild == pdtn)
|
|
{
|
|
// if my parent was pointing to me, point him to my sib
|
|
pdtn->pdtnParent->pdtnChild = pdtn->pdtnNext;
|
|
}
|
|
}
|
|
}
|
|
|
|
LocalFree(pdtn);
|
|
}
|
|
|
|
// this frees all children of (but NOT including) the current node.
|
|
// it doesn' free the current node because it's assumed that
|
|
// DTGoToNextNode will be called right afterwards, and that will
|
|
// free the current node
|
|
void DTFreeChildrenNodes(PDIRTREEHEADER pdth, PDIRTREENODE pdtn)
|
|
{
|
|
PDIRTREENODE pdtnChild = pdtn->pdtnChild;
|
|
while (pdtnChild && pdtnChild != DTN_DELAYED)
|
|
{
|
|
PDIRTREENODE pdtnNext = pdtnChild->pdtnNext;
|
|
|
|
// recurse and free these children
|
|
if (DTNIsDirectory(pdtnChild))
|
|
{
|
|
DTFreeChildrenNodes(pdth, pdtnChild);
|
|
}
|
|
|
|
DTFreeNode(pdth, pdtnChild);
|
|
pdtnChild = pdtnNext;
|
|
}
|
|
|
|
pdtn->pdtnChild = NULL;
|
|
}
|
|
|
|
void DTForceEnumChildren(PDIRTREEHEADER pdth)
|
|
{
|
|
if (!pdth->pdtnCurrent->pdtnChild)
|
|
pdth->pdtnCurrent->pdtnChild = DTN_DELAYED;
|
|
}
|
|
|
|
void DTAbortCurrentNode(PDIRTREEHEADER pdth)
|
|
{
|
|
DTFreeChildrenNodes((pdth), (pdth)->pdtnCurrent);
|
|
if (pdth->oper == OPER_ENTERDIR)
|
|
pdth->oper = OPER_LEAVEDIR;
|
|
}
|
|
|
|
void DTCleanup(PDIRTREEHEADER pdth)
|
|
{
|
|
PDIRTREENODE pdtn;
|
|
|
|
while (pdth->pdtnCurrent && pdth->pdtnCurrent->pdtnParent)
|
|
{
|
|
// in case we bailed deep in a tree
|
|
pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnParent;
|
|
}
|
|
|
|
while (pdth->pdtnCurrent)
|
|
{
|
|
pdtn = pdth->pdtnCurrent;
|
|
pdth->pdtnCurrent = pdtn->pdtnNext;
|
|
DTFreeChildrenNodes(NULL, pdtn);
|
|
DTFreeNode(NULL, pdtn);
|
|
}
|
|
}
|
|
|
|
BOOL DTInitializePaths(PDIRTREEHEADER pdth, COPY_STATE *pcs)
|
|
{
|
|
ASSERT(pdth->pdtnCurrent); // If we have no current node then how can we Initialize its paths?
|
|
|
|
lstrcpyn(pdth->szSrcPath, pdth->pFrom, ARRAYSIZE(pdth->szSrcPath));
|
|
|
|
// For the "Origins" we need to do this only if a wild card exists. However, for connected elements,
|
|
// we need to do this everytime because connected elements may not exist for every "Origins"
|
|
if (PathIsWild(pdth->pFrom) || (pdth->pdtnCurrent->fNewRoot && DTNIsConnected(pdth->pdtnCurrent)))
|
|
{
|
|
PathRemoveFileSpec(pdth->szSrcPath);
|
|
if (!PathAppend(pdth->szSrcPath, pdth->pdtnCurrent->szName))
|
|
return FALSE;
|
|
}
|
|
|
|
if (!pdth->pTo)
|
|
{
|
|
// no dest, make it the same as the source and we're done
|
|
lstrcpyn(pdth->szDestPath, pdth->szSrcPath, ARRAYSIZE(pdth->szSrcPath));
|
|
return TRUE;
|
|
}
|
|
|
|
if (pdth->pTo)
|
|
{
|
|
lstrcpyn(pdth->szDestPath, pdth->pTo, ARRAYSIZE(pdth->szSrcPath));
|
|
}
|
|
|
|
if (!pdth->fMultiDest)
|
|
{
|
|
if (!PathAppend(pdth->szDestPath, pdth->pdtnCurrent->szName))
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
//When undo of a move operation is done, fMultiDest is set.
|
|
// When fMultiDest is set, we need to strip out the filename given by pTo and
|
|
// append the current filename.
|
|
// For RENAME operations, the source and destination names are different. This is handled
|
|
// seperately below. So, we handle only other operations here where source and dest names are the same.
|
|
if ((pcs->lpfo->wFunc != FO_RENAME) && pdth->pdtnCurrent->fNewRoot && DTNIsConnected(pdth->pdtnCurrent))
|
|
{
|
|
PathRemoveFileSpec(pdth->szDestPath);
|
|
if (!PathAppend(pdth->szDestPath, pdth->pdtnCurrent->szName))
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//We will never try to rename a connected element! Make sure we don't hit this!
|
|
ASSERT(!((pcs->lpfo->wFunc == FO_RENAME) && DTNIsConnected(pdth->pdtnCurrent)));
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
UINT DTValidatePathNames(PDIRTREEHEADER pdth, UINT operation, COPY_STATE * pcs)
|
|
{
|
|
if (pcs->lpfo->wFunc != FO_DELETE)
|
|
{
|
|
// Why process name mappings? Here's why. If we are asked to copy directory "c:\foo" and
|
|
// file "c:\foo\file" to another directory (say "d:\") we might have a name confilct when
|
|
// we copy "c:\foo" so instead we create "d:\Copy Of foo". Later, we walk to the second
|
|
// dirtree node and we are asked to copy "c:\foo\file" to "d:\foo", all of which is valid.
|
|
// HOWEVER, it's not what we want to do. We use _ProccessNameMappings to convert
|
|
// "d:\foo\file" into "d:\Copy of foo\file".
|
|
_ProcessNameMappings(pdth->szDestPath, pdth->hdsaRenamePairs);
|
|
|
|
// REVIEW, do we need to do the name mapping here or just let the
|
|
// VFAT do it? if vfat does it we need to rip out all of the GetNameDialog() stuff.
|
|
|
|
if ((operation != OPER_LEAVEDIR) &&
|
|
!IsLFNDrive(pdth->szDestPath) &&
|
|
PathIsLFNFileSpec(PathFindFileName(pdth->szSrcPath)) &&
|
|
PathIsLFNFileSpec(PathFindFileName(pdth->szDestPath)))
|
|
{
|
|
|
|
int iRet;
|
|
TCHAR szOldDest[MAX_PATH];
|
|
|
|
lstrcpyn(szOldDest, pdth->szDestPath, ARRAYSIZE(szOldDest));
|
|
iRet = GetNameDialog(pcs->hwndDlgParent, pcs,
|
|
(pcs->nSourceFiles != 1) || !DTNIsRootNode(pdth->pdtnCurrent), // if we're entering a dir, multiple spec, or not at root
|
|
operation, pdth->szSrcPath, pdth->szDestPath);
|
|
|
|
switch (iRet)
|
|
{
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
return iRet;
|
|
|
|
default:
|
|
AddRenamePairToHDSA(szOldDest, pdth->szDestPath, &pcs->dth.hdsaRenamePairs);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (operation == OPER_ENTERDIR)
|
|
{
|
|
// Make sure the new directory is not a subdir of the original...
|
|
|
|
int cchFrom = lstrlen(pdth->szSrcPath);
|
|
|
|
// NTRAID89511-2000/02/25-KishoreP
|
|
// Shouldn't we get the short names for both these directories and compair those?
|
|
// Otherwise I can copy "C:\Long Directory Name" to "C:\LongDi~1\foo" without error.
|
|
|
|
if (!(pcs->fFlags & FOF_RENAMEONCOLLISION) &&
|
|
!StrCmpNI(pdth->szSrcPath, pdth->szDestPath, cchFrom))
|
|
{
|
|
TCHAR chNext = pdth->szDestPath[cchFrom]; // Get the next char in the dest.
|
|
|
|
if (!chNext)
|
|
{
|
|
return OPER_ERROR | DE_DESTSAMETREE;
|
|
}
|
|
else if (chNext == TEXT('\\'))
|
|
{
|
|
// The two fully qualified strings are equal up to the end
|
|
// of the source directory ==> the destination is a subdir.
|
|
// Must return an error.
|
|
|
|
// if, stripping the last file name and the backslash give the same length, they are the
|
|
// same file/folder
|
|
if ((PathFindFileName(pdth->szDestPath) - pdth->szDestPath - 1) ==
|
|
lstrlen(pdth->szSrcPath))
|
|
{
|
|
return OPER_ERROR | DE_DESTSAMETREE;
|
|
}
|
|
else
|
|
{
|
|
return OPER_ERROR | DE_DESTSUBTREE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// this moves to the next node (child, sib, parent) and sets up the
|
|
// directory path info and oper state
|
|
UINT DTGoToNextNode(PDIRTREEHEADER pdth, COPY_STATE *pcs)
|
|
{
|
|
UINT oper = OPER_ENTERDIR; // the default
|
|
int iError;
|
|
|
|
if (!pdth->pdtnCurrent)
|
|
{
|
|
pdth->pdtnCurrent = pdth->pdtn;
|
|
|
|
if (pdth->pdtnCurrent)
|
|
{
|
|
if (pdth->pdtnCurrent->fDummy)
|
|
{
|
|
// if this is just a placeholder... go on to the next one
|
|
return DTGoToNextNode(pdth, pcs);
|
|
}
|
|
|
|
if (!DTInitializePaths(pdth, pcs))
|
|
{
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Our tree is completely empty.
|
|
|
|
// REVIEW: What do we do here? If pdtnCurrent is still NULL then our list is completely empty.
|
|
// Is that a bug or what? My hunch is that we should return an error code here, most likely
|
|
// OPER_ERROR | DE_INVALIDFILES. If we do nothing here then we will fail silently.
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
UINT iError;
|
|
BOOL fFreeLastNode = TRUE;
|
|
PDIRTREENODE pdtnLastCurrent = pdth->pdtnCurrent;
|
|
TCHAR szTemp[MAX_PATH];
|
|
|
|
if (iError = DTEnumChildren(pdth, pcs, FALSE, DTF_FILES_AND_FOLDERS))
|
|
return iError;
|
|
|
|
if (pdth->pdtnCurrent->pdtnChild)
|
|
{
|
|
|
|
fFreeLastNode = FALSE;
|
|
pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnChild;
|
|
|
|
// if the source long name is too long, try the short name
|
|
if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szName))
|
|
{
|
|
if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szShortName))
|
|
{
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
StrCpyN(pdth->szSrcPath, szTemp, ARRAYSIZE(pdth->szSrcPath));
|
|
|
|
// if the dest long name is too long, try the short name
|
|
if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szName))
|
|
{
|
|
if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szShortName))
|
|
{
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
StrCpyN(pdth->szDestPath, szTemp, ARRAYSIZE(pdth->szDestPath));
|
|
}
|
|
else if (pdth->oper == OPER_ENTERDIR)
|
|
{
|
|
// if the last operation was an enterdir and it has no children
|
|
// (because it failed the above test
|
|
// then we should do a leave dir on it now
|
|
oper = OPER_LEAVEDIR;
|
|
fFreeLastNode = FALSE;
|
|
|
|
}
|
|
else if (pdth->pdtnCurrent->pdtnNext)
|
|
{
|
|
pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnNext;
|
|
|
|
if (!pdth->pdtnCurrent->pdtnParent)
|
|
{
|
|
// if this was the top, we need to build the next path info
|
|
// from scratch
|
|
|
|
if (pdth->pdtnCurrent->fNewRoot)
|
|
{
|
|
if (pdth->pdtnCurrent->fConnectedElement)
|
|
{
|
|
// Since this is a new root in a Connected list, the pFrom and pTo are
|
|
// stored in the node itself. This is needed because Connected elements may
|
|
// not exist for every item in the source list and we do not want to create dummy
|
|
// nodes for each one of them. So, pFrom and pTo are stored for every NewRoot of
|
|
// connected elements and we use these here.
|
|
pdth->pFrom = pdth->pdtnCurrent->ConnectedInfo.pFromConnected;
|
|
pdth->pTo = pdth->pdtnCurrent->ConnectedInfo.pToConnected;
|
|
}
|
|
else
|
|
{
|
|
// go to the next path pair
|
|
pdth->pFrom += lstrlen(pdth->pFrom) + 1;
|
|
if (pdth->pTo)
|
|
{
|
|
if (pdth->fMultiDest)
|
|
{
|
|
pdth->pTo += lstrlen(pdth->pTo) + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pdth->pdtnCurrent->fDummy)
|
|
{
|
|
// if this is just a placeholder... go on to the next one
|
|
if (fFreeLastNode)
|
|
{
|
|
DTFreeNode(pdth, pdtnLastCurrent);
|
|
}
|
|
return DTGoToNextNode(pdth, pcs);
|
|
}
|
|
|
|
DTInitializePaths(pdth, pcs);
|
|
}
|
|
else
|
|
{
|
|
|
|
PathRemoveFileSpec(pdth->szSrcPath);
|
|
PathRemoveFileSpec(pdth->szDestPath);
|
|
|
|
// if the source long name is too long, try the short name
|
|
if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szName))
|
|
{
|
|
if (!PathCombine(szTemp, pdth->szSrcPath, pdth->pdtnCurrent->szShortName))
|
|
{
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
StrCpyN(pdth->szSrcPath, szTemp, ARRAYSIZE(pdth->szSrcPath));
|
|
|
|
// if the dest long name is too long, try the short name
|
|
if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szName))
|
|
{
|
|
if (!PathCombine(szTemp, pdth->szDestPath, pdth->pdtnCurrent->szShortName))
|
|
{
|
|
return OPER_ERROR | DE_INVALIDFILES;
|
|
}
|
|
}
|
|
StrCpyN(pdth->szDestPath, szTemp, ARRAYSIZE(pdth->szDestPath));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
oper = OPER_LEAVEDIR;
|
|
PathRemoveFileSpec(pdth->szSrcPath);
|
|
PathRemoveFileSpec(pdth->szDestPath);
|
|
pdth->pdtnCurrent = pdth->pdtnCurrent->pdtnParent;
|
|
}
|
|
|
|
if (fFreeLastNode)
|
|
{
|
|
DTFreeNode(pdth, pdtnLastCurrent);
|
|
}
|
|
}
|
|
|
|
if (!pdth->pdtnCurrent)
|
|
{
|
|
// no more! we're done!
|
|
return 0;
|
|
}
|
|
|
|
DebugDumpPDTN(pdth->pdtnCurrent, TEXT("PDTNCurrent"));
|
|
|
|
if (oper == OPER_ENTERDIR)
|
|
{
|
|
if (pcs->lpfo->wFunc == FO_RENAME || !DTNIsDirectory(pdth->pdtnCurrent))
|
|
{
|
|
oper = OPER_DOFILE;
|
|
}
|
|
}
|
|
|
|
if (DTNIsRootNode(pdth->pdtnCurrent))
|
|
{
|
|
// we need to diskcheck the source and target because this might
|
|
// be the first time we've seen this drive
|
|
if (!DTDiskCheck(pdth, pcs, pdth->szSrcPath) ||
|
|
!DTDiskCheck(pdth, pcs, pdth->szDestPath))
|
|
{
|
|
pcs->bAbort = TRUE;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
iError = DTValidatePathNames(pdth, oper, pcs);
|
|
if (iError)
|
|
{
|
|
if (iError & OPER_ERROR)
|
|
{
|
|
//For connected nodes, ignore the error and silently abort the node!
|
|
if (DTNIsConnected(pdth->pdtnCurrent))
|
|
{
|
|
DTAbortCurrentNode(pdth);
|
|
return DTGoToNextNode(pdth, pcs);
|
|
}
|
|
else
|
|
return iError;
|
|
}
|
|
else
|
|
{
|
|
switch (iError)
|
|
{
|
|
case IDNO:
|
|
DTAbortCurrentNode(pdth);
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
return DTGoToNextNode(pdth, pcs);
|
|
|
|
case IDCANCEL:
|
|
// User cancelled the operation
|
|
pcs->bAbort = TRUE;
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
pdth->oper = oper;
|
|
return oper;
|
|
}
|
|
|
|
int CopyMoveRetry(COPY_STATE *pcs, LPCTSTR pszDest, int error, ULARGE_INTEGER* puliFileSize);
|
|
void CopyError(LPCOPY_STATE, LPCTSTR, LPCTSTR, int, UINT, int);
|
|
|
|
void SetProgressTime(COPY_STATE *pcs);
|
|
void SetProgressText(COPY_STATE *pcs, LPCTSTR pszFrom, LPCTSTR pszTo);
|
|
void FOUndo_AddInfo(UNDOATOM *lpua, LPTSTR lpszSrc, LPTSTR lpszDest, DWORD dwAttributes);
|
|
void CALLBACK FOUndo_Release(UNDOATOM *lpua);
|
|
void FOUndo_FileReallyDeleted(LPTSTR lpszFile);
|
|
void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs);
|
|
BOOL_PTR CALLBACK FOFProgressDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
typedef struct {
|
|
LPTSTR lpszName;
|
|
DWORD dwAttributes;
|
|
} FOUNDO_DELETEDFILEINFO, *LPFOUNDO_DELETEDFILEINFO;
|
|
|
|
typedef struct {
|
|
HDPA hdpa;
|
|
HDSA hdsa;
|
|
} FOUNDODATA, *LPFOUNDODATA;
|
|
|
|
|
|
void ReleasePCS(COPY_STATE *pcs)
|
|
{
|
|
if (0 == InterlockedDecrement(&pcs->nRef))
|
|
{
|
|
SimplePidlCache_Release(&pcs->spc);
|
|
LocalFree(pcs);
|
|
}
|
|
}
|
|
|
|
DWORD CALLBACK AddRefPCS(COPY_STATE *pcs)
|
|
{
|
|
return InterlockedIncrement(&pcs->nRef);
|
|
}
|
|
|
|
DWORD CALLBACK FOUIThreadProc(COPY_STATE *pcs)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- Begin"));
|
|
|
|
Sleep(SHOW_PROGRESS_TIMEOUT);
|
|
|
|
if (!pcs->fDone)
|
|
{
|
|
HWND hwndParent;
|
|
FOUITHREADINFO fouiti = {0};
|
|
|
|
ENTERCRITICAL;
|
|
if (!pcs->fDone)
|
|
{
|
|
// need to check again within the critsec to make sure that pcs->lpfo is still valid
|
|
fouiti.pcs = pcs;
|
|
fouiti.wFunc = pcs->lpfo->wFunc;
|
|
fouiti.bIsEmptyRBOp = ((pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_EMPTYINGWASTEBASKET)) ||
|
|
(pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_DELETINGWASTEBASKETFILES)));
|
|
|
|
hwndParent = pcs->lpfo->hwnd;
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (fouiti.pcs)
|
|
{
|
|
HWND hwnd = CreateDialogParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_MOVECOPYPROGRESS),
|
|
hwndParent, FOFProgressDlgProc, (LPARAM)&fouiti);
|
|
if (hwnd)
|
|
{
|
|
MSG msg;
|
|
DWORD dwShowTime;
|
|
int iShowTimeLeft;
|
|
|
|
// crit section to sync with main thread termination
|
|
ENTERCRITICAL;
|
|
if (!pcs->fDone)
|
|
{
|
|
pcs->hwndProgress = hwnd;
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
dwShowTime = GetTickCount();
|
|
while (!pcs->fDone && GetMessage(&msg, NULL, 0, 0))
|
|
{
|
|
if (!pcs->fDone && !IsDialogMessage(pcs->hwndProgress, &msg))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
// if we've put it up, we need to keep it up for at least some minimal amount of time
|
|
iShowTimeLeft = MINSHOWTIME - (GetTickCount() - dwShowTime);
|
|
if (iShowTimeLeft > 0)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- doing an extra sleep"));
|
|
Sleep(iShowTimeLeft);
|
|
}
|
|
|
|
// Keep us from doing this while other thread processing...
|
|
ENTERCRITICAL;
|
|
pcs->hwndProgress = NULL;
|
|
LEAVECRITICAL;
|
|
|
|
DestroyWindow(hwnd);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// main thread must have finished
|
|
ASSERT(pcs->fDone);
|
|
}
|
|
}
|
|
ReleasePCS(pcs);
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("FOUIThreadProc -- End . Completed"));
|
|
return 0;
|
|
}
|
|
|
|
|
|
// this queries the progress dialog for a cancel and yields.
|
|
// it also will show the progress dialog if a certain amount of time has passed
|
|
//
|
|
// returns:
|
|
// TRUE cacnel was pressed, abort the operation
|
|
// FALSE continue
|
|
BOOL FOQueryAbort(COPY_STATE *pcs)
|
|
{
|
|
if (!pcs->bAbort && pcs->hwndProgress)
|
|
{
|
|
if (pcs->hwndProgress != pcs->hwndDlgParent)
|
|
{
|
|
// do this here rather than on the FOUIThreadProc so that we don't have
|
|
// synchronization problems with this thread popping up a dialog on
|
|
// hwndDlgParent then the progress dialog coming up afterwards on top.
|
|
pcs->hwndDlgParent = pcs->hwndProgress;
|
|
ShowWindow(pcs->hwndProgress, SW_SHOW);
|
|
SetForegroundWindow(pcs->hwndProgress);
|
|
SetFocus(GetDlgItem(pcs->hwndProgress, IDCANCEL));
|
|
|
|
SetProgressText(pcs, pcs->dth.szSrcPath,
|
|
pcs->lpfo->wFunc == FO_DELETE ? NULL : pcs->dth.szDestPath);
|
|
}
|
|
else
|
|
{
|
|
MSG msg;
|
|
|
|
// win95 handled messages in here.
|
|
// we need to do the same in order to flush the input queue as well as
|
|
// for backwards compatability.
|
|
|
|
// we need to flush the input queue now because hwndProgress is
|
|
// on a different thread... which means it has attached thread inputs
|
|
// inorder to unlock the attached threads, we need to remove some
|
|
// sort of message until there's none left... any type of message..
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
|
|
{
|
|
if (!IsDialogMessage(pcs->hwndProgress, &msg))
|
|
{
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pcs->dth.dtAll.fChanged || pcs->dth.dtDone.fChanged)
|
|
{
|
|
if (!pcs->dth.fChangePosted)
|
|
{
|
|
// set the flag first because with async threads
|
|
// the progress window could handle it and clear the
|
|
// bit before we set it.. then we'd lose further messages
|
|
// thinking that one was still pending
|
|
pcs->dth.fChangePosted = TRUE;
|
|
if (!PostMessage(pcs->hwndProgress, PDM_UPDATE, 0, 0))
|
|
pcs->dth.fChangePosted = FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return pcs->bAbort;
|
|
}
|
|
|
|
|
|
|
|
|
|
typedef struct _confdlg_data {
|
|
LPCTSTR pFileDest;
|
|
LPCTSTR pFileSource;
|
|
LPCTSTR pStreamNames;
|
|
const WIN32_FIND_DATA *pfdDest;
|
|
const WIN32_FIND_DATA *pfdSource;
|
|
|
|
BOOL bShowCancel; // allow cancel out of this operation
|
|
BOOL bShowDates; // use date/size info in message
|
|
UINT uDeleteWarning; // warn that the delete's not going to the wastebasket
|
|
BOOL bFireIcon;
|
|
BOOL bShrinkDialog; // should we move the buttons up to the text?
|
|
int nSourceFiles; // if != 1 used to build "n files" string
|
|
int idText; // if != 0 use to override string in dlg template
|
|
CONFIRM_FLAG fConfirm; // we will confirm things set here
|
|
CONFIRM_FLAG fYesMask; // these bits are cleared in fConfirm on "yes"
|
|
// Only use fYesMask for things that should be confirmed once per operation
|
|
CONFIRM_FLAG fYesToAllMask; // these bits are cleared in fConfirm on "yes to all"
|
|
//COPY_STATE *pcs;
|
|
CONFIRM_DATA *pcd;
|
|
void (*InitConfirmDlg)(HWND hDlg, struct _confdlg_data *pcd); // routine to initialize dialog
|
|
BOOL bARPWarning;
|
|
} CONFDLG_DATA;
|
|
|
|
|
|
BOOL BuildDateLine(LPTSTR pszDateLine, const WIN32_FIND_DATA *pFind, LPCTSTR pFileName)
|
|
{
|
|
TCHAR szTemplate[64];
|
|
TCHAR szNum[32], szTmp[64];
|
|
WIN32_FIND_DATA fd;
|
|
ULARGE_INTEGER liFileSize;
|
|
|
|
if (!pFind)
|
|
{
|
|
HANDLE hfind = FindFirstFile(pFileName, &fd);
|
|
ASSERT(hfind != INVALID_HANDLE_VALUE);
|
|
FindClose(hfind);
|
|
pFind = &fd;
|
|
}
|
|
|
|
liFileSize.LowPart = pFind->nFileSizeLow;
|
|
liFileSize.HighPart = pFind->nFileSizeHigh;
|
|
|
|
// There are cases where the date is 0, this is especially true when the
|
|
// source is from a file contents...
|
|
if (pFind->ftLastWriteTime.dwLowDateTime || pFind->ftLastWriteTime.dwHighDateTime)
|
|
{
|
|
DWORD dwFlags = FDTF_LONGDATE | FDTF_RELATIVE | FDTF_LONGTIME;
|
|
|
|
SHFormatDateTime(&pFind->ftLastWriteTime, &dwFlags, szTmp, SIZECHARS(szTmp));
|
|
|
|
LoadString(HINST_THISDLL, IDS_DATESIZELINE, szTemplate, ARRAYSIZE(szTemplate));
|
|
wsprintf(pszDateLine, szTemplate, StrFormatByteSize64(liFileSize.QuadPart, szNum, ARRAYSIZE(szNum)),
|
|
szTmp);
|
|
}
|
|
else
|
|
{
|
|
// Simpy output the number to the string
|
|
StrFormatByteSize64(liFileSize.QuadPart, pszDateLine, 64);
|
|
if (liFileSize.QuadPart == 0)
|
|
return FALSE;
|
|
}
|
|
return TRUE; // valid data in the strings
|
|
}
|
|
|
|
|
|
// hide the cancel button and move "Yes" and "No" over to the right positions.
|
|
//
|
|
// "Yes" is IDYES
|
|
// "No" is IDNO
|
|
//
|
|
|
|
#define HideYesToAllAndCancel(hdlg) HideConfirmButtons(hdlg, IDCANCEL)
|
|
#define HideYesToAllAndNo(hdlg) HideConfirmButtons(hdlg, IDNO)
|
|
|
|
void HideConfirmButtons(HWND hdlg, int idHide)
|
|
{
|
|
HWND hwndCancel = GetDlgItem(hdlg, IDCANCEL);
|
|
HWND hwndYesToAll = GetDlgItem(hdlg, IDD_YESTOALL);
|
|
if (hwndCancel)
|
|
{
|
|
RECT rcCancel;
|
|
HWND hwndNo;
|
|
GetWindowRect(hwndCancel, &rcCancel);
|
|
|
|
hwndNo = GetDlgItem(hdlg, IDNO);
|
|
if (hwndNo)
|
|
{
|
|
RECT rcNo;
|
|
HWND hwndYes;
|
|
|
|
GetWindowRect(hwndNo, &rcNo);
|
|
|
|
MapWindowRect(NULL, hdlg, &rcCancel);
|
|
|
|
SetWindowPos(hwndNo, NULL, rcCancel.left, rcCancel.top,
|
|
0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
|
|
|
|
hwndYes = GetDlgItem(hdlg, IDYES);
|
|
if (hwndYes)
|
|
{
|
|
MapWindowRect(NULL, hdlg, &rcNo);
|
|
|
|
SetWindowPos(hwndYes, NULL, rcNo.left, rcNo.top,
|
|
0, 0, SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOSIZE);
|
|
}
|
|
}
|
|
|
|
// Although the function is called "Hide", we actually destroy
|
|
// the windows, because keyboard accelerators for hidden windows
|
|
// are still active!
|
|
if (hwndYesToAll)
|
|
DestroyWindow(hwndYesToAll);
|
|
DestroyWindow(GetDlgItem(hdlg, idHide));
|
|
}
|
|
}
|
|
|
|
int MoveDlgItem(HWND hDlg, UINT id, int y)
|
|
{
|
|
RECT rc;
|
|
HWND hwnd = GetDlgItem(hDlg, id);
|
|
if (hwnd)
|
|
{
|
|
GetWindowRect(hwnd, &rc);
|
|
MapWindowRect(NULL, hDlg, &rc);
|
|
SetWindowPos(hwnd, NULL, rc.left, y, 0,0, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE);
|
|
return rc.top - y; // return how much it moved
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void ShrinkDialog(HWND hDlg, UINT idText)
|
|
{
|
|
RECT rc;
|
|
int y;
|
|
HWND hwnd;
|
|
hwnd = GetDlgItem(hDlg, idText);
|
|
ASSERT(hwnd);
|
|
GetWindowRect(hwnd, &rc);
|
|
MapWindowRect(NULL, hDlg, &rc);
|
|
y = rc.bottom + 12;
|
|
|
|
// move all the buttons
|
|
MoveDlgItem(hDlg, IDNO, y);
|
|
MoveDlgItem(hDlg, IDCANCEL, y);
|
|
MoveDlgItem(hDlg, IDD_YESTOALL, y);
|
|
y = MoveDlgItem(hDlg, IDYES, y);
|
|
|
|
// now resize the entire dialog
|
|
GetWindowRect(hDlg, &rc);
|
|
SetWindowPos(hDlg, NULL, 0, 0, rc.right - rc.left, rc.bottom - y - rc.top, SWP_NOMOVE | SWP_NOZORDER |SWP_NOACTIVATE);
|
|
}
|
|
|
|
void InitConfirmDlg(HWND hDlg, CONFDLG_DATA *pcd)
|
|
{
|
|
TCHAR szMessage[255];
|
|
TCHAR szDeleteWarning[80];
|
|
TCHAR szSrc[32];
|
|
TCHAR szFriendlyName[MAX_PATH];
|
|
SHFILEINFO sfi;
|
|
SHFILEINFO sfiDest;
|
|
LPTSTR pszFileDest = NULL;
|
|
LPTSTR pszMsg, pszSource;
|
|
int i;
|
|
int cxWidth;
|
|
RECT rc;
|
|
HDC hdc;
|
|
HFONT hfont;
|
|
HFONT hfontSave;
|
|
SIZE size;
|
|
|
|
BOOL bIsARPWarning = pcd->bARPWarning;
|
|
|
|
ASSERT((bIsARPWarning && (pcd->nSourceFiles == 1)) || (!bIsARPWarning));
|
|
|
|
hdc = GetDC(hDlg);
|
|
hfont = (HFONT)SendMessage(hDlg, WM_GETFONT, 0, 0);
|
|
hfontSave = (HFONT)SelectObject(hdc, hfont);
|
|
|
|
// get the size of the text boxes
|
|
GetWindowRect(GetDlgItem(hDlg, pcd->idText), &rc);
|
|
cxWidth = rc.right - rc.left;
|
|
|
|
//
|
|
// There are cases where, if the filename has no spaces, the static text
|
|
// control will put the entire file name with our quote character down
|
|
// on the 2nd line. To account for this, we subtract off the width of a
|
|
// the quote character. Since the quote character comes from the resource
|
|
// string, it could really be just about an character, with just about
|
|
// any width. So we assume its about the width of the letter 0, which
|
|
// should be more than wide enough.
|
|
size.cx = 0;
|
|
GetTextExtentPoint(hdc, TEXT("0"), 1, &size);
|
|
cxWidth -= size.cx * 2;
|
|
|
|
if (!bIsARPWarning && !pcd->bShowCancel)
|
|
HideYesToAllAndCancel(hDlg);
|
|
|
|
switch (pcd->nSourceFiles)
|
|
{
|
|
case -1:
|
|
LoadString(HINST_THISDLL, IDS_SELECTEDFILES, szSrc, ARRAYSIZE(szSrc));
|
|
pszSource = szSrc;
|
|
break;
|
|
|
|
case 1:
|
|
if (bIsARPWarning)
|
|
{
|
|
TCHAR szTarget[MAX_PATH];
|
|
DWORD cchFriendlyName = ARRAYSIZE(szFriendlyName);
|
|
HRESULT hres = GetPathFromLinkFile(pcd->pFileSource, szTarget, ARRAYSIZE(szTarget));
|
|
if (S_OK == hres)
|
|
{
|
|
if (SUCCEEDED(AssocQueryString(ASSOCF_VERIFY | ASSOCF_OPEN_BYEXENAME, ASSOCSTR_FRIENDLYAPPNAME,
|
|
szTarget, NULL, szFriendlyName, &cchFriendlyName)))
|
|
{
|
|
pszSource = szFriendlyName;
|
|
}
|
|
else
|
|
{
|
|
pszSource = PathFindFileName(szTarget);
|
|
}
|
|
}
|
|
else if (S_FALSE == hres)
|
|
{
|
|
TCHAR szProductCode[MAX_PATH];
|
|
szProductCode[0] = 0;
|
|
|
|
if ((ERROR_SUCCESS == MsiDecomposeDescriptor(szTarget, szProductCode, NULL, NULL, NULL)) &&
|
|
(ERROR_SUCCESS == MsiGetProductInfo(szProductCode, INSTALLPROPERTY_PRODUCTNAME, szFriendlyName, &cchFriendlyName)))
|
|
{
|
|
pszSource = szFriendlyName;
|
|
}
|
|
else
|
|
goto UNKNOWNAPP;
|
|
|
|
}
|
|
else
|
|
{
|
|
UNKNOWNAPP:
|
|
LoadString(HINST_THISDLL, IDS_UNKNOWNAPPLICATION, szSrc, ARRAYSIZE(szSrc));
|
|
pszSource = szSrc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SHGetFileInfo(pcd->pFileSource,
|
|
(pcd->fConfirm==CONFIRM_DELETE_FOLDER || pcd->fConfirm==CONFIRM_WONT_RECYCLE_FOLDER)? FILE_ATTRIBUTE_DIRECTORY : 0,
|
|
&sfi, sizeof(sfi), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES);
|
|
pszSource = sfi.szDisplayName;
|
|
PathCompactPath(hdc, pszSource, cxWidth);
|
|
}
|
|
break;
|
|
|
|
default:
|
|
pszSource = AddCommas(pcd->nSourceFiles, szSrc, ARRAYSIZE(szSrc));
|
|
break;
|
|
}
|
|
|
|
// if we're supposed to show the date info, grab the icons and format the date string
|
|
if (pcd->bShowDates)
|
|
{
|
|
SHFILEINFO sfi2;
|
|
TCHAR szDateSrc[64], szDateDest[64];
|
|
|
|
BuildDateLine(szDateSrc, pcd->pfdSource, pcd->pFileSource);
|
|
SetDlgItemText(hDlg, IDD_FILEINFO_NEW, szDateSrc);
|
|
|
|
BuildDateLine(szDateDest, pcd->pfdDest, pcd->pFileDest);
|
|
SetDlgItemText(hDlg, IDD_FILEINFO_OLD, szDateDest);
|
|
|
|
SHGetFileInfo(pcd->pFileDest, pcd->pfdDest ? pcd->pfdDest->dwFileAttributes : 0, &sfi2, sizeof(sfi2),
|
|
pcd->pfdDest ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON));
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_OLD, sfi2.hIcon);
|
|
|
|
SHGetFileInfo(pcd->pFileSource, pcd->pfdSource ? pcd->pfdSource->dwFileAttributes : 0, &sfi2, sizeof(sfi2),
|
|
pcd->pfdSource ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON));
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_NEW, sfi2.hIcon);
|
|
}
|
|
|
|
|
|
if (!bIsARPWarning)
|
|
{
|
|
// there are multiple controls:
|
|
// IDD_TEXT contains regular text (normal file/folder)
|
|
// IDD_TEXT1 - IDD_TEXT4 contain optional secondary text
|
|
|
|
for (i = IDD_TEXT; i <= IDD_TEXT4; i++)
|
|
{
|
|
if (i == pcd->idText)
|
|
{
|
|
szMessage[0] = 0;
|
|
GetDlgItemText(hDlg, i, szMessage, ARRAYSIZE(szMessage));
|
|
}
|
|
else
|
|
{
|
|
HWND hwndCtl = GetDlgItem(hDlg, i);
|
|
if (hwndCtl)
|
|
ShowWindow(hwndCtl, SW_HIDE);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GetDlgItemText(hDlg, IDD_ARPWARNINGTEXT, szMessage, ARRAYSIZE(szMessage));
|
|
}
|
|
|
|
// REVIEW Is there some better way? The code above always hides
|
|
// this control, and I don't see a way around this
|
|
|
|
if (pcd->pStreamNames)
|
|
{
|
|
SetDlgItemText(hDlg, IDD_TEXT1, pcd->pStreamNames);
|
|
ShowWindow(GetDlgItem(hDlg, IDD_TEXT1), SW_SHOW);
|
|
}
|
|
|
|
if (pcd->bShrinkDialog)
|
|
ShrinkDialog(hDlg, pcd->idText);
|
|
|
|
if (pcd->pFileDest)
|
|
{
|
|
SHGetFileInfo(pcd->pFileDest, 0,
|
|
&sfiDest, sizeof(sfiDest), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES);
|
|
pszFileDest = sfiDest.szDisplayName;
|
|
PathCompactPath(hdc, pszFileDest, cxWidth);
|
|
}
|
|
|
|
if (pcd->uDeleteWarning)
|
|
{
|
|
LPITEMIDLIST pidl;
|
|
|
|
if (SUCCEEDED(SHGetSpecialFolderLocation(NULL, CSIDL_BITBUCKET, &pidl)))
|
|
{
|
|
SHFILEINFO fi;
|
|
|
|
if (SHGetFileInfo((LPCTSTR)pidl, 0, &fi, sizeof(fi), SHGFI_PIDL | SHGFI_ICON |SHGFI_LARGEICON))
|
|
{
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, fi.hIcon);
|
|
}
|
|
ILFree(pidl);
|
|
}
|
|
LoadString(HINST_THISDLL, pcd->uDeleteWarning, szDeleteWarning, ARRAYSIZE(szDeleteWarning));
|
|
}
|
|
else
|
|
szDeleteWarning[0] = 0;
|
|
|
|
if (pcd->bFireIcon)
|
|
{
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, LoadImage(HINST_THISDLL, MAKEINTRESOURCE(IDI_NUKEFILE), IMAGE_ICON, 0, 0, LR_LOADMAP3DCOLORS));
|
|
}
|
|
|
|
pszMsg = ShellConstructMessageString(HINST_THISDLL, szMessage,
|
|
pszSource, pszFileDest, szDeleteWarning);
|
|
|
|
if (pszMsg)
|
|
{
|
|
SetDlgItemText(hDlg, pcd->idText, pszMsg);
|
|
LocalFree(pszMsg);
|
|
}
|
|
|
|
|
|
SelectObject(hdc, hfontSave);
|
|
ReleaseDC(hDlg, hdc);
|
|
}
|
|
|
|
|
|
BOOL_PTR CALLBACK ConfirmDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
CONFDLG_DATA *pcd = (CONFDLG_DATA *)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
pcd = (CONFDLG_DATA *)lParam;
|
|
pcd->InitConfirmDlg(hDlg, pcd);
|
|
break;
|
|
|
|
case WM_DESTROY:
|
|
// Handle case where the allocation of the PCD failed.
|
|
if (!pcd)
|
|
break;
|
|
|
|
if (pcd->bShowDates)
|
|
{
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_NEW, NULL);
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_OLD, NULL);
|
|
}
|
|
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_WASTEBASKET, NULL);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
if (!pcd)
|
|
break;
|
|
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDNO:
|
|
if (GetKeyState(VK_SHIFT) < 0) // force NOTOALL
|
|
{
|
|
// I use the fYesToAllMask here. There used to be a fNoToAllMask but I
|
|
// removed it. When you select "No To All" what you are saying is that
|
|
// anything I would be saying yes to all for I am actually saying "no to
|
|
// all" for. I feel that it is confusing and unnecessary to have both.
|
|
pcd->pcd->fNoToAll |= pcd->fYesToAllMask;
|
|
}
|
|
EndDialog(hDlg, IDNO);
|
|
break;
|
|
|
|
case IDD_YESTOALL:
|
|
// pcd is the confirmation data for just this file/folder. pcd->pcd is the
|
|
// confirm data for the entire copy operation. When we get a Yes To All we
|
|
// remove the coresponding bits from the entire operation.
|
|
pcd->pcd->fConfirm &= ~pcd->fYesToAllMask;
|
|
EndDialog(hDlg, IDYES);
|
|
break;
|
|
|
|
case IDYES:
|
|
// There are some messages that we only want to tell the use once even if they
|
|
// select Yes instead of Yes To All. As such we sometimes remove bits from the
|
|
// global confirm state even on a simple Yes. This mask is usually zero.
|
|
pcd->pcd->fConfirm &= ~pcd->fYesMask;
|
|
EndDialog(hDlg, IDYES);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hDlg, IDCANCEL);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_NOTIFY:
|
|
switch (((LPNMHDR)lParam)->code)
|
|
{
|
|
case NM_RETURN:
|
|
case NM_CLICK:
|
|
{
|
|
TCHAR szModule[MAX_PATH];
|
|
if (GetSystemDirectory(szModule, ARRAYSIZE(szModule)))
|
|
{
|
|
if (PathAppend(szModule, TEXT("appwiz.cpl")))
|
|
{
|
|
TCHAR szParam[1 + MAX_PATH + 2 + MAX_CCH_CPLNAME]; // See MakeCPLCommandLine function
|
|
TCHAR szAppwiz[64];
|
|
|
|
LoadString(g_hinst, IDS_APPWIZCPL, szAppwiz, SIZECHARS(szAppwiz));
|
|
MakeCPLCommandLine(szModule, szAppwiz, szParam, ARRAYSIZE(szParam));
|
|
SHRunControlPanelEx(szParam, NULL, FALSE);
|
|
}
|
|
}
|
|
EndDialog(hDlg, IDNO);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
void SetConfirmMaskAndText(CONFDLG_DATA *pcd, DWORD dwFileAttributes, LPCTSTR pszFile)
|
|
{
|
|
if (IS_SYSTEM_HIDDEN(dwFileAttributes) && !ShowSuperHidden())
|
|
{
|
|
dwFileAttributes &= ~FILE_ATTRIBUTE_SUPERHIDDEN;
|
|
}
|
|
|
|
// we used to have a desktop.ini "ConfirmFileOp" flag that was set
|
|
// to avoid this case, but there are no folders that are marked READONLY
|
|
// or SYSTEM for a reason other than the shell, so don't consider any as such
|
|
if ((dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)) &&
|
|
(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
dwFileAttributes &= ~(FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY);
|
|
}
|
|
|
|
if (dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
|
|
{
|
|
pcd->fConfirm = CONFIRM_SYSTEM_FILE;
|
|
pcd->fYesToAllMask |= CONFIRM_SYSTEM_FILE;
|
|
pcd->idText = IDD_TEXT2;
|
|
}
|
|
else if (dwFileAttributes & FILE_ATTRIBUTE_READONLY)
|
|
{
|
|
pcd->fConfirm = CONFIRM_READONLY_FILE;
|
|
pcd->fYesToAllMask |= CONFIRM_READONLY_FILE;
|
|
pcd->idText = IDD_TEXT1;
|
|
}
|
|
else if (pszFile && ((dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) &&
|
|
PathIsRegisteredProgram(pszFile))
|
|
{
|
|
pcd->fConfirm = CONFIRM_PROGRAM_FILE;
|
|
pcd->fYesToAllMask |= CONFIRM_PROGRAM_FILE;
|
|
pcd->idText = IDD_TEXT3;
|
|
}
|
|
}
|
|
|
|
|
|
void PauseAnimation(COPY_STATE *pcs, BOOL bStop)
|
|
{
|
|
// only called from within the hwndProgress wndproc so assum it's there
|
|
if (bStop)
|
|
Animate_Stop(GetDlgItem(pcs->hwndProgress, IDD_ANIMATE));
|
|
else
|
|
Animate_Play(GetDlgItem(pcs->hwndProgress, IDD_ANIMATE), -1, -1, -1);
|
|
}
|
|
|
|
// confirm a file operation UI.
|
|
//
|
|
// this routine uses the CONFIRM_DATA in the copy state structure to
|
|
// decide if it needs to put up a dailog to confirm the given file operation.
|
|
//
|
|
// in:
|
|
// pcs current copy state (confirm flags, hwnd)
|
|
// fConfirm only one bit may be set! (operation to confirm)
|
|
// pFileSource source file
|
|
// pFileDest optional destination file
|
|
// pfdSource
|
|
// pfdDest find data describing the destination
|
|
//
|
|
// returns:
|
|
// IDYES
|
|
// IDNO
|
|
// IDCANCEL
|
|
// ERROR_ (DE_) error codes (DE_MEMORY)
|
|
//
|
|
int ConfirmFileOp(HWND hwnd, COPY_STATE *pcs, CONFIRM_DATA *pcd,
|
|
int nSourceFiles, int cDepth, CONFIRM_FLAG fConfirm,
|
|
LPCTSTR pFileSource, const WIN32_FIND_DATA *pfdSource,
|
|
LPCTSTR pFileDest, const WIN32_FIND_DATA *pfdDest,
|
|
LPCTSTR pStreamNames)
|
|
{
|
|
int dlg;
|
|
int ret;
|
|
CONFDLG_DATA cdd;
|
|
CONFIRM_FLAG fConfirmType;
|
|
|
|
if (pcs)
|
|
nSourceFiles = pcs->nSourceFiles;
|
|
|
|
cdd.pfdSource = pfdSource;
|
|
cdd.pfdDest = NULL; // pfdDest is only partially filed in
|
|
cdd.pFileSource = pFileSource;
|
|
cdd.pFileDest = pFileDest;
|
|
cdd.pcd = pcd;
|
|
cdd.fConfirm = fConfirm; // default, changed below
|
|
cdd.fYesMask = 0;
|
|
cdd.fYesToAllMask = 0;
|
|
cdd.nSourceFiles = 1; // default to individual file names in message
|
|
cdd.idText = IDD_TEXT; // default string from the dlg template
|
|
cdd.bShowCancel = ((nSourceFiles != 1) || cDepth);
|
|
cdd.uDeleteWarning = 0;
|
|
cdd.bFireIcon = FALSE;
|
|
cdd.bShowDates = FALSE;
|
|
cdd.bShrinkDialog = FALSE;
|
|
cdd.InitConfirmDlg = InitConfirmDlg;
|
|
cdd.pStreamNames = NULL;
|
|
cdd.bARPWarning = FALSE;
|
|
|
|
fConfirmType = fConfirm & CONFIRM_FLAG_TYPE_MASK;
|
|
|
|
switch (fConfirmType)
|
|
{
|
|
case CONFIRM_DELETE_FILE:
|
|
case CONFIRM_DELETE_FOLDER:
|
|
{
|
|
BOOL bIsFolderShortcut = FALSE;
|
|
|
|
cdd.bShrinkDialog = TRUE;
|
|
// find data for source is in pdfDest
|
|
if ((nSourceFiles != 1) && (pcd->fConfirm & CONFIRM_MULTIPLE))
|
|
{
|
|
// this is the special CONFIRM_MULTIPLE case (usuall SHIFT+DELETE, or
|
|
// SHIFT+DRAG to Recycle Bin). if the user says yes to this, they
|
|
// basically get no more warnings.
|
|
cdd.nSourceFiles = nSourceFiles;
|
|
if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) ||
|
|
(!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) ||
|
|
!BBWillRecycle(cdd.pFileSource, NULL))
|
|
{
|
|
// have the fire icon and the REALLY delete warning
|
|
cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING;
|
|
cdd.bFireIcon = TRUE;
|
|
if (pcs)
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
|
|
if (nSourceFiles == -1)
|
|
{
|
|
// -1 indicates that there were >= MAX_EMPTY_FILES files, so we stoped counting
|
|
// them all up for perf. We use the more generic message in this case.
|
|
cdd.idText = IDD_TEXT3;
|
|
}
|
|
else
|
|
{
|
|
// use the "are you sure you want to nuke XX files?" message
|
|
cdd.idText = IDD_TEXT4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// uDeleteWarning must be set for the proper recycle icon to be loaded.
|
|
cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING;
|
|
}
|
|
|
|
if (!pcs || !pcs->fNoConfirmRecycle)
|
|
{
|
|
POINT ptInvoke;
|
|
HWND hwndPos = NULL;
|
|
|
|
if ((GetNumberOfMonitors() > 1) && GetCursorPos(&ptInvoke))
|
|
{
|
|
HMONITOR hMon = MonitorFromPoint(ptInvoke, MONITOR_DEFAULTTONULL);
|
|
if (hMon)
|
|
{
|
|
hwndPos = _CreateStubWindow(&ptInvoke, hwnd);
|
|
}
|
|
}
|
|
|
|
ret = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_DELETE_MULTIPLE), hwndPos ? hwndPos : hwnd, ConfirmDlgProc, (LPARAM)&cdd);
|
|
|
|
if (hwndPos)
|
|
{
|
|
DestroyWindow(hwndPos);
|
|
}
|
|
|
|
if (ret != IDYES)
|
|
{
|
|
return IDCANCEL;
|
|
}
|
|
}
|
|
|
|
// clear all other possible warnings
|
|
pcd->fConfirm &= ~(CONFIRM_MULTIPLE | CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER);
|
|
cdd.fConfirm &= ~(CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER);
|
|
cdd.nSourceFiles = 1; // use individual file name
|
|
}
|
|
|
|
SetConfirmMaskAndText(&cdd, pfdDest->dwFileAttributes, cdd.pFileSource);
|
|
|
|
if ((pfdDest->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
PathIsShortcut(cdd.pFileSource, pfdDest->dwFileAttributes))
|
|
{
|
|
// Its a folder and its a shortcut... must be a FolderShortcut!
|
|
bIsFolderShortcut = TRUE;
|
|
|
|
// since its a folder, we need to clear out all of these warnings
|
|
cdd.fYesMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE;
|
|
cdd.fYesToAllMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE;
|
|
}
|
|
|
|
// we want to treat FolderShortcuts as "files" instead of folders. We do this so we don't display dialogs
|
|
// that say stuff like "do you want to delete this and all of its contents" when to the user, this looks like
|
|
// an item instead of a folder (eg nethood shortcut).
|
|
if ((fConfirmType == CONFIRM_DELETE_FILE) || bIsFolderShortcut)
|
|
{
|
|
dlg = DLG_DELETE_FILE;
|
|
if ((nSourceFiles == 1) && PathIsShortcutToProgram(cdd.pFileSource))
|
|
{
|
|
dlg = DLG_DELETE_FILE_ARP;
|
|
cdd.idText = IDD_ARPWARNINGTEXT;
|
|
cdd.bShrinkDialog = FALSE;
|
|
cdd.bARPWarning = TRUE;
|
|
}
|
|
|
|
if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) ||
|
|
(!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) ||
|
|
!BBWillRecycle(cdd.pFileSource, NULL))
|
|
{
|
|
// we are really nuking it, so show the appropriate icon/dialog
|
|
cdd.bFireIcon = TRUE;
|
|
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
cdd.uDeleteWarning = IDS_FILEDELETEWARNING;
|
|
|
|
if (cdd.idText == IDD_TEXT)
|
|
{
|
|
cdd.idText = IDD_TEXT4;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we are recycling it
|
|
cdd.uDeleteWarning = IDS_FILERECYCLEWARNING;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
// fConfirmType == CONFIRM_DELETE_FOLDER
|
|
if (pcs)
|
|
{
|
|
// show cancel on NEXT confirm dialog
|
|
pcs->nSourceFiles = -1;
|
|
}
|
|
|
|
cdd.fYesMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE;
|
|
cdd.fYesToAllMask |= CONFIRM_DELETE_FILE | CONFIRM_DELETE_FOLDER | CONFIRM_MULTIPLE;
|
|
|
|
dlg = DLG_DELETE_FOLDER;
|
|
|
|
if ((fConfirm & CONFIRM_WASTEBASKET_PURGE) ||
|
|
(!pcs || !(pcs->fFlags & FOF_ALLOWUNDO)) ||
|
|
!BBWillRecycle(cdd.pFileSource, NULL))
|
|
{
|
|
// we are really nuking it, so show the appropriate icon/dialog
|
|
cdd.bFireIcon = TRUE;
|
|
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
cdd.uDeleteWarning = IDS_FOLDERDELETEWARNING;
|
|
}
|
|
else
|
|
{
|
|
// we are recycling it
|
|
cdd.uDeleteWarning = IDS_FOLDERRECYCLEWARNING;
|
|
}
|
|
}
|
|
|
|
//
|
|
// NTRAID#NTBUG9-100335-2001/01/03-jeffreys
|
|
// See also #128485 in the OSR v 4.1 database
|
|
//
|
|
// The fix for 128485 added the BBWillRecycle check below, but this
|
|
// caused NTBUG9-100335. These 2 bugs say the opposite things.
|
|
// We've had several customer complaints (see dupes of 100335)
|
|
// so I'm putting it back to the way it worked in Windows 2000.
|
|
//
|
|
if (pcs && pcs->fNoConfirmRecycle /*&& BBWillRecycle(cdd.pFileSource, NULL)*/)
|
|
{
|
|
cdd.fConfirm = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case CONFIRM_WONT_RECYCLE_FILE:
|
|
case CONFIRM_WONT_RECYCLE_FOLDER:
|
|
cdd.bShrinkDialog = TRUE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.bFireIcon = TRUE;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.fYesMask = CONFIRM_MULTIPLE;
|
|
cdd.fConfirm = fConfirmType;
|
|
cdd.fYesToAllMask = fConfirmType | CONFIRM_MULTIPLE;
|
|
|
|
// set the dialog to be file or folder
|
|
if (fConfirmType == CONFIRM_WONT_RECYCLE_FOLDER)
|
|
{
|
|
dlg = DLG_WONT_RECYCLE_FOLDER;
|
|
}
|
|
else
|
|
{
|
|
dlg = DLG_WONT_RECYCLE_FILE;
|
|
}
|
|
break;
|
|
|
|
case CONFIRM_PATH_TOO_LONG:
|
|
cdd.bShrinkDialog = TRUE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.bFireIcon = TRUE;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.fYesMask = CONFIRM_MULTIPLE;
|
|
cdd.fConfirm = CONFIRM_PATH_TOO_LONG;
|
|
cdd.fYesToAllMask = CONFIRM_PATH_TOO_LONG | CONFIRM_MULTIPLE;
|
|
dlg = DLG_PATH_TOO_LONG;
|
|
break;
|
|
|
|
case CONFIRM_WONT_RECYCLE_OFFLINE:
|
|
cdd.bShrinkDialog = TRUE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.bFireIcon = TRUE;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.fYesMask = CONFIRM_MULTIPLE;
|
|
cdd.fConfirm = fConfirmType;
|
|
cdd.fYesToAllMask = fConfirmType | CONFIRM_MULTIPLE;
|
|
dlg = DLG_WONT_RECYCLE_OFFLINE;
|
|
break;
|
|
|
|
case CONFIRM_STREAMLOSS:
|
|
cdd.bShrinkDialog = FALSE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.fConfirm = CONFIRM_STREAMLOSS;
|
|
cdd.fYesToAllMask = CONFIRM_STREAMLOSS;
|
|
cdd.pStreamNames = pStreamNames;
|
|
dlg = DLG_STREAMLOSS_ON_COPY;
|
|
break;
|
|
|
|
case CONFIRM_FAILED_ENCRYPT:
|
|
cdd.bShrinkDialog = FALSE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.bShowCancel = TRUE;
|
|
cdd.fConfirm = CONFIRM_FAILED_ENCRYPT;
|
|
cdd.fYesToAllMask = CONFIRM_FAILED_ENCRYPT;
|
|
dlg = DLG_FAILED_ENCRYPT;
|
|
break;
|
|
|
|
case CONFIRM_LOST_ENCRYPT_FILE:
|
|
case CONFIRM_LOST_ENCRYPT_FOLDER:
|
|
cdd.bShrinkDialog = FALSE;
|
|
cdd.nSourceFiles = 1;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.bShowCancel = TRUE;
|
|
cdd.fConfirm = CONFIRM_LOST_ENCRYPT_FILE | CONFIRM_LOST_ENCRYPT_FOLDER;
|
|
cdd.fYesToAllMask = CONFIRM_LOST_ENCRYPT_FILE | CONFIRM_LOST_ENCRYPT_FOLDER;
|
|
if (fConfirmType == CONFIRM_LOST_ENCRYPT_FILE)
|
|
{
|
|
dlg = DLG_LOST_ENCRYPT_FILE;
|
|
}
|
|
else
|
|
{
|
|
dlg = DLG_LOST_ENCRYPT_FOLDER;
|
|
}
|
|
break;
|
|
|
|
case CONFIRM_REPLACE_FILE:
|
|
cdd.bShowDates = TRUE;
|
|
cdd.fYesToAllMask = CONFIRM_REPLACE_FILE;
|
|
SetConfirmMaskAndText(&cdd, pfdDest->dwFileAttributes, NULL);
|
|
dlg = DLG_REPLACE_FILE;
|
|
break;
|
|
|
|
case CONFIRM_REPLACE_FOLDER:
|
|
cdd.bShowCancel = TRUE;
|
|
if (pcs) pcs->nSourceFiles = -1; // show cancel on NEXT confirm dialog
|
|
// this implies operations on the files
|
|
cdd.fYesMask = CONFIRM_REPLACE_FILE;
|
|
cdd.fYesToAllMask = CONFIRM_REPLACE_FILE | CONFIRM_REPLACE_FOLDER;
|
|
dlg = DLG_REPLACE_FOLDER;
|
|
break;
|
|
|
|
case CONFIRM_MOVE_FILE:
|
|
cdd.fYesToAllMask = CONFIRM_MOVE_FILE;
|
|
SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, NULL);
|
|
dlg = DLG_MOVE_FILE;
|
|
break;
|
|
|
|
case CONFIRM_MOVE_FOLDER:
|
|
cdd.bShowCancel = TRUE;
|
|
cdd.fYesToAllMask = CONFIRM_MOVE_FOLDER;
|
|
SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, cdd.pFileSource);
|
|
dlg = DLG_MOVE_FOLDER;
|
|
break;
|
|
|
|
case CONFIRM_RENAME_FILE:
|
|
SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, NULL);
|
|
dlg = DLG_RENAME_FILE;
|
|
break;
|
|
|
|
case CONFIRM_RENAME_FOLDER:
|
|
cdd.bShowCancel = TRUE;
|
|
if (pcs) pcs->nSourceFiles = -1; // show cancel on NEXT confirm dialog
|
|
SetConfirmMaskAndText(&cdd, pfdSource->dwFileAttributes, cdd.pFileSource);
|
|
dlg = DLG_RENAME_FOLDER;
|
|
break;
|
|
|
|
default:
|
|
DebugMsg(DM_WARNING, TEXT("bogus confirm option"));
|
|
return IDCANCEL;
|
|
}
|
|
|
|
// Does this operation need to be confirmed?
|
|
if (pcd->fConfirm & cdd.fConfirm)
|
|
{
|
|
// Has the user already said "No To All" for this operation?
|
|
if ((pcd->fNoToAll & cdd.fConfirm) == cdd.fConfirm)
|
|
{
|
|
ret = IDNO;
|
|
}
|
|
else
|
|
{
|
|
// HACK for multimon, make sure the file operation dialog box comes
|
|
// up on the correct monitor
|
|
POINT ptInvoke;
|
|
HWND hwndPos = NULL;
|
|
|
|
if ((GetNumberOfMonitors() > 1) && GetCursorPos(&ptInvoke))
|
|
{
|
|
HMONITOR hMon = MonitorFromPoint(ptInvoke, MONITOR_DEFAULTTONULL);
|
|
if (hMon)
|
|
{
|
|
hwndPos = _CreateStubWindow(&ptInvoke, hwnd);
|
|
}
|
|
}
|
|
ret = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(dlg), (hwndPos ? hwndPos : hwnd), ConfirmDlgProc, (LPARAM)&cdd);
|
|
|
|
if (hwndPos)
|
|
DestroyWindow(hwndPos);
|
|
|
|
if (ret == -1)
|
|
ret = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ret = IDYES;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
//
|
|
// DTNIsParentConnectOrigin()
|
|
//
|
|
// When a folder ("c:\foo files") is moved to a different drive ("a:\"), the source and the
|
|
// destinations have different roots, and therefore the "fRecursive" flag is turned ON by default.
|
|
// This results in confirmations obtained for the individual files ("c:\foo files\aaa.gif")
|
|
// rather than the folder itself. We need to first find the parent and then save the confirmation
|
|
// in the connected element of it's parent. This function gets the top-most parent and then
|
|
// checks to see if it is a connect origin and if so returns that parent pointer.
|
|
//
|
|
|
|
PDIRTREENODE DTNGetConnectOrigin(PDIRTREENODE pdtn)
|
|
{
|
|
PDIRTREENODE pdtnParent = pdtn;
|
|
|
|
//Get the top-level parent of the given node.
|
|
while (pdtn)
|
|
{
|
|
pdtnParent = pdtn;
|
|
pdtn = pdtn->pdtnParent;
|
|
}
|
|
|
|
//Now check if the parent is a connect origin.
|
|
if (pdtnParent && DTNIsConnectOrigin(pdtnParent))
|
|
return pdtnParent; //If so, return him.
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
//
|
|
// CachedConfirmFileOp()
|
|
//
|
|
// When a file("foo.htm") is moved/copied, we may put up a confirmation dialog in case
|
|
// of a conflict and the end-user might have responded saying "Yes", "no" etc., When the
|
|
// corresponding connected element ("foo files") is also moved/copied etc., we should NOT put up
|
|
// a confirmation dialog again. We must simply store the answer to the original confirmation and
|
|
// use it later.
|
|
//
|
|
// What this function does is: if the given node is a connected element, it simply retrieves the
|
|
// confirmation for the original operation and returns. If the given element is NOT a connected
|
|
// element, then this function calls the ConfirmFileOp and stores the confirmation result in
|
|
// it's connected element sothat, it later it can be used by the connected element.
|
|
//
|
|
|
|
int CachedConfirmFileOp(HWND hwnd, COPY_STATE *pcs, CONFIRM_DATA *pcd,
|
|
int nSourceFiles, int cDepth, CONFIRM_FLAG fConfirm,
|
|
LPCTSTR pFileSource, const WIN32_FIND_DATA *pfdSource,
|
|
LPCTSTR pFileDest, const WIN32_FIND_DATA *pfdDest,
|
|
LPCTSTR pStreamNames)
|
|
|
|
{
|
|
int result;
|
|
|
|
//See if this is a connected item.
|
|
if (DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
{
|
|
// Since this is a connected item, the confirmation must already have been obtained from
|
|
// the user and get it from the cache!
|
|
result = DTNGetConfirmationResult(pcs->dth.pdtnCurrent);
|
|
}
|
|
else
|
|
{
|
|
PDIRTREENODE pdtnConnectOrigin;
|
|
|
|
result = ConfirmFileOp(hwnd, pcs, pcd, nSourceFiles, cDepth, fConfirm, pFileSource,
|
|
pfdSource, pFileDest, pfdDest, pStreamNames);
|
|
|
|
//Check if this node has a connection.
|
|
if (pdtnConnectOrigin = DTNGetConnectOrigin(pcs->dth.pdtnCurrent))
|
|
{
|
|
pdtnConnectOrigin->pdtnConnected->ConnectedInfo.dwConfirmation = result;
|
|
|
|
// PERF: Can we check for the result to be IDCANCEL or IDNO and if so make the
|
|
// connected node a Dummy? Currently this won't work because current code assumes
|
|
// that dummy nodes do not have children. This connected node might have some children.
|
|
// if ((result == IDCANCEL) || (result == IDNO))
|
|
// pdtnConnectOrigin->pdtnConnected->fDummy = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
void GuessAShortName(LPCTSTR p, LPTSTR szT)
|
|
{
|
|
int i, j, fDot, cMax;
|
|
|
|
for (i = j = fDot = 0, cMax = 8; *p; p++)
|
|
{
|
|
if (*p == TEXT('.'))
|
|
{
|
|
// if there was a previous dot, step back to it
|
|
// this way, we get the last extension
|
|
if (fDot)
|
|
i -= j+1;
|
|
|
|
// set number of chars to 0, put the dot in
|
|
j = 0;
|
|
szT[i++] = TEXT('.');
|
|
|
|
// remember we saw a dot and set max 3 chars.
|
|
fDot = TRUE;
|
|
cMax = 3;
|
|
}
|
|
else if (j < cMax && (PathGetCharType(*p) & GCT_SHORTCHAR))
|
|
{
|
|
// if *p is a lead byte, we move forward one more
|
|
if (IsDBCSLeadByte(*p))
|
|
{
|
|
szT[i] = *p++;
|
|
if (++j >= cMax)
|
|
continue;
|
|
++i;
|
|
}
|
|
j++;
|
|
szT[i++] = *p;
|
|
}
|
|
}
|
|
szT[i] = 0;
|
|
}
|
|
|
|
/* GetNameDialog
|
|
*
|
|
* Runs the dialog box to prompt the user for a new filename when copying
|
|
* or moving from HPFS to FAT.
|
|
*/
|
|
|
|
typedef struct {
|
|
LPTSTR pszDialogFrom;
|
|
LPTSTR pszDialogTo;
|
|
BOOL bShowCancel;
|
|
} GETNAME_DATA;
|
|
|
|
BOOL_PTR CALLBACK GetNameDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
TCHAR szT[14];
|
|
TCHAR szTo[MAX_PATH];
|
|
GETNAME_DATA * pgn = (GETNAME_DATA *)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
|
|
switch (wMsg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
|
|
pgn = (GETNAME_DATA *)lParam;
|
|
|
|
// inform the user of the old name
|
|
PathSetDlgItemPath(hDlg, IDD_FROM, pgn->pszDialogFrom);
|
|
|
|
// directory the file will go into
|
|
PathRemoveFileSpec(pgn->pszDialogTo);
|
|
PathSetDlgItemPath(hDlg, IDD_DIR, pgn->pszDialogTo);
|
|
|
|
// generate a guess for the new name
|
|
GuessAShortName(PathFindFileName(pgn->pszDialogFrom), szT);
|
|
|
|
lstrcpy(szTo, pgn->pszDialogTo);
|
|
PathAppend(szTo, szT);
|
|
// make sure that name is unique
|
|
PathYetAnotherMakeUniqueName(szTo, szTo, NULL, NULL);
|
|
SetDlgItemText(hDlg, IDD_TO, PathFindFileName(szTo));
|
|
SendDlgItemMessage(hDlg, IDD_TO, EM_LIMITTEXT, 13, 0L);
|
|
|
|
SHAutoComplete(GetDlgItem(hDlg, IDD_TO), 0);
|
|
|
|
if (!pgn->bShowCancel)
|
|
HideYesToAllAndNo(hDlg);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDD_YESTOALL:
|
|
case IDYES:
|
|
GetDlgItemText(hDlg, IDD_TO, szT, ARRAYSIZE(szT));
|
|
PathAppend(pgn->pszDialogTo, szT);
|
|
PathQualify(pgn->pszDialogTo);
|
|
// fall through
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
EndDialog(hDlg,GET_WM_COMMAND_ID(wParam, lParam));
|
|
break;
|
|
|
|
case IDD_TO:
|
|
{
|
|
LPCTSTR p;
|
|
GetDlgItemText(hDlg, IDD_TO, szT, ARRAYSIZE(szT));
|
|
for (p = szT; *p; p = CharNext(p))
|
|
{
|
|
if (!(PathGetCharType(*p) & GCT_SHORTCHAR))
|
|
break;
|
|
}
|
|
|
|
EnableWindow(GetDlgItem(hDlg,IDYES), ((!*p) && (p != szT)));
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
int GetNameDialog(HWND hwnd, COPY_STATE *pcs, BOOL fMultiple,UINT wOp, LPTSTR pFrom, LPTSTR pTo)
|
|
{
|
|
int iRet;
|
|
|
|
// if we don't want to confirm this, just mock up a string and return ok
|
|
if (!(pcs->cd.fConfirm & CONFIRM_LFNTOFAT))
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
GuessAShortName(PathFindFileName(pFrom), szTemp);
|
|
PathRemoveFileSpec(pTo);
|
|
PathAppend(pTo, szTemp);
|
|
// make sure that name is unique
|
|
PathYetAnotherMakeUniqueName(pTo, pTo, NULL, NULL);
|
|
iRet = IDYES;
|
|
}
|
|
else
|
|
{
|
|
GETNAME_DATA gn;
|
|
gn.pszDialogFrom = pFrom;
|
|
gn.pszDialogTo = pTo;
|
|
gn.bShowCancel = fMultiple;
|
|
|
|
iRet = (int)DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_LFNTOFAT), hwnd, GetNameDlgProc, (LPARAM)(GETNAME_DATA *)&gn);
|
|
if (iRet == IDD_YESTOALL)
|
|
pcs->cd.fConfirm &= ~CONFIRM_LFNTOFAT;
|
|
}
|
|
return iRet;
|
|
}
|
|
|
|
STDAPI_(void) SHFreeNameMappings(void *hNameMappings)
|
|
{
|
|
HDSA hdsaRenamePairs = (HDSA)hNameMappings;
|
|
int i;
|
|
|
|
if (!hdsaRenamePairs)
|
|
return;
|
|
|
|
i = DSA_GetItemCount(hdsaRenamePairs) - 1;
|
|
for (; i >= 0; i--)
|
|
{
|
|
SHNAMEMAPPING FAR* prp = DSA_GetItemPtr(hdsaRenamePairs, i);
|
|
|
|
LocalFree(prp->pszOldPath);
|
|
LocalFree(prp->pszNewPath);
|
|
}
|
|
|
|
DSA_Destroy(hdsaRenamePairs);
|
|
}
|
|
|
|
void _ProcessNameMappings(LPTSTR pszTarget, HDSA hdsaRenamePairs)
|
|
{
|
|
int i;
|
|
|
|
if (!hdsaRenamePairs)
|
|
return;
|
|
|
|
for (i = DSA_GetItemCount(hdsaRenamePairs) - 1; i >= 0; i--)
|
|
{
|
|
TCHAR cTemp;
|
|
SHNAMEMAPPING FAR* prp = DSA_GetItemPtr(hdsaRenamePairs, i);
|
|
|
|
// I don't call StrCmpNI 'cause I already know cchOldPath, and
|
|
// it has to do a couple of lstrlen()s to calculate it.
|
|
cTemp = pszTarget[prp->cchOldPath];
|
|
pszTarget[prp->cchOldPath] = 0;
|
|
|
|
// Does the target match this collision renaming entry?
|
|
// NOTE: We are trying to compare a path to a path. prp->pszOldPath
|
|
// does not have a trailing "\" character, so this isn't covered
|
|
// by the lstrcmpi below. As such, cTemp had best be the path
|
|
// seperator character to ensure that the modified pszTarget is actually
|
|
// a path and not a filename or a longer path name that doesn't match
|
|
// but happens to start with the same characters as prp->pszOldPath.
|
|
if ((cTemp == TEXT('\\')) && !lstrcmpi(pszTarget, prp->pszOldPath))
|
|
{
|
|
// Get subtree string of the target.
|
|
TCHAR *pszSubTree = &(pszTarget[prp->cchOldPath + 1]);
|
|
|
|
// Generate the new target path.
|
|
PathCombine(pszTarget, prp->pszNewPath, pszSubTree);
|
|
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
// Restore the trounced character.
|
|
pszTarget[prp->cchOldPath] = cTemp;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Sets the status dialog item in the modeless status dialog box. */
|
|
|
|
// used for both the drag drop status dialogs and the manual user
|
|
// entry dialogs so be careful what you change
|
|
|
|
void SetProgressText(COPY_STATE *pcs, LPCTSTR pszFrom, LPCTSTR pszTo)
|
|
{
|
|
HWND hwndProgress = pcs->hwndProgress;
|
|
|
|
if (hwndProgress && !(pcs->fFlags & FOF_SIMPLEPROGRESS))
|
|
{
|
|
TCHAR szFrom[MAX_PATH], szTo[MAX_PATH];
|
|
LPTSTR pszMsg = NULL;
|
|
|
|
HDC hdc;
|
|
HFONT hfont;
|
|
HFONT hfontSave;
|
|
RECT rc;
|
|
int cxWidth;
|
|
SIZE size;
|
|
|
|
//
|
|
// Compute the size we can use for our file names (REVIEW: Cache this result?)
|
|
//
|
|
hdc = GetDC(hwndProgress);
|
|
hfont = (HFONT)SendMessage(hwndProgress, WM_GETFONT, 0, 0);
|
|
hfontSave = (HFONT)SelectObject(hdc, hfont);
|
|
|
|
GetWindowRect(GetDlgItem(hwndProgress, IDD_TONAME), &rc);
|
|
cxWidth = rc.right - rc.left;
|
|
|
|
if (NULL != pszTo && pcs->fFlags & FOF_MULTIDESTFILES)
|
|
{
|
|
lstrcpy(szFrom, pszTo);
|
|
}
|
|
else
|
|
{
|
|
lstrcpy(szFrom, pszFrom);
|
|
}
|
|
PathStripPath(szFrom);
|
|
PathCompactPath(hdc, szFrom, cxWidth);
|
|
SetDlgItemText(hwndProgress, IDD_NAME, szFrom);
|
|
|
|
lstrcpy(szFrom, pszFrom);
|
|
if (szFrom[0])
|
|
{
|
|
LPTSTR pszResource = MAKEINTRESOURCE(IDS_FROM);
|
|
LPTSTR pszToUsable = NULL;
|
|
|
|
szTo[0] = TEXT('\0');
|
|
if (pszTo)
|
|
{
|
|
pszToUsable = szTo;
|
|
pszResource = MAKEINTRESOURCE(IDS_FROMTO);
|
|
}
|
|
|
|
pszMsg = ShellConstructMessageString(HINST_THISDLL,
|
|
pszResource, "", pszToUsable);
|
|
|
|
if (NULL != pszMsg)
|
|
{
|
|
GetTextExtentPoint(hdc, pszMsg, lstrlen(pszMsg), &size);
|
|
cxWidth -= size.cx;
|
|
LocalFree(pszMsg);
|
|
}
|
|
|
|
//
|
|
// Now build the file names
|
|
//
|
|
PathRemoveFileSpec(szFrom);
|
|
PathStripPath(szFrom);
|
|
|
|
if (pszTo)
|
|
{
|
|
lstrcpy(szTo, pszTo);
|
|
PathRemoveFileSpec(szTo);
|
|
PathStripPath(szTo);
|
|
|
|
PathCompactPath(hdc, szFrom, cxWidth/2);
|
|
PathCompactPath(hdc, szTo, cxWidth/2);
|
|
}
|
|
else
|
|
{
|
|
PathCompactPath(hdc, szFrom, cxWidth);
|
|
}
|
|
|
|
//
|
|
// Now create the real message
|
|
//
|
|
pszMsg = ShellConstructMessageString(HINST_THISDLL,
|
|
pszResource, szFrom, pszToUsable);
|
|
|
|
}
|
|
else if (!pcs->fDTBuilt)
|
|
{
|
|
TCHAR szFunc[80];
|
|
if (LoadString(HINST_THISDLL, FOFuncToStringID(pcs->lpfo->wFunc),
|
|
szFunc, ARRAYSIZE(szFunc)))
|
|
{
|
|
pszMsg = ShellConstructMessageString(HINST_THISDLL,
|
|
MAKEINTRESOURCE(IDS_PREPARINGTO), szFunc);
|
|
}
|
|
}
|
|
|
|
if (pszMsg)
|
|
{
|
|
SetDlgItemText(hwndProgress, IDD_TONAME, pszMsg);
|
|
LocalFree(pszMsg);
|
|
}
|
|
|
|
SelectObject(hdc, hfontSave);
|
|
ReleaseDC(hwndProgress, hdc);
|
|
|
|
}
|
|
}
|
|
|
|
void SetProgressTimeEst(COPY_STATE *pcs, DWORD dwTimeLeft)
|
|
{
|
|
TCHAR szFmt[60];
|
|
TCHAR szOut[70];
|
|
DWORD dwTime;
|
|
|
|
if (pcs->hwndProgress)
|
|
{
|
|
if (dwTimeLeft > 4*60*60) // 4 hours and over you get no text
|
|
{
|
|
szFmt[0] = TEXT('\0');
|
|
}
|
|
else if (dwTimeLeft > 60)
|
|
{
|
|
// Note that dwTime is at least 2, so we only need a plural form
|
|
LoadString(HINST_THISDLL, IDS_TIMEEST_MINUTES, szFmt, ARRAYSIZE(szFmt));
|
|
dwTime = (dwTimeLeft / 60) + 1;
|
|
}
|
|
else
|
|
{
|
|
LoadString(HINST_THISDLL, IDS_TIMEEST_SECONDS, szFmt, ARRAYSIZE(szFmt));
|
|
// Round up to 5 seconds so it doesn't look so random
|
|
dwTime = ((dwTimeLeft+4) / 5) * 5;
|
|
}
|
|
|
|
wsprintf(szOut, szFmt, dwTime);
|
|
|
|
SetDlgItemText(pcs->hwndProgress, IDD_TIMEEST, szOut);
|
|
}
|
|
}
|
|
|
|
|
|
// this updates the animation, which could change because we could switch between
|
|
// doing a move to recycle bin and really nuke if the file/folder was bigger that
|
|
// the allowable size of the recycle bin.
|
|
void UpdateProgressAnimation(COPY_STATE *pcs)
|
|
{
|
|
if (pcs->hwndProgress && pcs->lpfo)
|
|
{
|
|
INT_PTR idAni, idAniCurrent;
|
|
HWND hwndAnimation;
|
|
switch (pcs->lpfo->wFunc)
|
|
{
|
|
case FO_DELETE:
|
|
if ((pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_EMPTYINGWASTEBASKET)) ||
|
|
(pcs->lpfo->lpszProgressTitle == MAKEINTRESOURCE(IDS_BB_DELETINGWASTEBASKETFILES)))
|
|
{
|
|
idAni = IDA_FILENUKE;
|
|
break;
|
|
}
|
|
else if (!(pcs->fFlags & FOF_ALLOWUNDO))
|
|
{
|
|
idAni = IDA_FILEDELREAL;
|
|
break;
|
|
} // else fall through to default
|
|
|
|
default:
|
|
idAni = (IDA_FILEMOVE + (int)pcs->lpfo->wFunc - FO_MOVE);
|
|
}
|
|
|
|
hwndAnimation = GetDlgItem(pcs->hwndProgress,IDD_ANIMATE);
|
|
|
|
idAniCurrent = (INT_PTR) GetProp(hwndAnimation, TEXT("AnimationID"));
|
|
|
|
if (idAni != idAniCurrent)
|
|
{
|
|
// the one we should be using is different from the one we have,
|
|
// so update it
|
|
|
|
// close the old clip
|
|
Animate_Close(hwndAnimation);
|
|
|
|
// open the new one
|
|
Animate_Open(hwndAnimation, idAni);
|
|
|
|
// if the window is enabled, start the new animation playing
|
|
if (IsWindowEnabled(pcs->hwndProgress))
|
|
Animate_Play(hwndAnimation, -1, -1, -1);
|
|
|
|
// set the current idAni
|
|
SetProp(hwndAnimation, TEXT("AnimationID"), (HANDLE)idAni);
|
|
|
|
// at the same time we update the animation, we also update the text,
|
|
// so that the two will always be in sync
|
|
SetProgressText(pcs, pcs->dth.szSrcPath, pcs->lpfo->wFunc == FO_DELETE ? NULL : pcs->dth.szDestPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void SendProgressMessage(COPY_STATE *pcs, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (pcs->hwndProgress)
|
|
SendDlgItemMessage(pcs->hwndProgress, IDD_PROBAR, uMsg, wParam, lParam);
|
|
}
|
|
|
|
|
|
//
|
|
// creates folder and all parts of the path if necessary (parent does not need
|
|
// to exists) and verifies that the contents of the folder will be visibile.
|
|
//
|
|
// in:
|
|
// hwnd hwnd to post UI on
|
|
// pszPath full path to create
|
|
// psa security attributes
|
|
//
|
|
// returns:
|
|
// ERROR_SUCCESS (0) success
|
|
// ERROR_ failure
|
|
//
|
|
|
|
STDAPI_(int) SHCreateDirectoryEx(HWND hwnd, LPCTSTR pszPath, SECURITY_ATTRIBUTES *psa)
|
|
{
|
|
int ret = ERROR_SUCCESS;
|
|
|
|
if (PathIsRelative(pszPath))
|
|
{
|
|
// if not a "full" path bail
|
|
// to ensure that we dont create a dir in the current working directory
|
|
SetLastError(ERROR_BAD_PATHNAME);
|
|
return ERROR_BAD_PATHNAME;
|
|
}
|
|
|
|
if (!Win32CreateDirectory(pszPath, psa))
|
|
{
|
|
TCHAR *pEnd, *pSlash, szTemp[MAX_PATH];
|
|
|
|
ret = GetLastError();
|
|
|
|
// There are certain error codes that we should bail out here
|
|
// before going through and walking up the tree...
|
|
switch (ret)
|
|
{
|
|
case ERROR_FILENAME_EXCED_RANGE:
|
|
case ERROR_FILE_EXISTS:
|
|
case ERROR_ALREADY_EXISTS:
|
|
return ret;
|
|
}
|
|
|
|
lstrcpyn(szTemp, pszPath, ARRAYSIZE(szTemp));
|
|
pEnd = PathAddBackslash(szTemp); // for the loop below
|
|
|
|
// assume we have 'X:\' to start this should even work
|
|
// on UNC names because will will ignore the first error
|
|
|
|
pSlash = szTemp + 3;
|
|
|
|
// create each part of the dir in order
|
|
|
|
while (*pSlash)
|
|
{
|
|
while (*pSlash && *pSlash != TEXT('\\'))
|
|
pSlash = CharNext(pSlash);
|
|
|
|
if (*pSlash)
|
|
{
|
|
ASSERT(*pSlash == TEXT('\\'));
|
|
|
|
*pSlash = 0; // terminate path at seperator
|
|
|
|
ret = Win32CreateDirectory(szTemp, pSlash + 1 == pEnd ? psa : NULL) ? ERROR_SUCCESS : GetLastError();
|
|
|
|
}
|
|
*pSlash++ = TEXT('\\'); // put the seperator back
|
|
}
|
|
}
|
|
|
|
if (ERROR_SUCCESS != ret)
|
|
{
|
|
// We failed, so let's try to display error UI.
|
|
if (hwnd && ERROR_CANCELLED != ret)
|
|
{
|
|
SHSysErrorMessageBox(hwnd, NULL, IDS_CANNOTCREATEFOLDER, ret,
|
|
pszPath ? PathFindFileName(pszPath) : NULL,
|
|
MB_OK | MB_ICONEXCLAMATION);
|
|
|
|
ret = ERROR_CANCELLED; // Indicate we already displayed Error UI.
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
STDAPI_(int) SHCreateDirectory(HWND hwnd, LPCTSTR pszPath)
|
|
{
|
|
return SHCreateDirectoryEx(hwnd, pszPath, NULL);
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
STDAPI_(int) SHCreateDirectoryExA(HWND hwnd, LPCSTR pszPath, SECURITY_ATTRIBUTES *psa)
|
|
{
|
|
WCHAR wsz[MAX_PATH];
|
|
SHAnsiToUnicode(pszPath, wsz, SIZECHARS(wsz));
|
|
return SHCreateDirectoryEx(hwnd, wsz, psa);
|
|
}
|
|
#else
|
|
STDAPI_(int) SHCreateDirectoryExW(HWND hwnd, LPCWSTR pszPath, SECURITY_ATTRIBUTES *psa)
|
|
{
|
|
char sz[MAX_PATH];
|
|
SHUnicodeToAnsi(pszPath, sz, SIZECHARS(sz));
|
|
return SHCreateDirectoryEx(hwnd, sz, psa);
|
|
}
|
|
#endif
|
|
|
|
|
|
// call MPR to find out the speed of a given path
|
|
//
|
|
// returns
|
|
// 0 for unknown
|
|
// 144 for 14.4 modems
|
|
// 96 for 9600
|
|
// 24 for 2400
|
|
//
|
|
// if the device does not return a speed we return 0
|
|
//
|
|
|
|
DWORD GetPathSpeed(LPCTSTR pszPath)
|
|
{
|
|
NETCONNECTINFOSTRUCT nci;
|
|
NETRESOURCE nr;
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
lstrcpyn(szPath, pszPath, ARRAYSIZE(szPath));
|
|
PathStripToRoot(szPath); // get a root to this path
|
|
|
|
memset(&nci, 0, sizeof(nci));
|
|
nci.cbStructure = sizeof(nci);
|
|
|
|
memset(&nr, 0, sizeof(nr));
|
|
if (PathIsUNC(szPath))
|
|
nr.lpRemoteName = szPath;
|
|
else
|
|
{
|
|
// Don't bother for local drives
|
|
if (!IsRemoteDrive(DRIVEID(szPath)))
|
|
return 0;
|
|
|
|
// we are passing in a local drive and MPR does not like us to pass a
|
|
// local name as Z:\ but only wants Z:
|
|
szPath[2] = 0; // Strip off after character and :
|
|
nr.lpLocalName = szPath;
|
|
}
|
|
|
|
// dwSpeed is returned by MultinetGetConnectionPerformance
|
|
MultinetGetConnectionPerformance(&nr, &nci);
|
|
|
|
return nci.dwSpeed;
|
|
}
|
|
|
|
|
|
DWORD CopyCallbackProc(LARGE_INTEGER liTotSize, LARGE_INTEGER liBytes,
|
|
LARGE_INTEGER liStreamSize, LARGE_INTEGER liStreamBytes,
|
|
DWORD dwStream, DWORD dwCallback,
|
|
HANDLE hSource, HANDLE hDest, void *pv)
|
|
{
|
|
COPY_STATE *pcs = (COPY_STATE *)pv;
|
|
|
|
DebugMsg(DM_TRACE, TEXT("CopyCallbackProc[%08lX], totsize=%08lX, bytes=%08lX"),
|
|
dwCallback, liTotSize.LowPart, liBytes.LowPart);
|
|
|
|
if (FOQueryAbort(pcs))
|
|
return PROGRESS_CANCEL;
|
|
|
|
DTSetFileCopyProgress(&pcs->dth, liBytes);
|
|
|
|
if (pcs->fInitialize)
|
|
{
|
|
// preserve the create date when moving across volumes, otherwise use the
|
|
// create date the file system picked when we did the CreateFile()
|
|
// always preserve modified date (ftLastWriteTime)
|
|
// bummer is we loose accuracy when going to VFAT compared to NT servers
|
|
|
|
SetFileTime((HANDLE)hDest, (pcs->lpfo->wFunc == FO_MOVE) ? &pcs->pfd->ftCreationTime : NULL,
|
|
NULL, &pcs->pfd->ftLastWriteTime);
|
|
|
|
pcs->fInitialize = FALSE;
|
|
}
|
|
|
|
switch (dwCallback)
|
|
{
|
|
case CALLBACK_STREAM_SWITCH:
|
|
break;
|
|
case CALLBACK_CHUNK_FINISHED:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return PROGRESS_CONTINUE;
|
|
}
|
|
|
|
// copy the SECURITY_DESCRIPTOR for two files
|
|
//
|
|
// in:
|
|
// pszSource fully qualified source path
|
|
// pszDest fully qualified destination path
|
|
//
|
|
// returns:
|
|
// 0 ERROR_SUCCESS
|
|
// WIN32 error codes
|
|
//
|
|
|
|
DWORD
|
|
CopyFileSecurity(LPCTSTR pszSource, LPCTSTR pszDest)
|
|
{
|
|
DWORD err = ERROR_SUCCESS;
|
|
BOOL fRet = TRUE;
|
|
BYTE buf[512];
|
|
|
|
// arbitrarily saying do everything we can
|
|
// except SACL_SECURITY_INFORMATION because
|
|
SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
|
|
PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) buf;
|
|
DWORD cbPsd = sizeof(buf);
|
|
|
|
if (!SHRestricted(REST_FORCECOPYACLWITHFILE))
|
|
{
|
|
// shell restriction so return access denied?
|
|
return ERROR_ACCESS_DENIED;
|
|
}
|
|
|
|
fRet = GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd);
|
|
if (!fRet)
|
|
{
|
|
err = GetLastError();
|
|
if (ERROR_INSUFFICIENT_BUFFER == err)
|
|
{
|
|
// just need to resize the buffer and try again
|
|
|
|
psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, cbPsd);
|
|
if (psd)
|
|
{
|
|
fRet = GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd);
|
|
}
|
|
else
|
|
{
|
|
err = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fRet)
|
|
{
|
|
fRet = SetFileSecurity(pszDest, si, psd);
|
|
if (!fRet)
|
|
err = GetLastError();
|
|
}
|
|
|
|
if (psd && psd != buf)
|
|
LocalFree(psd);
|
|
|
|
if (fRet)
|
|
return ERROR_SUCCESS;
|
|
|
|
return err;
|
|
}
|
|
|
|
// reset the SECURITY_DESCRIPTOR on a file or directory
|
|
//
|
|
// in:
|
|
// pszDest fully qualified destination path
|
|
//
|
|
// returns:
|
|
// 0 ERROR_SUCCESS
|
|
// WIN32 error codes
|
|
//
|
|
|
|
DWORD
|
|
ResetFileSecurity(LPCTSTR pszDest)
|
|
{
|
|
DWORD err = ERROR_SUCCESS;
|
|
|
|
if (!SHRestricted(REST_FORCECOPYACLWITHFILE))
|
|
{
|
|
ACL acl;
|
|
InitializeAcl(&acl, sizeof(acl), ACL_REVISION);
|
|
|
|
// TreeResetNamedSecurityInfo has a callback mechanism, but
|
|
// we currently don't use it. Note that the paths passed to
|
|
// the callback look like
|
|
// "\Device\HarddiskVolume1\dir\name"
|
|
|
|
err = TreeResetNamedSecurityInfo((LPTSTR)pszDest,
|
|
SE_FILE_OBJECT,
|
|
DACL_SECURITY_INFORMATION | UNPROTECTED_DACL_SECURITY_INFORMATION,
|
|
NULL,
|
|
NULL,
|
|
&acl,
|
|
NULL,
|
|
FALSE, // KeepExplicit (perms on children)
|
|
NULL,
|
|
ProgressInvokeNever,
|
|
NULL);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
//
|
|
// in:
|
|
// hwnd Window to report things to.
|
|
// pszSource fully qualified source path
|
|
// pszDest fully qualified destination path
|
|
// pfd source file find data (size/date/time/attribs)
|
|
//
|
|
// returns:
|
|
// ERROR_SUCCESS (0)
|
|
// other Win32 ERROR_ codes
|
|
//
|
|
|
|
UINT FileCopy(COPY_STATE *pcs, LPCTSTR pszSource, LPCTSTR pszDest, const WIN32_FIND_DATA *pfd, BOOL fCreateAlways)
|
|
{
|
|
UINT iRet = ERROR_CANCELLED;
|
|
BOOL fRetryPath = FALSE;
|
|
BOOL fRetryAttr = FALSE;
|
|
BOOL fCopyOrMoveSucceeded = FALSE;
|
|
BOOL fSecurityObtained = FALSE;
|
|
DWORD dwCopyFlags;
|
|
|
|
// Buffers for security info
|
|
|
|
BYTE rgbSecurityDescriptor[512];
|
|
SECURITY_INFORMATION si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
|
|
PSECURITY_DESCRIPTOR psd = (PSECURITY_DESCRIPTOR) rgbSecurityDescriptor;
|
|
DWORD cbPsd = sizeof(rgbSecurityDescriptor);
|
|
|
|
// Make sure we can start
|
|
if (FOQueryAbort(pcs))
|
|
return ERROR_CANCELLED;
|
|
|
|
//
|
|
// Now do the file copy/move
|
|
//
|
|
|
|
// Get the security info from the source file. If there is a problem
|
|
// (e.g. the file is on FAT) we ignore it and proceed with the copy/move.
|
|
|
|
if (!(pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS))
|
|
{
|
|
if (SHRestricted(REST_FORCECOPYACLWITHFILE))
|
|
{
|
|
if (GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd))
|
|
{
|
|
fSecurityObtained = TRUE;
|
|
}
|
|
else
|
|
{
|
|
if (ERROR_INSUFFICIENT_BUFFER == GetLastError())
|
|
{
|
|
psd = (PSECURITY_DESCRIPTOR) LocalAlloc(LPTR, cbPsd);
|
|
if (psd)
|
|
{
|
|
if (GetFileSecurity(pszSource, si, psd, cbPsd, &cbPsd))
|
|
{
|
|
fSecurityObtained = TRUE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TryCopyAgain:
|
|
|
|
pcs->fInitialize = TRUE;
|
|
pcs->pfd = pfd;
|
|
SetProgressText(pcs, pszSource, pszDest);
|
|
|
|
dwCopyFlags = 0;
|
|
if (pcs->fLostEncryptOk)
|
|
{
|
|
dwCopyFlags |= COPY_FILE_ALLOW_DECRYPTED_DESTINATION;
|
|
}
|
|
|
|
if (FO_MOVE == pcs->lpfo->wFunc)
|
|
{
|
|
fCopyOrMoveSucceeded = MoveFileWithProgress(pszSource, pszDest, CopyCallbackProc, pcs, MOVEFILE_COPY_ALLOWED | (fCreateAlways ? MOVEFILE_REPLACE_EXISTING : 0));
|
|
}
|
|
else
|
|
{
|
|
if (!fCreateAlways)
|
|
{
|
|
dwCopyFlags |= COPY_FILE_FAIL_IF_EXISTS;
|
|
}
|
|
fCopyOrMoveSucceeded = CopyFileEx(pszSource, pszDest, CopyCallbackProc, pcs, &pcs->bAbort, dwCopyFlags);
|
|
}
|
|
|
|
if (!fCopyOrMoveSucceeded)
|
|
{
|
|
int iLastError = (int)GetLastError();
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("FileCopy() failed, get last error returned 0x%08x"), iLastError);
|
|
|
|
switch (iLastError)
|
|
{
|
|
// Let the caller handle this one
|
|
case ERROR_FILE_EXISTS:
|
|
case ERROR_ALREADY_EXISTS: // nt5 221893 CopyFileEx now returns this for some reason...
|
|
iRet = ERROR_FILE_EXISTS;
|
|
goto Exit;
|
|
|
|
case ERROR_DISK_FULL:
|
|
if (PathIsUNC(pszDest) || !IsRemovableDrive(DRIVEID(pszDest)) || PathIsSameRoot(pszDest,pszSource))
|
|
{
|
|
break;
|
|
}
|
|
|
|
iLastError = ERROR_DISK_FULL;
|
|
// Fall through
|
|
|
|
case ERROR_PATH_NOT_FOUND:
|
|
if (!fRetryPath)
|
|
{
|
|
// ask the user to stick in another disk or empty wastebasket
|
|
ULARGE_INTEGER ulFileSize;
|
|
ulFileSize.LowPart = pfd->nFileSizeLow;
|
|
ulFileSize.HighPart = pfd->nFileSizeHigh;
|
|
iLastError = CopyMoveRetry(pcs, pszDest, iLastError, &ulFileSize);
|
|
if (!iLastError)
|
|
{
|
|
fRetryPath = TRUE;
|
|
goto TryCopyAgain;
|
|
}
|
|
CopyError(pcs, pszSource, pszDest, (UINT)iLastError | ERRORONDEST, FO_COPY, OPER_DOFILE);
|
|
iRet = ERROR_CANCELLED;
|
|
goto Exit;
|
|
}
|
|
break;
|
|
|
|
case ERROR_ENCRYPTION_FAILED:
|
|
if (pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED && FALSE == pcs->fLostEncryptOk)
|
|
{
|
|
int result;
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs,
|
|
&pcs->cd, pcs->nSourceFiles,
|
|
FALSE,
|
|
CONFIRM_LOST_ENCRYPT_FILE,
|
|
pszSource, pfd, pszDest, NULL, NULL);
|
|
|
|
switch (result)
|
|
{
|
|
case IDYES:
|
|
pcs->fLostEncryptOk = TRUE;
|
|
goto TryCopyAgain;
|
|
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
iRet = result;
|
|
break;
|
|
|
|
default:
|
|
iRet = result;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ERROR_ACCESS_DENIED:
|
|
// check if the filename is too long
|
|
if (lstrlen(PathFindFileName(pszSource)) + lstrlen(pszDest) >= MAX_PATH)
|
|
{
|
|
iLastError = DE_FILENAMETOOLONG;
|
|
}
|
|
else if (!fRetryAttr)
|
|
{
|
|
// If the file is readonly, reset the readonly attribute
|
|
// and have another go at it
|
|
DWORD dwAttributes = GetFileAttributes(pszDest);
|
|
if (0xFFFFFFFF != dwAttributes)
|
|
{
|
|
dwAttributes &= ~(FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM);
|
|
if (SetFileAttributes(pszDest, dwAttributes))
|
|
{
|
|
fRetryAttr = TRUE;
|
|
goto TryCopyAgain;
|
|
}
|
|
}
|
|
|
|
// GetFileAttributes() 10 lines above clobers GetLastError() and CopyError()
|
|
// needs it.
|
|
SetLastError(iLastError);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!pcs->bAbort)
|
|
{
|
|
CopyError(pcs, pszSource, pszDest, iLastError, FO_COPY, OPER_DOFILE);
|
|
}
|
|
|
|
iRet = ERROR_CANCELLED; // error already reported
|
|
goto Exit;
|
|
}
|
|
|
|
// If copying from a CDRom - clear the read-only bit
|
|
if (pcs->fFromCDRom)
|
|
{
|
|
SetFileAttributes(pszDest, pfd->dwFileAttributes & ~FILE_ATTRIBUTE_READONLY);
|
|
}
|
|
|
|
// Set the source's security on the destination, ignoring any error.
|
|
if (fSecurityObtained)
|
|
{
|
|
SetFileSecurity(pszDest, si, psd);
|
|
}
|
|
|
|
|
|
SHChangeNotify(SHCNE_CREATE, SHCNF_PATH, pszDest, NULL);
|
|
|
|
if (FO_MOVE == pcs->lpfo->wFunc)
|
|
{
|
|
// Let windows waiting on notifications of Source know of change. We have to check
|
|
// to see if the file is actually gone in order to tell if it actually moved or not.
|
|
|
|
if (!PathFileExists(pszSource))
|
|
SHChangeNotify(SHCNE_DELETE, SHCNF_PATH, pszSource, NULL);
|
|
}
|
|
else if (0 == StrCmpIC(pfd->cFileName, TEXT("desktop.ini")))
|
|
{
|
|
// clean out stuff from the desktop.ini
|
|
WritePrivateProfileSection(TEXT("DeleteOnCopy"), NULL, pszDest);
|
|
}
|
|
|
|
iRet = ERROR_SUCCESS; // 0
|
|
|
|
Exit:
|
|
|
|
// If we had to alloc a buffer for the security descriptor,
|
|
// free it now.
|
|
|
|
if (psd && (rgbSecurityDescriptor != psd))
|
|
LocalFree(psd);
|
|
|
|
return iRet;
|
|
}
|
|
|
|
// note: this is a very slow call
|
|
DWORD GetFreeClusters(LPCTSTR szPath)
|
|
{
|
|
DWORD dwFreeClus;
|
|
DWORD dwTemp;
|
|
|
|
if (GetDiskFreeSpace(szPath, &dwTemp, &dwTemp, &dwFreeClus, &dwTemp))
|
|
return dwFreeClus;
|
|
else
|
|
return (DWORD)-1;
|
|
}
|
|
|
|
// note: this is a very slow call
|
|
BOOL TotalCapacity(LPCTSTR szPath, ULARGE_INTEGER *puliDiskSize)
|
|
{
|
|
int idDrive = PathGetDriveNumber(szPath);
|
|
if (idDrive != -1)
|
|
{
|
|
TCHAR szDrive[5];
|
|
ULARGE_INTEGER ullDiskFreeForUser;
|
|
|
|
PathBuildRoot(szDrive, idDrive);
|
|
|
|
return GetDiskFreeSpaceEx(szDrive, &ullDiskFreeForUser, puliDiskSize, NULL);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
typedef struct
|
|
{
|
|
LPTSTR pszTitle;
|
|
LPTSTR pszText;
|
|
} DISKERRORPARAM;
|
|
|
|
BOOL_PTR CALLBACK DiskErrDlgProc(HWND hDlg, UINT uMessage, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMessage)
|
|
{
|
|
case WM_INITDIALOG:
|
|
{
|
|
DISKERRORPARAM *pDiskError = (DISKERRORPARAM *) lParam;
|
|
if (pDiskError)
|
|
{
|
|
SetWindowText(hDlg, pDiskError->pszTitle);
|
|
SetDlgItemText(hDlg, IDC_DISKERR_EXPLAIN, pDiskError->pszText);
|
|
}
|
|
Static_SetIcon(GetDlgItem(hDlg, IDC_DISKERR_STOPICON),
|
|
LoadIcon(NULL, IDI_HAND));
|
|
}
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
case IDCANCEL:
|
|
case IDC_DISKERR_LAUNCHCLEANUP:
|
|
EndDialog (hDlg, LOWORD(wParam));
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void DisplayFileOperationError(HWND hParent, int idVerb, int wFunc, int nError, LPCTSTR pszReason, LPCTSTR pszPath, LPCTSTR pszDest)
|
|
{
|
|
TCHAR szBuffer[80];
|
|
DISKERRORPARAM diskparams;
|
|
|
|
// Grab title from resource
|
|
if (LoadString(HINST_THISDLL, IDS_FILEERROR + wFunc, szBuffer, ARRAYSIZE(szBuffer)))
|
|
{
|
|
diskparams.pszTitle = szBuffer;
|
|
}
|
|
else
|
|
{
|
|
diskparams.pszTitle = NULL;
|
|
}
|
|
|
|
// Build Message to display
|
|
diskparams.pszText = ShellConstructMessageString(HINST_THISDLL,
|
|
MAKEINTRESOURCE(idVerb), pszReason, PathFindFileName(pszPath));
|
|
|
|
if (diskparams.pszText)
|
|
{
|
|
int idDrive = DriveIDFromBBPath(pszDest);
|
|
//if we want to show Disk cleanup do our stuff, otherwise do MessageBox
|
|
if (nError == ERROR_DISK_FULL &&
|
|
IsBitBucketableDrive(idDrive) &&
|
|
!PathIsUNC(pszDest) &&
|
|
GetDiskCleanupPath(NULL, 0))
|
|
{
|
|
if (DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_DISKERR), hParent,
|
|
DiskErrDlgProc, (LPARAM)&diskparams) == IDC_DISKERR_LAUNCHCLEANUP)
|
|
{
|
|
LaunchDiskCleanup(hParent, idDrive, DISKCLEANUP_NOFLAG);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
MessageBox(hParent, diskparams.pszText, diskparams.pszTitle,
|
|
MB_OK | MB_ICONSTOP | MB_SETFOREGROUND);
|
|
}
|
|
LocalFree(diskparams.pszText);
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************\
|
|
DESCRIPTION:
|
|
We received an SHARINGVIOLATION or ACCESSDENIED error. We want
|
|
to generate the most accruate error message for the user to inform
|
|
them better. These are the cases we care about:
|
|
|
|
ERROR_ACCESS_DENIED: This is the legacy case with the message:
|
|
"Access is denied. The source file may be in use."
|
|
DE_DEST_IS_CDROM: This is displayed in case the user copies a file to
|
|
their cd-rom drive.
|
|
DE_DEST_IS_CDRECORD: user deletes from CD recordable drive, we need an error
|
|
message that isn't so scary about "cant copy files to CD".
|
|
DE_DEST_IS_DVD: This is displayed in case the user copies a file to
|
|
their DVD drive
|
|
DE_SHARING_VIOLATION: The file can't be copied because it's open by someone
|
|
who doesn't allow others to read the file while they
|
|
use it.
|
|
DE_PERMISSIONDENIED: This should be displayed if the user doesn't have
|
|
the ACLs (security permissions) to read/copy the file.
|
|
\***********************************************************************/
|
|
int GenAccessDeniedError(LPCTSTR pszSource, LPCTSTR pszDest, int nError)
|
|
{
|
|
int nErrorMsg = ERROR_ACCESS_DENIED;
|
|
int iDrive = PathGetDriveNumber(pszDest);
|
|
|
|
if (iDrive != -1)
|
|
{
|
|
if (IsCDRomDrive(iDrive))
|
|
{
|
|
WCHAR szDrive[4];
|
|
// check if user is deleting from cd-r drive. error message saying "cant copy or move files to cd drive"
|
|
// doesn't apply. since we're about to put up ui its not like we have to be super fast here, call into cdburning code.
|
|
if (SUCCEEDED(CDBurn_GetRecorderDriveLetter(szDrive, ARRAYSIZE(szDrive))) &&
|
|
(DRIVEID(szDrive) == iDrive))
|
|
{
|
|
nErrorMsg = DE_DEST_IS_CDRECORD;
|
|
}
|
|
else
|
|
{
|
|
nErrorMsg = DE_DEST_IS_CDROM;
|
|
}
|
|
}
|
|
|
|
if (DriveIsDVD(iDrive))
|
|
nErrorMsg = DE_DEST_IS_DVD;
|
|
}
|
|
|
|
// TODO: DE_SHARING_VIOLATION, DE_PERMISSIONDENIED
|
|
return nErrorMsg;
|
|
}
|
|
|
|
|
|
//
|
|
// The following function reports errors for the copy engine
|
|
//
|
|
// Parameters
|
|
// pszSource source file name
|
|
// pszDest destination file name
|
|
// nError dos (or our exteneded) error code
|
|
// 0xFFFF for special case NET error
|
|
// wFunc FO_* values
|
|
// nOper OPER_* values, operation being performed
|
|
//
|
|
|
|
void CopyError(LPCOPY_STATE pcs, LPCTSTR pszSource, LPCTSTR pszDest, int nError, UINT wFunc, int nOper)
|
|
{
|
|
TCHAR szReason[200];
|
|
TCHAR szFile[MAX_PATH];
|
|
int idVerb;
|
|
BOOL bDest;
|
|
BOOL fSysError = FALSE;
|
|
DWORD dwError = GetLastError(); // get Extended error now before we blow it away.
|
|
|
|
if (!pcs || (pcs->fFlags & FOF_NOERRORUI))
|
|
return; // caller doesn't want to report errors
|
|
|
|
bDest = nError & ERRORONDEST; // was dest file cause of error
|
|
nError &= ~ERRORONDEST; // clear the dest bit
|
|
|
|
// We also may need to remap some new error codes into old error codes
|
|
//
|
|
if (nError == ERROR_BAD_PATHNAME)
|
|
nError = DE_INVALIDFILES;
|
|
|
|
if (nError == ERROR_CANCELLED) // user abort
|
|
return;
|
|
|
|
lstrcpyn(szFile, bDest ? pszDest : pszSource, ARRAYSIZE(szFile));
|
|
if (!szFile[0])
|
|
{
|
|
LoadString(HINST_THISDLL, IDS_FILE, szFile, ARRAYSIZE(szFile));
|
|
}
|
|
else
|
|
{
|
|
// make the path fits on the screen
|
|
RECT rcMonitor;
|
|
HWND hwnd = pcs->hwndProgress ? pcs->hwndProgress : pcs->hwndDlgParent;
|
|
GetMonitorRect(MonitorFromWindow(hwnd, TRUE), &rcMonitor);
|
|
|
|
PathCompactPath(NULL, szFile, (rcMonitor.right - rcMonitor.left) / 3);
|
|
}
|
|
|
|
// get the verb string
|
|
// since we now recycle folders as well as files, added OPER_ENTERDIR check here
|
|
if ((nOper == OPER_DOFILE) || (nOper == OPER_ENTERDIR) || (nOper == 0))
|
|
{
|
|
if ((nError != -1) && bDest)
|
|
{
|
|
idVerb = IDS_REPLACING;
|
|
}
|
|
else
|
|
{
|
|
idVerb = IDS_VERBS + wFunc;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
idVerb = IDS_ACTIONS + (nOper >> 8);
|
|
}
|
|
|
|
// get the reason string
|
|
if (nError == 0xFFFF)
|
|
{
|
|
DWORD dw;
|
|
WNetGetLastError(&dw, szReason, ARRAYSIZE(szReason), NULL, 0);
|
|
}
|
|
else
|
|
{
|
|
// transform some error cases
|
|
|
|
if (bDest)
|
|
{
|
|
// This caseing of error codes is error prone.. it would
|
|
// be better to find the explicit ones we wish to map to
|
|
// this one instead of trying to guess all the ones
|
|
// we don't want to map...
|
|
if ((nError == ERROR_DISK_FULL) ||
|
|
((nError != ERROR_ACCESS_DENIED) &&
|
|
(nError != ERROR_NETWORK_ACCESS_DENIED) &&
|
|
(nError != ERROR_WRITE_PROTECT) &&
|
|
(nError != ERROR_BAD_NET_NAME) &&
|
|
(GetFreeClusters(pszDest) == 0L)))
|
|
{
|
|
nError = ERROR_DISK_FULL;
|
|
}
|
|
else if (dwError == ERROR_WRITE_FAULT)
|
|
{
|
|
nError = ERROR_WRITE_FAULT;
|
|
}
|
|
else if (dwError == ERROR_INVALID_NAME)
|
|
{
|
|
nError = ERROR_INVALID_NAME;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (nError == ERROR_ACCESS_DENIED)
|
|
{
|
|
// Check the extended error for more info about the error...
|
|
// We just map these errors to something generic that
|
|
// tells the user something weird is going on.
|
|
switch (dwError)
|
|
{
|
|
case ERROR_CRC:
|
|
case ERROR_SEEK:
|
|
case ERROR_SECTOR_NOT_FOUND:
|
|
case ERROR_READ_FAULT:
|
|
case ERROR_GEN_FAILURE:
|
|
nError = ERROR_GEN_FAILURE;
|
|
break;
|
|
|
|
|
|
// We can't test for ERROR_FILE_NOT_FOUND because in the case where we copy to
|
|
// a write-protected dest we check to see if the reason we got access denied was
|
|
// because there's already a read-only file there. If there isn't _that_ test is
|
|
// going to SetLastError() to ERROR_FILE_NOT_FOUND and that's what we're going to
|
|
// report as an error. [davepl]
|
|
//
|
|
// case ERROR_FILE_NOT_FOUND:
|
|
// nError = ERROR_GEN_FAILURE;
|
|
// break;
|
|
|
|
case ERROR_SHARING_VIOLATION:
|
|
case ERROR_ACCESS_DENIED:
|
|
nError = GenAccessDeniedError(pszSource, pszDest, nError);
|
|
break;
|
|
default:
|
|
TraceMsg(TF_WARNING, "CopyEngine: hit error %x , not currently special cased", dwError);
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This error occures when a user drags & drops a file from point a to
|
|
// point b twice. The second time fails because the first time hasn't finished.
|
|
if (nError == (OPER_ERROR | ERROR_FILE_NOT_FOUND))
|
|
{
|
|
nError = ERROR_GEN_FAILURE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// the error munging above is in several places, but there are some errors that we
|
|
// know for SURE the user will never want to see so zap them to generic failures.
|
|
// this whole thing needs a redesign... we shouldnt depend generally on errors getting
|
|
// UI ("There is not enough space on the disk.") because then we get crap like this.
|
|
// but everybody already knows that.
|
|
switch (nError)
|
|
{
|
|
case ERROR_SWAPERROR: // Error performing inpage operation.
|
|
nError = ERROR_GEN_FAILURE;
|
|
break;
|
|
}
|
|
|
|
if (nError <= DE_ERROR_MAX)
|
|
{
|
|
BOOL fOverridden = FALSE;
|
|
|
|
if (nError == ERROR_SHARING_VIOLATION)
|
|
{
|
|
// in the sharing violation case we can try to be a little better in the error UI by
|
|
// going through the running object table and seeing if the file is registered in there.
|
|
// if it's not in there, no biggie, just use our normal handling.
|
|
PWSTR pszApp;
|
|
if (SUCCEEDED(FindAppForFileInUse(bDest ? pszDest : pszSource, &pszApp)))
|
|
{
|
|
PWSTR pszMessage = ShellConstructMessageString(HINST_THISDLL, MAKEINTRESOURCE(IDS_SHAREVIOLATION_HINT), pszApp);
|
|
if (pszMessage)
|
|
{
|
|
StrCpyN(szReason, pszMessage, ARRAYSIZE(szReason));
|
|
fOverridden = TRUE;
|
|
LocalFree(pszMessage);
|
|
}
|
|
LocalFree(pszApp);
|
|
}
|
|
}
|
|
|
|
if (!fOverridden)
|
|
{
|
|
fSysError = !LoadString(HINST_THISDLL, IDS_REASONS + nError, szReason, ARRAYSIZE(szReason));
|
|
}
|
|
}
|
|
|
|
if (nOper == OPER_DOFILE)
|
|
{
|
|
PathRemoveExtension(szFile);
|
|
}
|
|
|
|
if (fSysError)
|
|
{
|
|
SHSysErrorMessageBox(pcs->hwndDlgParent, MAKEINTRESOURCE(IDS_FILEERROR + wFunc),
|
|
idVerb, nError, PathFindFileName(szFile),
|
|
MB_OK | MB_ICONSTOP | MB_SETFOREGROUND);
|
|
}
|
|
else
|
|
{
|
|
if (nError > DE_ERROR_MAX &&
|
|
0 == FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
nError,
|
|
0,
|
|
szReason,
|
|
ARRAYSIZE(szReason),
|
|
NULL))
|
|
{
|
|
szReason[0] = 0;
|
|
}
|
|
|
|
DisplayFileOperationError(pcs->hwndDlgParent, idVerb, wFunc, nError, szReason, szFile, pszDest);
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// The following function is used to retry failed move/copy operations
|
|
// due to out of disk situations or path not found errors
|
|
// on the destination.
|
|
//
|
|
// parameters:
|
|
// pszDest Fully qualified path to destination file (ANSI)
|
|
// nError type of error: ERROR_DISK_FULL or ERROR_PATH_NOT_FOUND
|
|
// dwFileSize amount of space needed for this file if ERROR_DISK_FULL
|
|
//
|
|
// returns:
|
|
// 0 success (destination path has been created)
|
|
// != 0 dos error code including ERROR_CANCELLED
|
|
//
|
|
|
|
int CopyMoveRetry(COPY_STATE *pcs, LPCTSTR pszDest, int nError, ULARGE_INTEGER* pulFileSize)
|
|
{
|
|
UINT wFlags;
|
|
int result;
|
|
LPCTSTR wID;
|
|
TCHAR szTemp[MAX_PATH];
|
|
BOOL fFirstRetry = TRUE;
|
|
|
|
if (pcs->fFlags & FOF_NOERRORUI)
|
|
{
|
|
result = ERROR_CANCELLED;
|
|
goto ErrorExit;
|
|
}
|
|
|
|
lstrcpyn(szTemp, pszDest, ARRAYSIZE(szTemp));
|
|
PathRemoveFileSpec(szTemp);
|
|
|
|
do
|
|
{
|
|
// until the destination path has been created
|
|
if (nError == ERROR_PATH_NOT_FOUND)
|
|
{
|
|
if (!(pcs->fFlags & FOF_NOCONFIRMMKDIR))
|
|
{
|
|
wID = MAKEINTRESOURCE(IDS_PATHNOTTHERE);
|
|
wFlags = MB_ICONEXCLAMATION | MB_YESNO;
|
|
}
|
|
else
|
|
{
|
|
wID = 0;
|
|
}
|
|
}
|
|
else // ERROR_DISK_FULL
|
|
{
|
|
ULARGE_INTEGER ulDiskSize;
|
|
|
|
wFlags = MB_ICONEXCLAMATION | MB_RETRYCANCEL;
|
|
if (pulFileSize && TotalCapacity(pszDest, &ulDiskSize) && pulFileSize->QuadPart > ulDiskSize.QuadPart)
|
|
{
|
|
wID = MAKEINTRESOURCE(IDS_FILEWONTFIT);
|
|
}
|
|
else
|
|
{
|
|
wID = MAKEINTRESOURCE(IDS_DESTFULL);
|
|
}
|
|
}
|
|
|
|
if (wID)
|
|
{
|
|
// szTemp will be ignored if there's no %1%s in the string.
|
|
result = ShellMessageBox(HINST_THISDLL, pcs->hwndDlgParent, wID, MAKEINTRESOURCE(IDS_UNDO_FILEOP + pcs->lpfo->wFunc), wFlags, (LPTSTR)szTemp);
|
|
}
|
|
else
|
|
{
|
|
result = IDYES;
|
|
}
|
|
|
|
if (result == IDRETRY || result == IDYES)
|
|
{
|
|
TCHAR szDrive[5];
|
|
int idDrive;
|
|
|
|
// Allow the disk to be formatted
|
|
// REVIEW, could this be FO_MOVE as well?
|
|
if (FAILED(SHPathPrepareForWrite(((pcs->fFlags & FOF_NOERRORUI) ? NULL : pcs->hwndDlgParent), NULL, szTemp, SHPPFW_DEFAULT)))
|
|
return ERROR_CANCELLED;
|
|
|
|
idDrive = PathGetDriveNumber(szTemp);
|
|
if (idDrive != -1)
|
|
PathBuildRoot(szDrive, idDrive);
|
|
else
|
|
szDrive[0] = 0;
|
|
|
|
// if we're not copying to the root
|
|
if (lstrcmpi(szTemp, szDrive))
|
|
{
|
|
result = SHCreateDirectory(pcs->hwndDlgParent, szTemp);
|
|
|
|
if (result == ERROR_CANCELLED)
|
|
goto ErrorExit;
|
|
if (result == ERROR_ALREADY_EXISTS)
|
|
{
|
|
// if SHPathPrepareForWrite created the directory we shouldn't treat this as an error
|
|
result = 0;
|
|
}
|
|
else if (result && (nError == ERROR_PATH_NOT_FOUND))
|
|
{
|
|
result |= ERRORONDEST;
|
|
|
|
// We try twice to allow the recyclebin to be flushed.
|
|
if (fFirstRetry)
|
|
fFirstRetry = FALSE;
|
|
else
|
|
goto ErrorExit;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = 0;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
result = ERROR_CANCELLED;
|
|
goto ErrorExit;
|
|
}
|
|
} while (result);
|
|
|
|
ErrorExit:
|
|
return result; // success
|
|
}
|
|
|
|
|
|
BOOL ValidFilenames(LPCTSTR pList)
|
|
{
|
|
if (!*pList)
|
|
return FALSE;
|
|
|
|
for (; *pList; pList += lstrlen(pList) + 1)
|
|
{
|
|
if (PathIsInvalid(pList))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void AddRenamePairToHDSA(LPCTSTR pszOldPath, LPCTSTR pszNewPath, HDSA* phdsaRenamePairs)
|
|
{
|
|
//
|
|
// Update our collision mapping table
|
|
//
|
|
if (!*phdsaRenamePairs)
|
|
*phdsaRenamePairs = DSA_Create(sizeof(SHNAMEMAPPING), 4);
|
|
|
|
if (*phdsaRenamePairs)
|
|
{
|
|
SHNAMEMAPPING rp;
|
|
rp.cchOldPath = lstrlen(pszOldPath);
|
|
rp.cchNewPath = lstrlen(pszNewPath);
|
|
|
|
rp.pszOldPath = StrDup(pszOldPath);
|
|
if (rp.pszOldPath)
|
|
{
|
|
rp.pszNewPath = StrDup(pszNewPath);
|
|
if (rp.pszNewPath)
|
|
{
|
|
if (DSA_AppendItem(*phdsaRenamePairs, &rp) == -1)
|
|
{
|
|
LocalFree(rp.pszOldPath);
|
|
LocalFree(rp.pszNewPath);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
LocalFree(rp.pszOldPath);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL _HandleRename(LPCTSTR pszSource, LPTSTR pszDest, FILEOP_FLAGS fFlags, COPY_STATE * pcs)
|
|
{
|
|
TCHAR *pszConflictingName = PathFindFileName(pszSource);
|
|
TCHAR szTemp[MAX_PATH];
|
|
TCHAR szTemplate[MAX_PATH];
|
|
LPTSTR lpszLongPlate;
|
|
|
|
PathRemoveFileSpec(pszDest);
|
|
|
|
if (LoadString(HINST_THISDLL, IDS_COPYLONGPLATE, szTemplate, ARRAYSIZE(szTemplate)))
|
|
{
|
|
LPTSTR lpsz;
|
|
lpsz = pszConflictingName;
|
|
lpszLongPlate = szTemplate;
|
|
// see if the first part of the template is the same as the name "Copy #"
|
|
while (*lpsz && *lpszLongPlate &&
|
|
*lpsz == *lpszLongPlate &&
|
|
*lpszLongPlate != TEXT('('))
|
|
{
|
|
lpsz++;
|
|
lpszLongPlate++;
|
|
}
|
|
|
|
if (*lpsz == TEXT('(') && *lpszLongPlate == TEXT('('))
|
|
{
|
|
// conflicting name already in the template, use it instead
|
|
lpszLongPlate = pszConflictingName;
|
|
}
|
|
else
|
|
{
|
|
// otherwise build our own
|
|
// We need to make sure not to overflow a max buffer.
|
|
int ichFixed = lstrlen(szTemplate) + lstrlen(pszDest) + 5;
|
|
lpszLongPlate = szTemplate;
|
|
|
|
if ((ichFixed + lstrlen(pszConflictingName)) <= MAX_PATH)
|
|
{
|
|
lstrcat(lpszLongPlate, pszConflictingName);
|
|
}
|
|
else
|
|
{
|
|
// Need to remove some of the name
|
|
LPTSTR pszExt = StrRChr(pszConflictingName, NULL, TEXT('.'));
|
|
if (pszExt)
|
|
{
|
|
int ichTemplate = lstrlen(lpszLongPlate);
|
|
lstrcpyn(lpszLongPlate + ichTemplate,
|
|
pszConflictingName,
|
|
max(MAX_PATH - ichFixed - lstrlen(pszExt), 0));
|
|
|
|
// use as much of the buffer as possible
|
|
StrCatBuff(lpszLongPlate, pszExt, max(MAX_PATH - ichFixed + ichTemplate, 0));
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(lpszLongPlate + lstrlen(lpszLongPlate),
|
|
pszConflictingName,
|
|
MAX_PATH - ichFixed);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lpszLongPlate = NULL;
|
|
}
|
|
|
|
if (PathYetAnotherMakeUniqueName(szTemp, pszDest, pszConflictingName, lpszLongPlate))
|
|
{
|
|
//
|
|
// If there are any other files in the queue which are to
|
|
// be copied into a subtree of pszDest, we must update them
|
|
// as well.
|
|
//
|
|
|
|
// Put the new (renamed) target in pszDest.
|
|
lstrcpy(pszDest, szTemp);
|
|
|
|
// Rebuild the old dest name and put it in szTemp.
|
|
// I'm going for minimum stack usage here, so I don't want more
|
|
// than one MAX_PATH lying around.
|
|
PathRemoveFileSpec(szTemp);
|
|
PathAppend(szTemp, pszConflictingName);
|
|
|
|
AddRenamePairToHDSA(szTemp, pszDest, &pcs->dth.hdsaRenamePairs);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
// test input for "multiple" filespec
|
|
//
|
|
// examples:
|
|
// 1 foo.bar (single non directory file)
|
|
// -1 *.exe (wild card on any of the files)
|
|
// n foo.bar bletch.txt (number of files)
|
|
//
|
|
|
|
int CountFiles(LPCTSTR pInput)
|
|
{
|
|
int count;
|
|
for (count = 0; *pInput; pInput += lstrlen(pInput) + 1, count++)
|
|
{
|
|
// wild cards imply multiple files
|
|
if (PathIsWild(pInput))
|
|
return -1;
|
|
}
|
|
return count;
|
|
|
|
}
|
|
|
|
#define ISDIGIT(c) ((c) >= TEXT('0') && (c) <= TEXT('9'))
|
|
|
|
BOOL IsCompressedVolume(LPCTSTR pszSource, DWORD dwAttributes)
|
|
{
|
|
int i;
|
|
LPTSTR pszFileName, pszExtension;
|
|
TCHAR szPath[MAX_PATH];
|
|
|
|
// must be marked system and hidden
|
|
if (!IS_SYSTEM_HIDDEN(dwAttributes))
|
|
return FALSE;
|
|
|
|
lstrcpy(szPath, pszSource);
|
|
pszFileName = PathFindFileName(szPath);
|
|
pszExtension = PathFindExtension(pszFileName);
|
|
|
|
// make sure the extension is a 3 digit number
|
|
if (!*pszExtension)
|
|
return FALSE; // no extension
|
|
|
|
for (i = 1; i < 4; i++)
|
|
{
|
|
if (!pszExtension[i] || !ISDIGIT(pszExtension[i]))
|
|
return FALSE;
|
|
}
|
|
|
|
// make sure it's null terminated here
|
|
if (pszExtension[4])
|
|
return FALSE;
|
|
|
|
// now knock off the extension and make sure the stem matches
|
|
*pszExtension = 0;
|
|
if (lstrcmpi(pszFileName, TEXT("DRVSPACE")) &&
|
|
lstrcmpi(pszFileName, TEXT("DBLSPACE")))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// make sure it's in the root
|
|
PathRemoveFileSpec(szPath);
|
|
if (!PathIsRoot(szPath))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE; // passed all tests!
|
|
}
|
|
|
|
void _DeferMoveDlgItem(HDWP hdwp, HWND hDlg, int nItem, int x, int y)
|
|
{
|
|
RECT rc;
|
|
HWND hwnd = GetDlgItem(hDlg, nItem);
|
|
|
|
GetClientRect(hwnd, &rc);
|
|
MapWindowPoints(hwnd, hDlg, (LPPOINT) &rc, 2);
|
|
|
|
DeferWindowPos(hdwp, hwnd, 0, rc.left + x, rc.top + y, 0, 0,
|
|
SWP_NOZORDER | SWP_NOSIZE | SWP_SHOWWINDOW | SWP_NOACTIVATE);
|
|
}
|
|
|
|
void _RecalcWindowHeight(HWND hWnd, LPTSTR lpszText)
|
|
{
|
|
HDC hdc = GetDC(hWnd);
|
|
RECT rc;
|
|
HWND hwndText = GetDlgItem(hWnd,IDC_MBC_TEXT);
|
|
HDWP hdwp;
|
|
int iHeightDelta, cx;
|
|
|
|
// Get the starting rect of the text area (for the width)
|
|
GetClientRect(hwndText, &rc);
|
|
MapWindowPoints(hwndText, hWnd, (LPPOINT) &rc, 2);
|
|
|
|
// Calc how high the static text area needs to be, given the above width
|
|
iHeightDelta = RECTHEIGHT(rc);
|
|
cx = RECTWIDTH(rc);
|
|
DrawText(hdc, lpszText, -1, &rc, DT_CALCRECT | DT_WORDBREAK | DT_LEFT | DT_INTERNAL | DT_EDITCONTROL);
|
|
|
|
iHeightDelta = RECTHEIGHT(rc) - iHeightDelta;
|
|
cx = RECTWIDTH(rc) - cx; // Should only change for really long words w/o spaces
|
|
if (cx < 0)
|
|
cx = 0;
|
|
|
|
ReleaseDC(hWnd, hdc);
|
|
|
|
hdwp = BeginDeferWindowPos(4);
|
|
if (hdwp)
|
|
{
|
|
hdwp = DeferWindowPos(hdwp, hwndText, 0, rc.left, rc.top, RECTWIDTH(rc), RECTHEIGHT(rc), SWP_NOZORDER | SWP_NOACTIVATE);
|
|
if (hdwp)
|
|
{
|
|
_DeferMoveDlgItem(hdwp, hWnd, IDC_MESSAGEBOXCHECKEX, 0, iHeightDelta);
|
|
_DeferMoveDlgItem(hdwp, hWnd, IDYES, cx, iHeightDelta);
|
|
_DeferMoveDlgItem(hdwp, hWnd, IDNO, cx, iHeightDelta);
|
|
|
|
EndDeferWindowPos(hdwp);
|
|
}
|
|
}
|
|
|
|
GetWindowRect(hWnd, &rc);
|
|
SetWindowPos(hWnd, 0, rc.left - (cx/2), rc.top - (iHeightDelta/2), RECTWIDTH(rc)+cx, RECTHEIGHT(rc)+iHeightDelta, SWP_NOZORDER | SWP_NOACTIVATE);
|
|
return;
|
|
}
|
|
|
|
BOOL_PTR CALLBACK RenameMsgBoxCheckDlgProc(HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
// we only handle the WM_INITDIALOG so that we can resize the dialog
|
|
// approprately and to set the default button to IDNO
|
|
case WM_INITDIALOG:
|
|
{
|
|
HWND hwndNO = GetDlgItem(hDlg, IDNO);
|
|
|
|
_RecalcWindowHeight(hDlg, (LPTSTR)lParam);
|
|
|
|
SetDlgItemText(hDlg,IDC_MBC_TEXT,(LPTSTR)lParam);
|
|
|
|
SendMessage(hDlg, DM_SETDEFID, IDNO, 0);
|
|
SetFocus(hwndNO);
|
|
|
|
return FALSE; // we set the focus, so return false
|
|
}
|
|
}
|
|
|
|
// didnt handle this message
|
|
return FALSE;
|
|
}
|
|
|
|
int ConfirmRenameOfConnectedItem(COPY_STATE *pcs, WIN32_FIND_DATA *pfd, LPTSTR szSource)
|
|
{
|
|
int result = IDYES; //For non-connected elements, the default is IDYES!
|
|
LPTSTR pszMessage;
|
|
LPTSTR lpConnectedItem, lpConnectOrigin;
|
|
LPTSTR lpStringID;
|
|
|
|
//Check if this item being renamed has a connected item.
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
{
|
|
//Yes! It has a connected element! Form the strings to create the confirmation dialog!
|
|
|
|
//Get the name of the connected element
|
|
lpConnectedItem = PathFindFileName(pcs->dth.pdtnCurrent->pdtnConnected->szName);
|
|
lpConnectOrigin = PathFindFileName(pcs->dth.pFrom);
|
|
|
|
// Mark the connected item as dummy as this will never get renamed.
|
|
// (Note that this connected node could be a folder. It is still OK to mark it as
|
|
// dummy because for rename operation, a folder is treated just like a file in
|
|
// DTGotoNextNode()).
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
|
|
if (pfd && (pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
lpStringID = MAKEINTRESOURCE(IDS_HTML_FOLDER_RENAME);
|
|
else
|
|
lpStringID = MAKEINTRESOURCE(IDS_HTML_FILE_RENAME);
|
|
|
|
//Load the confirmation message and format it!
|
|
pszMessage = ShellConstructMessageString(HINST_THISDLL, lpStringID,
|
|
lpConnectedItem, lpConnectOrigin);
|
|
|
|
if (pszMessage)
|
|
{
|
|
//Get the confirmation from the end-user;
|
|
result = SHMessageBoxCheckEx(pcs->hwndDlgParent, HINST_THISDLL,
|
|
MAKEINTRESOURCE(DLG_RENAME_MESSAGEBOXCHECK),
|
|
RenameMsgBoxCheckDlgProc,
|
|
(void *)pszMessage,
|
|
IDYES,
|
|
REG_VAL_GENERAL_RENAMEHTMLFILE);
|
|
//It is possible we get IDCANCEL if the "X" in the caption is clicked to clost
|
|
// the dialog. The following code makes sure we get one of the return code that we want.
|
|
if ((result != IDYES) && (result != IDNO))
|
|
result = IDNO;
|
|
|
|
SHFree(pszMessage);
|
|
}
|
|
else
|
|
result = IDNO; //For connected elements, the default is "Don't rename";
|
|
}
|
|
else
|
|
{
|
|
if (DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
result = IDNO; //Connected elements, do not get renamed.
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int AllConfirmations(COPY_STATE *pcs, WIN32_FIND_DATA *pfd, UINT oper, UINT wFunc,
|
|
LPTSTR szSource, LPTSTR szDest, BOOL bTimeToUpdate,
|
|
WIN32_FIND_DATA *pfdDest, LPINT lpret)
|
|
{
|
|
int result = IDYES;
|
|
LPTSTR p;
|
|
LPTSTR pszStatusDest = NULL;
|
|
CONFIRM_FLAG fConfirm;
|
|
WIN32_FIND_DATA *pfdUse1 = NULL;
|
|
WIN32_FIND_DATA *pfdUse2;
|
|
BOOL fSetProgress = FALSE;
|
|
BOOL fShowConfirm = FALSE;
|
|
|
|
switch (oper | wFunc)
|
|
{
|
|
case OPER_ENTERDIR | FO_MOVE:
|
|
if (PathIsSameRoot(szSource, szDest))
|
|
{
|
|
fConfirm = CONFIRM_MOVE_FOLDER;
|
|
pfdUse1 = pfd;
|
|
pfdUse2 = pfdDest;
|
|
fShowConfirm = TRUE;
|
|
}
|
|
break;
|
|
|
|
case OPER_ENTERDIR | FO_DELETE:
|
|
// Confirm removal of directory on this pass. The directories
|
|
// are actually removed on the OPER_LEAVEDIR pass
|
|
if (DTNIsRootNode(pcs->dth.pdtnCurrent))
|
|
fSetProgress = TRUE;
|
|
|
|
if (!PathIsRoot(szSource))
|
|
{
|
|
fShowConfirm = TRUE;
|
|
pfdUse2 = pfd;
|
|
fConfirm = CONFIRM_DELETE_FOLDER;
|
|
szDest = NULL;
|
|
}
|
|
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_RENAME:
|
|
// pszStatusDest = szDest;
|
|
fSetProgress = TRUE;
|
|
|
|
p = PathFindFileName(szSource);
|
|
if (!IntlStrEqNI(szSource, szDest, (int)(p - szSource)))
|
|
{
|
|
result = DE_DIFFDIR;
|
|
}
|
|
else
|
|
{
|
|
if (pfd && (pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
fConfirm = CONFIRM_RENAME_FOLDER;
|
|
else
|
|
fConfirm = CONFIRM_RENAME_FILE;
|
|
|
|
if (PathIsRoot(szSource) || (PathIsRoot(szDest)))
|
|
{
|
|
result = DE_ROOTDIR | ERRORONDEST;
|
|
}
|
|
else
|
|
{
|
|
// We need to bring up a special confirmation dialog if this file/folder being
|
|
// renamed has a connected element (if "foo.htm" or "foo files" is renamed that
|
|
// will break the links).
|
|
result = ConfirmRenameOfConnectedItem(pcs, pfd, szSource);
|
|
|
|
if (result != IDNO)
|
|
{
|
|
fShowConfirm = TRUE;
|
|
pfdUse2 = pfdDest;
|
|
pfdUse1 = pfd;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_MOVE:
|
|
|
|
fSetProgress = TRUE;
|
|
pszStatusDest = szDest;
|
|
if (PathIsRoot(szSource))
|
|
{
|
|
result = DE_ROOTDIR;
|
|
}
|
|
else if (PathIsRoot(szDest))
|
|
{
|
|
result = DE_ROOTDIR | ERRORONDEST;
|
|
}
|
|
else
|
|
{
|
|
fConfirm = CONFIRM_MOVE_FILE;
|
|
fShowConfirm = TRUE;
|
|
pfdUse2 = pfdDest;
|
|
pfdUse1 = pfd;
|
|
}
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_DELETE:
|
|
fSetProgress = TRUE;
|
|
|
|
if (IsCompressedVolume(szSource, pfd->dwFileAttributes))
|
|
{
|
|
CopyError(pcs, szSource, szDest, DE_COMPRESSEDVOLUME, wFunc, oper);
|
|
result = IDNO;
|
|
}
|
|
else
|
|
{
|
|
fShowConfirm = TRUE;
|
|
szDest = NULL;
|
|
pfdUse2 = pfd;
|
|
fConfirm = CONFIRM_DELETE_FILE;
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
if (fShowConfirm)
|
|
{
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), fConfirm,
|
|
szSource, pfdUse1, szDest, pfdUse2, NULL);
|
|
}
|
|
|
|
if (oper == OPER_DOFILE || oper == OPER_ENTERDIR)
|
|
{
|
|
if ((wFunc == FO_MOVE) || (wFunc == FO_COPY))
|
|
{
|
|
if ((result != IDNO) && (result != IDCANCEL))
|
|
{
|
|
LPTSTR pszDataToBeLost;
|
|
WCHAR wszDestDir[MAX_PATH];
|
|
BOOL bNoStreamLossThisDir = FALSE;
|
|
|
|
lstrcpy(wszDestDir, szDest);
|
|
PathRemoveFileSpec(wszDestDir);
|
|
|
|
// Files with multiple streams will suffer stream loss on a downlevel
|
|
// copy, but CopyFile special-cases native structure storage.
|
|
|
|
pszDataToBeLost = GetDownlevelCopyDataLossText(szSource, wszDestDir, (oper == OPER_ENTERDIR), &bNoStreamLossThisDir);
|
|
if (pszDataToBeLost)
|
|
{
|
|
fConfirm = CONFIRM_STREAMLOSS;
|
|
pfdUse2 = pfd;
|
|
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd, pcs->nSourceFiles, !DTNIsRootNode(pcs->dth.pdtnCurrent), fConfirm,
|
|
szSource, pfdUse1, szDest, pfdUse2, pszDataToBeLost);
|
|
LocalFree(pszDataToBeLost);
|
|
}
|
|
else if (bNoStreamLossThisDir)
|
|
{
|
|
// pcs->bStreamLossPossible = FALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// We only really care about OPER_ENTERDIR when deleting and
|
|
// OPER_DOFILE when renaming, but I guess the hook will figure it out
|
|
|
|
if ((result == IDYES) &&
|
|
ISDIRFINDDATA(*pfd) &&
|
|
(oper==OPER_ENTERDIR || oper==OPER_DOFILE))
|
|
{
|
|
|
|
result = CallFileCopyHooks(pcs->hwndDlgParent, wFunc, pcs->fFlags,
|
|
szSource, pfd->dwFileAttributes,
|
|
szDest, pfdDest->dwFileAttributes);
|
|
}
|
|
|
|
if ((result != IDCANCEL) && (result != IDNO) && fSetProgress && bTimeToUpdate)
|
|
SetProgressText(pcs, szSource, pszStatusDest);
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// return TRUE if they're the same file
|
|
// assumes that given two file specs, the short name will
|
|
// be identical (except case)
|
|
BOOL SameFile(LPTSTR pszSource, LPTSTR pszDest)
|
|
{
|
|
TCHAR szShortSrc[MAX_PATH];
|
|
if (GetShortPathName(pszSource, szShortSrc, ARRAYSIZE(szShortSrc)))
|
|
{
|
|
TCHAR szShortDest[MAX_PATH];
|
|
if (GetShortPathName(pszDest, szShortDest, ARRAYSIZE(szShortDest)))
|
|
return !lstrcmpi(szShortSrc, szShortDest);
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// make sure we aren't operating on the current dir to avoid
|
|
// ERROR_CURRENT_DIRECTORY kinda errors
|
|
|
|
void AvoidCurrentDirectory(LPCTSTR p)
|
|
{
|
|
TCHAR szTemp[MAX_PATH];
|
|
|
|
GetCurrentDirectory(ARRAYSIZE(szTemp), szTemp);
|
|
if (lstrcmpi(szTemp, p) == 0)
|
|
{
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("operating on current dir(%s), cd .."), p);
|
|
PathRemoveFileSpec(szTemp);
|
|
SetCurrentDirectory(szTemp);
|
|
}
|
|
}
|
|
|
|
// this resolves short/long name collisions such as moving
|
|
// "NewFolde" onto a dir with "New Folder" whose short name is "NEWFOLDE"
|
|
//
|
|
// we resolve this by renaming "New Folder" to a unique short name (like TMP1)
|
|
//
|
|
// making a temporary file of name "NEWFOLDE"
|
|
//
|
|
// renaming TMP1 back to "New Folder" (at which point it will have a new short
|
|
// name like "NEWFOL~1"
|
|
|
|
// PERF: it'd be faster if we didn't make the temporary file, but that
|
|
// would require that we rename the file back to the long name at the
|
|
// end of the operation.. which would mean we'd need to queue them all up..
|
|
// too much for right now.
|
|
BOOL ResolveShortNameCollisions(LPCTSTR lpszDest, WIN32_FIND_DATA *pfd)
|
|
{
|
|
BOOL fRet = FALSE;
|
|
|
|
// first verify that we're in the name collision.
|
|
// we are if lpszDest is the same as the pfd's short name which is different
|
|
// than it's long name.
|
|
|
|
if (!lstrcmpi(PathFindFileName(lpszDest), pfd->cAlternateFileName) &&
|
|
lstrcmpi(pfd->cAlternateFileName, pfd->cFileName))
|
|
{
|
|
// yes... do the renaming
|
|
TCHAR szTemp[MAX_PATH];
|
|
TCHAR szLongName[MAX_PATH];
|
|
|
|
lstrcpy(szTemp, lpszDest);
|
|
PathRemoveFileSpec(szTemp);
|
|
|
|
// build the original long name
|
|
lstrcpy(szLongName, szTemp);
|
|
PathAppend(szLongName, pfd->cFileName);
|
|
|
|
GetTempFileName(szTemp, c_szNULL, 1, szTemp);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("Got %s as a temp file"), szTemp);
|
|
// rename "New Folder" to "tmp1"
|
|
if (Win32MoveFile(szLongName, szTemp, ISDIRFINDDATA(*pfd)))
|
|
{
|
|
// make a temporary "NewFolde"
|
|
fRet = CreateWriteCloseFile(NULL, lpszDest, NULL, 0);
|
|
ASSERT(fRet);
|
|
|
|
// move it back...
|
|
|
|
if (!Win32MoveFile(szTemp, szLongName, ISDIRFINDDATA(*pfd)))
|
|
{
|
|
//
|
|
// Can't move it back, so delete the empty dir and then
|
|
// move it back. Return FALSE to denote failure.
|
|
//
|
|
DeleteFile(lpszDest);
|
|
Win32MoveFile(szTemp, szLongName, ISDIRFINDDATA(*pfd));
|
|
fRet = FALSE;
|
|
}
|
|
else
|
|
{
|
|
// send this out because we could have confused views
|
|
// with this swapping files around... by the time they get the first
|
|
// move file notification, the temp file is likely gone
|
|
// so they could blow that off.. which would mess up the rest of this.
|
|
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szLongName, NULL);
|
|
//
|
|
// We've now created an empty dir entry of this name type.
|
|
//
|
|
Win32DeleteFile(lpszDest);
|
|
}
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("ResolveShortNameCollision: %s = original, %s = destination,\n %s = temp file, %d = return"), szLongName, lpszDest, szTemp, fRet);
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
|
|
typedef struct { LPTSTR szFilename; int iResult; } RENAMEEXEMPTIONINFO;
|
|
RENAMEEXEMPTIONINFO g_rgExemptions[] = {
|
|
{ TEXT("thumbs.db"), IDYES }
|
|
};
|
|
|
|
// return values.
|
|
//
|
|
// IDCANCEL = bail out of all operations
|
|
// IDNO = skip this one
|
|
// IDRETRY = try operation again
|
|
// IDUNKNOWN = this (collision) is not the problem
|
|
#define IDUNKNOWN IDOK
|
|
int CheckForRenameCollision(COPY_STATE *pcs, UINT oper, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfdDest, WIN32_FIND_DATA* pfd)
|
|
{
|
|
int iRet = IDUNKNOWN;
|
|
|
|
ASSERT((pcs->lpfo->wFunc != FO_DELETE) && (oper != OPER_LEAVEDIR));
|
|
|
|
|
|
/* Check to see if we are overwriting an existing file or
|
|
directory. If so, better confirm */
|
|
|
|
if ((oper == OPER_DOFILE) ||
|
|
((oper == OPER_ENTERDIR) && (pcs->fFlags & FOF_RENAMEONCOLLISION)))
|
|
{
|
|
HANDLE hfindT;
|
|
|
|
// REVIEW this slows things down checking for the dest file
|
|
if ((hfindT = FindFirstFile(pszDest, pfdDest)) != INVALID_HANDLE_VALUE)
|
|
{
|
|
FindClose(hfindT);
|
|
|
|
iRet = IDCANCEL;
|
|
|
|
if (pcs->lpfo->wFunc != FO_RENAME || !SameFile(pszSource, pszDest))
|
|
{
|
|
|
|
if (!ResolveShortNameCollisions(pszDest, pfdDest))
|
|
{
|
|
if (pcs->fFlags & FOF_RENAMEONCOLLISION)
|
|
{
|
|
// The client wants us to generate a new name for the
|
|
// source file to avoid a collision at the destination
|
|
// dir. Must also update the current queue and the
|
|
// copy root.
|
|
_HandleRename(pszSource, pszDest, pcs->fFlags, pcs);
|
|
iRet = IDRETRY;
|
|
}
|
|
else
|
|
{
|
|
int result = IDRETRY;
|
|
|
|
if (pcs->lpfo->wFunc == FO_RENAME)
|
|
{
|
|
return ERROR_ALREADY_EXISTS;
|
|
}
|
|
|
|
// Is this a super-hidden file we don't want to prompt the
|
|
// user regarding?
|
|
if (IS_SYSTEM_HIDDEN(pfd->dwFileAttributes) &&
|
|
IS_SYSTEM_HIDDEN(pfdDest->dwFileAttributes) &&
|
|
!ShowSuperHidden())
|
|
{
|
|
int cExempt = 0;
|
|
for (; cExempt < ARRAYSIZE(g_rgExemptions); cExempt++)
|
|
{
|
|
if (0 == StrCmpI(g_rgExemptions[cExempt].szFilename, PathFindFileName(pszSource)))
|
|
{
|
|
result = g_rgExemptions[cExempt].iResult;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// REVIEW, if the destination file we are copying over
|
|
// is actually a directory we are doomed. we can
|
|
// try to remove the dir but that will fail if there
|
|
// are files there. we probably need a special error message
|
|
// for this case.
|
|
|
|
if (result == IDRETRY)
|
|
{
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs,
|
|
&pcs->cd, pcs->nSourceFiles,
|
|
!DTNIsRootNode(pcs->dth.pdtnCurrent),
|
|
CONFIRM_REPLACE_FILE,
|
|
pszSource, pfd, pszDest, pfdDest, NULL);
|
|
}
|
|
switch (result)
|
|
{
|
|
case IDYES:
|
|
|
|
if ((pcs->lpfo->wFunc == FO_MOVE) && (PathIsSameRoot(pszSource, pszDest)))
|
|
{
|
|
int ret;
|
|
// For FO_MOVE we need to delete the
|
|
// destination first. Do that now.
|
|
|
|
// FEATURE this replace options should be undable
|
|
ret = Win32DeleteFile(pszDest) ? 0 : GetLastError();
|
|
|
|
if (ret)
|
|
{
|
|
ret |= ERRORONDEST;
|
|
result = ret;
|
|
}
|
|
}
|
|
if (pcs->lpua)
|
|
FOUndo_Release(pcs->lpua);
|
|
iRet = IDRETRY;
|
|
break;
|
|
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
iRet = result;
|
|
break;
|
|
|
|
default:
|
|
iRet = result;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iRet = IDRETRY;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
int LeaveDir_Delete(COPY_STATE *pcs, LPTSTR pszSource)
|
|
{
|
|
int ret;
|
|
if (PathIsRoot(pszSource))
|
|
return 0;
|
|
|
|
AvoidCurrentDirectory(pszSource);
|
|
|
|
// We already confirmed the delete at MKDIR time, so attempt
|
|
// to delete the directory
|
|
|
|
ret = Win32RemoveDirectory(pszSource) ? 0 : GetLastError();
|
|
if (!ret)
|
|
{
|
|
FOUndo_FileReallyDeleted(pszSource);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
int EnterDir_Copy(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried)
|
|
{
|
|
int ret;
|
|
int result;
|
|
BOOL fSetDestAttributes = FALSE;
|
|
DWORD dwDesiredAttributes = pfd->dwFileAttributes;
|
|
|
|
// Whenever we enter a directory, we need to reset the bStreamLossPossible flag,
|
|
// since we could have stepped out from an NTFS->NTFS to NTFS->FAT scenario via
|
|
// a junction point
|
|
|
|
pcs->bStreamLossPossible = TRUE;
|
|
|
|
// SHMoveFile restricts the based on path length. To be consistent, we make the same
|
|
// restricton on Copy directory also.
|
|
if (IsDirPathTooLongForCreateDir(pszDest))
|
|
{
|
|
ret = ERROR_FILENAME_EXCED_RANGE;
|
|
}
|
|
else
|
|
{
|
|
BOOL fWithoutTemplate = FALSE;
|
|
|
|
if (pcs->fLostEncryptOk)
|
|
{
|
|
dwDesiredAttributes &= ~FILE_ATTRIBUTE_ENCRYPTED; // Pretend its not encrypted
|
|
fSetDestAttributes = TRUE;
|
|
fWithoutTemplate = TRUE;
|
|
}
|
|
|
|
if (pfd->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT)
|
|
{
|
|
if (!(pcs->fFlags & FOF_NORECURSEREPARSE))
|
|
{
|
|
dwDesiredAttributes &= ~FILE_ATTRIBUTE_REPARSE_POINT; // Pretend like its just a folder
|
|
fSetDestAttributes = TRUE;
|
|
fWithoutTemplate = TRUE;
|
|
}
|
|
}
|
|
|
|
if (fWithoutTemplate)
|
|
{
|
|
ret = (CreateDirectory(pszDest, NULL) ? 0 : GetLastError());
|
|
|
|
// Since we didn't call CreateDirectoryEx, we need to manually
|
|
// propogate the attributes to the dest directory.
|
|
fSetDestAttributes = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ret = (CreateDirectoryEx(pszSource, pszDest, NULL) ? 0 : GetLastError());
|
|
}
|
|
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
SHChangeNotify(SHCNE_MKDIR, SHCNF_PATH, pszDest, NULL);
|
|
}
|
|
}
|
|
|
|
switch (ret)
|
|
{
|
|
case 0: // successful folder creation (or it already exists)
|
|
// propogate the attributes (if there are any)
|
|
|
|
if (pcs->fFromCDRom)
|
|
{
|
|
// Don't propogate read-only from CDRoms
|
|
dwDesiredAttributes &= ~FILE_ATTRIBUTE_READONLY;
|
|
fSetDestAttributes = TRUE;
|
|
}
|
|
|
|
if (fSetDestAttributes)
|
|
{
|
|
// Avoid setting FILE_ATTRIBUTE_DIRECTORY, since its
|
|
// already a directory, and is less error prone.
|
|
SetFileAttributes(pszDest, dwDesiredAttributes);
|
|
}
|
|
|
|
// we should set the security ACLs here on NT
|
|
// we ignore any kind of failure though, is that OK?
|
|
//
|
|
CopyFileSecurity(pszSource, pszDest);
|
|
|
|
// add to the undo atom
|
|
if (pcs->lpua)
|
|
{
|
|
if (DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0);
|
|
}
|
|
break;
|
|
|
|
case ERROR_ALREADY_EXISTS:
|
|
case ERROR_DISK_FULL:
|
|
case ERROR_ACCESS_DENIED:
|
|
case ERROR_INVALID_NAME:
|
|
{
|
|
DWORD dwFileAttributes;
|
|
|
|
if (!fRenameTried)
|
|
{
|
|
int result = CheckForRenameCollision(pcs, OPER_ENTERDIR, pszSource, pszDest, pfdDest, pfd);
|
|
switch (result)
|
|
{
|
|
case IDUNKNOWN:
|
|
break;
|
|
|
|
case IDRETRY:
|
|
return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, TRUE);
|
|
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
return result;
|
|
|
|
case IDNO:
|
|
return result;
|
|
|
|
default:
|
|
return result;
|
|
}
|
|
}
|
|
|
|
dwFileAttributes = GetFileAttributes(pszDest);
|
|
|
|
if (dwFileAttributes == (DWORD)-1)
|
|
{
|
|
// The dir does not exist, so it looks like a problem
|
|
// with a read-only drive or disk full
|
|
|
|
if (ret == ERROR_DISK_FULL &&
|
|
IsRemovableDrive(DRIVEID(pszDest)) &&
|
|
!PathIsSameRoot(pszDest, pszSource))
|
|
{
|
|
ret = CopyMoveRetry(pcs, pszDest, ERROR_DISK_FULL, NULL);
|
|
if (!ret)
|
|
{
|
|
return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried);
|
|
}
|
|
else
|
|
{
|
|
pcs->bAbort = TRUE;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// Maybe its an encrypted folder thats losing its encryption?
|
|
if (pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED)
|
|
{
|
|
int result;
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs,
|
|
&pcs->cd, pcs->nSourceFiles,
|
|
FALSE,
|
|
CONFIRM_LOST_ENCRYPT_FOLDER,
|
|
pszSource, pfd, pszDest, NULL, NULL);
|
|
|
|
switch (result)
|
|
{
|
|
case IDYES:
|
|
pcs->fLostEncryptOk = TRUE;
|
|
return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried);
|
|
|
|
case IDNO:
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
ret = result;
|
|
break;
|
|
|
|
default:
|
|
ret = result;
|
|
break;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
CopyError(pcs, pszSource, pszDest, ERROR_ACCESS_DENIED | ERRORONDEST, FO_COPY, OPER_DOFILE);
|
|
pcs->bAbort = TRUE;
|
|
return ret;
|
|
}
|
|
|
|
if (!(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
// A file with this name already exists
|
|
CopyError(pcs, pszSource, pszDest, DE_FLDDESTISFILE | ERRORONDEST, FO_COPY, OPER_DOFILE);
|
|
pcs->bAbort = TRUE;
|
|
return ret;
|
|
}
|
|
|
|
result = CachedConfirmFileOp(pcs->hwndDlgParent, pcs, &pcs->cd,
|
|
pcs->nSourceFiles,
|
|
!DTNIsRootNode(pcs->dth.pdtnCurrent),
|
|
CONFIRM_REPLACE_FOLDER,
|
|
pszSource, pfd, pszDest, pfdDest, NULL);
|
|
switch (result)
|
|
{
|
|
case IDYES:
|
|
ret = 0; // convert to no error
|
|
pcs->fMerge = TRUE;
|
|
if (pcs->lpua)
|
|
FOUndo_Release(pcs->lpua);
|
|
break;
|
|
|
|
case IDNO:
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
ret = IDNO; // Don't put up error message on this one...
|
|
// Since the end-user cancelled the copy operation on this folder, we can cancel the
|
|
// copy operation on the corresponding connected file too!
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
pcs->bAbort = TRUE;
|
|
// Since the end-user cancelled the copy operation on this folder, we can cancel the
|
|
// copy operation on the corresponding connected file too!
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
break;
|
|
|
|
default:
|
|
result = ret;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case ERROR_CANCELLED:
|
|
pcs->bAbort = TRUE;
|
|
break;
|
|
|
|
case ERROR_FILENAME_EXCED_RANGE:
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
break;
|
|
|
|
default: // ret != 0 (dos error code)
|
|
ret |= ERRORONDEST;
|
|
break;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int EnterDir_Move(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried)
|
|
{
|
|
int ret;
|
|
|
|
// Whenever we enter a directory, we need to reset the bStreamLossPossible flag,
|
|
// since we could have stepped out from an NTFS->NTFS to NTFS->FAT scenario via
|
|
// a junction point
|
|
|
|
pcs->bStreamLossPossible = TRUE;
|
|
|
|
// if these are in the same drive, try using MoveFile on it.
|
|
// if that fails then fail through to the copy
|
|
|
|
if (PathIsSameRoot(pszSource, pszDest))
|
|
{
|
|
AvoidCurrentDirectory(pszSource);
|
|
|
|
ret = Win32MoveFile(pszSource, pszDest, TRUE) ? 0 : GetLastError();
|
|
|
|
switch (ret)
|
|
{
|
|
case 0:
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("Move Folder worked!"));
|
|
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
|
|
// add to the undo atom
|
|
if (pcs->lpua && DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0);
|
|
|
|
if (!SHRestricted(REST_NOENCRYPTONMOVE) &&
|
|
!(pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED))
|
|
{
|
|
TCHAR szDestDir[MAX_PATH];
|
|
DWORD dwAttribs;
|
|
|
|
StrCpyN(szDestDir, pszDest, ARRAYSIZE(szDestDir));
|
|
PathRemoveFileSpec(szDestDir);
|
|
dwAttribs = GetFileAttributes(szDestDir);
|
|
|
|
if ((dwAttribs != -1) && (dwAttribs & FILE_ATTRIBUTE_ENCRYPTED))
|
|
{
|
|
// Encrypt the directory by pretending we are the
|
|
// property sheet properties->Advanced. Fill in the fake
|
|
// information and call the helper.
|
|
FILEPROPSHEETPAGE fpsp;
|
|
FOLDERCONTENTSINFO fci;
|
|
fci.fIsCompressionAvailable = FALSE;
|
|
fci.fMultipleFiles = TRUE;
|
|
ZeroMemory(&fpsp, SIZEOF(fpsp));
|
|
fpsp.hDlg = GetWindow(pcs->hwndDlgParent, GW_CHILD);
|
|
fpsp.fRecursive = TRUE;
|
|
fpsp.fIsDirectory = TRUE;
|
|
fpsp.pfci = &fci;
|
|
// As long as asInitial.* == asCurrent.* it won't be changed
|
|
fpsp.asInitial.fReadOnly = BST_INDETERMINATE;
|
|
fpsp.asInitial.fHidden = BST_INDETERMINATE;
|
|
fpsp.asInitial.fIndex = BST_INDETERMINATE;
|
|
fpsp.asInitial.fArchive = BST_INDETERMINATE;
|
|
fpsp.asInitial.fCompress = BST_INDETERMINATE;
|
|
fpsp.asInitial.fEncrypt = BST_UNCHECKED; // Not encrypted yet
|
|
fpsp.asInitial.fRecordingEnabled = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fReadOnly = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fHidden = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fIndex = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fArchive = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fCompress = BST_INDETERMINATE;
|
|
fpsp.asCurrent.fEncrypt = BST_CHECKED; // Now encrypt
|
|
fpsp.asCurrent.fRecordingEnabled = BST_INDETERMINATE;
|
|
ApplyRecursiveFolderAttribs(pszDest, &fpsp);
|
|
}
|
|
}
|
|
|
|
// Win32MoveFile on a single-volume leaves the original ACL
|
|
// intact. If necessary, pick up perms from the destination.
|
|
if (pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS)
|
|
{
|
|
ResetFileSecurity(pszDest);
|
|
}
|
|
return 0;
|
|
|
|
case ERROR_PATH_NOT_FOUND:
|
|
ret = CopyMoveRetry(pcs, pszDest, ret, NULL);
|
|
if (!ret)
|
|
return EnterDir_Move(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried);
|
|
return ret;
|
|
|
|
case ERROR_ALREADY_EXISTS:
|
|
case ERROR_FILE_EXISTS:
|
|
if (!fRenameTried)
|
|
{
|
|
int result = CheckForRenameCollision(pcs, OPER_ENTERDIR, pszSource, pszDest, pfdDest, pfd);
|
|
switch (result)
|
|
{
|
|
case IDUNKNOWN:
|
|
break;
|
|
case IDRETRY:
|
|
return EnterDir_Move(pcs, pszSource, pszDest, pfd, pfdDest, TRUE);
|
|
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
return result;
|
|
|
|
case IDNO:
|
|
return result;
|
|
|
|
default:
|
|
return result;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case ERROR_FILENAME_EXCED_RANGE:
|
|
case ERROR_ONLY_IF_CONNECTED:
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
// we're going to recurse in.... if we've not enumerated the children for
|
|
// this folder, set it for delayed enumeration now.
|
|
if (!pcs->dth.pdtnCurrent->pdtnChild)
|
|
{
|
|
pcs->dth.pdtnCurrent->pdtnChild = DTN_DELAYED;
|
|
}
|
|
|
|
if (DTNIsConnected(pcs->dth.pdtnCurrent) && !PathFileExists(pszSource))
|
|
{
|
|
// This can happen if the end-user moved "foo.htm" AND "foo files" together.
|
|
// As a result the connected element "foo files" has already been moved.
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
return(0); //No error! This connected element seems to have been moved.
|
|
}
|
|
|
|
return EnterDir_Copy(pcs, pszSource, pszDest, pfd, pfdDest, FALSE);
|
|
}
|
|
|
|
int EnterDir_Delete(COPY_STATE * pcs, WIN32_FIND_DATA *pfdSrc, LPTSTR pszSource, HDPA *phdpaDeletedFiles)
|
|
{
|
|
int iRet = 0;
|
|
|
|
if (!DTNIsRootNode(pcs->dth.pdtnCurrent))
|
|
{
|
|
// we are not at a root node... when doing a delete this can only mean
|
|
// that we are really nuking the folder. we dont need to enum children
|
|
// because we already did a non-lazy enum at the root node.
|
|
return iRet;
|
|
}
|
|
else if (!pcs->lpua)
|
|
{
|
|
NukeFolder:
|
|
// we are at a root node and we have no undo atom, this means that we
|
|
// really want to nuke this whole dir, so enum the children
|
|
DTForceEnumChildren(&pcs->dth);
|
|
// do a non-layz enum of the children to prevent the progress
|
|
// bar from going back and forth as we recurse down into any subdirs.
|
|
DTEnumChildren(&pcs->dth, pcs, TRUE, DTF_FILES_AND_FOLDERS);
|
|
return iRet;
|
|
}
|
|
|
|
if (DeleteFileBB(pszSource, &iRet, pcs, TRUE, pfdSrc, phdpaDeletedFiles))
|
|
{
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
}
|
|
else
|
|
{
|
|
// DeleteFileBB failed, check iRet to find out why
|
|
|
|
switch (iRet)
|
|
{
|
|
case BBDELETE_PATH_TOO_LONG:
|
|
case BBDELETE_SIZE_TOO_BIG:
|
|
case BBDELETE_NUKE_OFFLINE:
|
|
{
|
|
// This is the case where the folder is too big to fit in the Recycle Bin or the folder
|
|
// is offline. We have no choice but to really nuke it, but we warn the user first since
|
|
// they may have thought that it was being sent to the recycle bin.
|
|
int result = CachedConfirmFileOp(pcs->hwndDlgParent,
|
|
pcs,
|
|
&pcs->cd,
|
|
pcs->nSourceFiles,
|
|
FALSE,
|
|
(iRet == BBDELETE_SIZE_TOO_BIG) ?
|
|
CONFIRM_WONT_RECYCLE_FOLDER :
|
|
((iRet == BBDELETE_NUKE_OFFLINE) ?
|
|
CONFIRM_WONT_RECYCLE_OFFLINE :
|
|
CONFIRM_PATH_TOO_LONG),
|
|
pszSource,
|
|
pfdSrc,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
switch (result)
|
|
{
|
|
case IDNO:
|
|
// user said "please dont really nuke the file"
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
|
|
iRet = IDNO; // Don't put up error message for this case
|
|
|
|
//Because the Delete on this FOLDER is aborted, we can cancel the "Delete"
|
|
// on the corresponding FILE too!
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
{
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
// user canceled the operation
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
|
|
pcs->bAbort = TRUE;
|
|
|
|
//Because the Delete on this FOLDER is cancelled, we can cancel the "Delete"
|
|
// on the corresponding FILE too!
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
{
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDYES:
|
|
default:
|
|
// user said "please nuke the file"
|
|
// assume noerror
|
|
iRet = 0;
|
|
|
|
// set this so the is correct progress animation is displayed
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
// dont allow undo since we are really nuking it (cant bring it back...)
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
|
|
UpdateProgressAnimation(pcs);
|
|
goto NukeFolder;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_CANNOT_DELETE:
|
|
{
|
|
// This is the non-deletable file case. Note: this is an NT only case, and
|
|
// it could be caused by acls or the fact that the file is currently in use.
|
|
// We attemt to really delete the file (which should fail) so we can generate
|
|
// the proper error value
|
|
DWORD dwAttributes = GetFileAttributes(pszSource);
|
|
|
|
if (dwAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
iRet = Win32RemoveDirectory(pszSource);
|
|
}
|
|
else
|
|
{
|
|
iRet = Win32DeleteFile(pszSource);
|
|
}
|
|
|
|
if (!iRet)
|
|
{
|
|
// indeed, the file/folder could not be deleted.
|
|
// Get last error to find out why
|
|
iRet = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
// DeleteFileBB said that it couldn't be deleted, but we just nuked it. We will
|
|
// end up falling into this case when we hit things like Mounted Volumes.
|
|
|
|
// As Obi-Wan would say: "You don't need to see his identification... these aren't
|
|
// the droids you are looking for... He can go about his business... Move along."
|
|
iRet = ERROR_SUCCESS;
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
|
|
// dont allow undo since we reall nuked it (cant bring it back...)
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_FORCE_NUKE:
|
|
{
|
|
// This is the catch-all case. If iRet = BDETETE_FORCE_NUKE, then we just nuke the
|
|
// file without warning.
|
|
|
|
// return noerror so we recurse into this dir and nuke it
|
|
iRet = ERROR_SUCCESS;
|
|
|
|
// set this so the is correct progress animation is displayed
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
// dont allow undo since we are really nuking it (cant bring it back...)
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
|
|
UpdateProgressAnimation(pcs);
|
|
|
|
goto NukeFolder;
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_CANCELLED:
|
|
{
|
|
// user canceled the operation
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
|
|
pcs->bAbort = TRUE;
|
|
|
|
//Because the Delete on this FOLDER is cancelled, we can cancel the "Delete"
|
|
// on the corresponding FILE too!
|
|
if (DTNIsConnectOrigin(pcs->dth.pdtnCurrent))
|
|
{
|
|
pcs->dth.pdtnCurrent->pdtnConnected->fDummy = TRUE;
|
|
}
|
|
}
|
|
|
|
case BBDELETE_UNKNOWN_ERROR:
|
|
default:
|
|
{
|
|
iRet = GetLastError();
|
|
ASSERT(iRet != ERROR_SUCCESS);
|
|
}
|
|
break;
|
|
|
|
}
|
|
} // DeleteFileBB
|
|
|
|
return iRet;
|
|
}
|
|
|
|
BOOL DoFile_Win32DeleteFileWithPidl(LPCTSTR pszFile, SIMPLEPIDLCACHE *pspc)
|
|
{
|
|
LPITEMIDLIST pidlFile = NULL;
|
|
int iRet;
|
|
if (pspc)
|
|
{
|
|
pidlFile = SimplePidlCache_GetFilePidl(pspc, pszFile);
|
|
}
|
|
iRet = Win32DeleteFilePidl(pszFile, pidlFile);
|
|
ILFree(pidlFile);
|
|
return iRet;
|
|
}
|
|
|
|
int DoFile_Delete(COPY_STATE* pcs, WIN32_FIND_DATA *pfdSrc, LPTSTR pszSource, HDPA *phdpaDeletedFiles, BOOL fShouldSuspendEvents)
|
|
{
|
|
int iRet = 0;
|
|
|
|
// if we dont have an undo atom or this isint a root node or if this is a network file
|
|
// then we need to really nuke it
|
|
if (!pcs->lpua || !DTNIsRootNode(pcs->dth.pdtnCurrent) || IsNetDrive(PathGetDriveNumber(pszSource)))
|
|
{
|
|
iRet = DoFile_Win32DeleteFileWithPidl(pszSource, fShouldSuspendEvents ? NULL : &pcs->spc) ? 0 : GetLastError();
|
|
if (!iRet)
|
|
{
|
|
FOUndo_FileReallyDeleted(pszSource);
|
|
}
|
|
}
|
|
else if (!DeleteFileBB(pszSource, &iRet, pcs, FALSE, pfdSrc, phdpaDeletedFiles))
|
|
{
|
|
// DeleteFileBB failed, check iRet to find out why
|
|
|
|
switch (iRet)
|
|
{
|
|
case BBDELETE_SIZE_TOO_BIG:
|
|
case BBDELETE_NUKE_OFFLINE:
|
|
{
|
|
// This is the case where the file is too big to fit in the Recycle Bin. We have no
|
|
// choice but to really nuke it, but we warn the user first since they may have thought
|
|
// that it was being sent to the recycle bin.
|
|
int result = CachedConfirmFileOp(pcs->hwndDlgParent,
|
|
pcs,
|
|
&pcs->cd,
|
|
pcs->nSourceFiles,
|
|
FALSE,
|
|
(iRet == BBDELETE_SIZE_TOO_BIG) ?
|
|
CONFIRM_WONT_RECYCLE_FOLDER :
|
|
CONFIRM_WONT_RECYCLE_OFFLINE,
|
|
pszSource,
|
|
pfdSrc,
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
|
|
switch (result)
|
|
{
|
|
case IDNO:
|
|
// user said "please dont really nuke the file"
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
iRet = IDNO; // Don't put up error message for this case
|
|
// WARNING: It is tempting to mark the corresponding connected folder as dummy here.
|
|
// But, this will not work because currently folders (nodes with children) can not be
|
|
// marked as dummy.
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
// user canceled the operation
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
pcs->bAbort = TRUE;
|
|
// WARNING: It is tempting to mark the corresponding connected folder as dummy here.
|
|
// But, this will not work because currently folders (nodes with children) can not be
|
|
// marked as dummy.
|
|
break;
|
|
|
|
case IDYES:
|
|
default:
|
|
// user said "please nuke the file"
|
|
// set this so the is correct progress animation is displayed
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
// dont allow undo since we are really nuking it
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
|
|
UpdateProgressAnimation(pcs);
|
|
|
|
iRet = DoFile_Win32DeleteFileWithPidl(pszSource, &pcs->spc) ? 0 : GetLastError();
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_CANNOT_DELETE:
|
|
{
|
|
// This is the non-deletable file case. Note: this is an NT only case, and
|
|
// it could be caused by acls or the fact that the file is currently in use.
|
|
// We attemt to really delete the file (which should fail) so we can generate
|
|
// the proper error value
|
|
iRet = Win32DeleteFile(pszSource);
|
|
|
|
if (!iRet)
|
|
{
|
|
// indeed, the file/folder could not be deleted.
|
|
// Get last error to find out why
|
|
iRet = GetLastError();
|
|
}
|
|
else
|
|
{
|
|
// DeleteFileBB said that it couldn't be deleted, but we just nuked it. We will
|
|
// end up falling into this case when we hit things like Mounted Volumes and other
|
|
// reparse points that we can't "recycle".
|
|
|
|
// As Obi-Wan would say: "You don't need to see his identification... these aren't
|
|
// the droids you are looking for... He can go about his business... Move along."
|
|
iRet = ERROR_SUCCESS;
|
|
DTAbortCurrentNode(&pcs->dth); // so we don't recurse down this folder
|
|
|
|
// dont allow undo since we really nuked it (cant bring it back...)
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_FORCE_NUKE:
|
|
{
|
|
// This is the catch-all case. If iRet = BDETETE_FORCE_NUKE, then we just nuke the
|
|
// file without warning.
|
|
|
|
// set this so the is correct progress animation is displayed
|
|
if (pcs)
|
|
{
|
|
pcs->fFlags &= ~FOF_ALLOWUNDO;
|
|
}
|
|
|
|
// dont allow undo since we are going to nuke this file
|
|
if (pcs->lpua)
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
}
|
|
|
|
UpdateProgressAnimation(pcs);
|
|
|
|
iRet = DoFile_Win32DeleteFileWithPidl(pszSource, &pcs->spc) ? 0 : GetLastError();
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_CANCELLED:
|
|
{
|
|
// user canceled the operation
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
pcs->bAbort = TRUE;
|
|
}
|
|
break;
|
|
|
|
case BBDELETE_UNKNOWN_ERROR:
|
|
default:
|
|
{
|
|
iRet = GetLastError();
|
|
ASSERT(iRet != ERROR_SUCCESS);
|
|
}
|
|
break;
|
|
|
|
}
|
|
} // !DeleteFileBB
|
|
|
|
return iRet;
|
|
}
|
|
|
|
int DoFile_Copy(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried)
|
|
{
|
|
/* Now try to copy the file. Do extra error processing only
|
|
in 2 cases:
|
|
1) If a removeable drive is full let the user stick in a new disk
|
|
2) If the path doesn't exist (the user typed in
|
|
and explicit path that doesn't exits) ask if
|
|
we should create it for him. */
|
|
|
|
int ret = FileCopy(pcs, pszSource, pszDest, pfd, fRenameTried);
|
|
|
|
if (ret == ERROR_CANCELLED)
|
|
{
|
|
pcs->bAbort = TRUE;
|
|
return ret;
|
|
}
|
|
|
|
if ((ret & ~ERRORONDEST) == ERROR_FILE_EXISTS)
|
|
{
|
|
if (!fRenameTried)
|
|
{
|
|
int result = CheckForRenameCollision(pcs, OPER_DOFILE, pszSource, pszDest, pfdDest, pfd);
|
|
switch (result)
|
|
{
|
|
case IDUNKNOWN:
|
|
break;
|
|
|
|
case IDRETRY:
|
|
return DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, TRUE);
|
|
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
return result;
|
|
|
|
case IDNO:
|
|
return result;
|
|
|
|
default:
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if ((((ret & ~ERRORONDEST) == ERROR_DISK_FULL) &&
|
|
IsRemovableDrive(DRIVEID(pszDest))) ||
|
|
((ret & ~ERRORONDEST) == ERROR_PATH_NOT_FOUND))
|
|
{
|
|
ULARGE_INTEGER ulFileSize;
|
|
ulFileSize.LowPart = pfd->nFileSizeLow;
|
|
ulFileSize.HighPart = pfd->nFileSizeHigh;
|
|
ret = CopyMoveRetry(pcs, pszDest, ret & ~ERRORONDEST, &ulFileSize);
|
|
if (!ret)
|
|
{
|
|
return DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried);
|
|
}
|
|
else
|
|
{
|
|
pcs->bAbort = TRUE;
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
if (!ret)
|
|
{
|
|
// add to the undo atom
|
|
// if we're doing a copy, only keep track of the highest most
|
|
// level.. unless we're doing a merge sort of copy
|
|
if (pcs->lpua)
|
|
{
|
|
if (DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0);
|
|
}
|
|
|
|
// if we copied in a new desktop ini, send out an update event for the paretn
|
|
if (!lstrcmpi(PathFindFileName(pszDest), c_szDesktopIni))
|
|
{
|
|
TCHAR szDest[MAX_PATH];
|
|
lstrcpyn(szDest, pszDest, ARRAYSIZE(szDest));
|
|
PathRemoveFileSpec(szDest);
|
|
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szDest, NULL);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int DoFile_Move(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried)
|
|
{
|
|
int ret = 0;
|
|
if (PathIsRoot(pszSource))
|
|
{
|
|
return DE_ROOTDIR;
|
|
}
|
|
if (PathIsRoot(pszDest))
|
|
{
|
|
return DE_ROOTDIR | ERRORONDEST;
|
|
}
|
|
|
|
AvoidCurrentDirectory(pszSource);
|
|
|
|
if (PathIsSameRoot(pszSource, pszDest))
|
|
{
|
|
TryAgain:
|
|
ret = Win32MoveFile(pszSource, pszDest, ISDIRFINDDATA(*pfd)) ? 0 : GetLastError();
|
|
|
|
// try to create the destination if it is not there
|
|
if (ret == ERROR_PATH_NOT_FOUND)
|
|
{
|
|
ret = CopyMoveRetry(pcs, pszDest, ret, NULL);
|
|
if (!ret)
|
|
{
|
|
goto TryAgain;
|
|
}
|
|
}
|
|
|
|
if (ret == ERROR_ALREADY_EXISTS)
|
|
{
|
|
if (!fRenameTried)
|
|
{
|
|
int result = CheckForRenameCollision(pcs, OPER_DOFILE, pszSource, pszDest, pfdDest, pfd);
|
|
switch (result)
|
|
{
|
|
case IDUNKNOWN:
|
|
break;
|
|
case IDRETRY:
|
|
fRenameTried = TRUE;
|
|
goto TryAgain;
|
|
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
return result;
|
|
|
|
case IDNO:
|
|
return result;
|
|
|
|
default:
|
|
return result;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((ret == ERROR_SUCCESS) &&
|
|
!SHRestricted(REST_NOENCRYPTONMOVE) &&
|
|
!(pfd->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
!(pfd->dwFileAttributes & FILE_ATTRIBUTE_ENCRYPTED))
|
|
{
|
|
TCHAR szDestDir[MAX_PATH];
|
|
DWORD dwAttribs;
|
|
|
|
// We are moving a file that is NOT encrypted. On Win2k, we need to check to see if this was a move to
|
|
// an encrypted folder. If so, we automatically encrypt the file.
|
|
|
|
lstrcpyn(szDestDir, pszDest, ARRAYSIZE(szDestDir));
|
|
PathRemoveFileSpec(szDestDir);
|
|
dwAttribs = GetFileAttributes(szDestDir);
|
|
|
|
if ((dwAttribs != -1) && (dwAttribs & FILE_ATTRIBUTE_ENCRYPTED))
|
|
{
|
|
// sainity check
|
|
ASSERT(dwAttribs & FILE_ATTRIBUTE_DIRECTORY);
|
|
|
|
// attempt to encrypt the file
|
|
if (!SHEncryptFile(pszDest, TRUE))
|
|
{
|
|
int result = CachedConfirmFileOp(pcs->hwndDlgParent,
|
|
pcs,
|
|
&pcs->cd,
|
|
pcs->nSourceFiles,
|
|
FALSE,
|
|
CONFIRM_FAILED_ENCRYPT,
|
|
pszDest,
|
|
pfd, // since we just moved it, the attibs should be the same as the src
|
|
NULL,
|
|
NULL,
|
|
NULL);
|
|
switch (result)
|
|
{
|
|
case IDCANCEL:
|
|
// user canceled the operation
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
pcs->bAbort = TRUE;
|
|
break;
|
|
|
|
case IDNO:
|
|
// user choose to "restore" the file to its original location
|
|
ret = Win32MoveFile(pszDest, pszSource, ISDIRFINDDATA(*pfd)) ? 0 : GetLastError();
|
|
|
|
case IDYES:
|
|
default:
|
|
// user ignored the error
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (ret == ERROR_SUCCESS)
|
|
{
|
|
if (pcs->lpua && DTNIsRootNode(pcs->dth.pdtnCurrent) && !DTNIsConnected(pcs->dth.pdtnCurrent))
|
|
{
|
|
// add to the undo atom
|
|
FOUndo_AddInfo(pcs->lpua, pszSource, pszDest, 0);
|
|
}
|
|
|
|
// Win32MoveFile on a single-volume leaves the original ACL
|
|
// intact. If necessary, pick up perms from the destination.
|
|
if (pcs->fFlags & FOF_NOCOPYSECURITYATTRIBS)
|
|
{
|
|
ResetFileSecurity(pszDest);
|
|
}
|
|
|
|
// if we copied in a new desktop ini, send out an update event for the paretn
|
|
if (!lstrcmpi(PathFindFileName(pszDest), c_szDesktopIni))
|
|
{
|
|
TCHAR szDest[MAX_PATH];
|
|
lstrcpyn(szDest, pszDest, ARRAYSIZE(szDest));
|
|
PathRemoveFileSpec(szDest);
|
|
SHChangeNotify(SHCNE_UPDATEITEM, SHCNF_PATH, szDest, NULL);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// we must force all copies to go through
|
|
// straight so we can remove the source
|
|
if (DTNIsConnected(pcs->dth.pdtnCurrent) && !PathFileExists(pszSource))
|
|
{
|
|
//This can happen if "foo.htm" and "foo files" were moved by the end-user.
|
|
// The connected file had already been moved and hence this is not an error!
|
|
ret = 0; //No error! That file has been moved already!
|
|
}
|
|
else
|
|
{
|
|
ret = DoFile_Copy(pcs, pszSource, pszDest, pfd, pfdDest, FALSE);
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
int DoFile_Rename(COPY_STATE* pcs, LPTSTR pszSource, LPTSTR pszDest,
|
|
WIN32_FIND_DATA *pfd, WIN32_FIND_DATA * pfdDest, BOOL fRenameTried)
|
|
{
|
|
LPTSTR p = PathFindFileName(pszSource);
|
|
|
|
/* Get raw source and dest paths. Check to make sure the
|
|
paths are the same */
|
|
int ret = !IntlStrEqNI(pszSource, pszDest, (int)(p - pszSource));
|
|
if (ret)
|
|
{
|
|
return DE_DIFFDIR;
|
|
}
|
|
|
|
return DoFile_Move(pcs, pszSource, pszDest, pfd, pfdDest, fRenameTried);
|
|
}
|
|
|
|
|
|
int MoveCopyInitPCS(COPY_STATE * pcs)
|
|
{
|
|
BOOL fMultiDest = FALSE;
|
|
int ret = 0;
|
|
LPTSTR p = NULL;
|
|
TCHAR szDestPath[MAX_PATH];
|
|
|
|
pcs->nSourceFiles = CountFiles(pcs->lpfo->pFrom); // multiple source files?
|
|
|
|
pcs->fProgressOk = TRUE;
|
|
|
|
// skip destination processing if we are deleting files
|
|
if (pcs->lpfo->wFunc != FO_DELETE)
|
|
{
|
|
lstrcpyn(szDestPath, pcs->lpfo->pTo, ARRAYSIZE(szDestPath));
|
|
if (!szDestPath[0]) // NULL dest is same as "."
|
|
{
|
|
szDestPath[0] = TEXT('.');
|
|
szDestPath[1] = 0;
|
|
}
|
|
|
|
if (PathIsInvalid(szDestPath))
|
|
{
|
|
CopyError(pcs, c_szNULL, c_szNULL, DE_INVALIDFILES | ERRORONDEST, pcs->lpfo->wFunc, 0);
|
|
return ERROR_ACCESS_DENIED;
|
|
}
|
|
|
|
if (pcs->lpfo->wFunc == FO_RENAME)
|
|
{
|
|
// don't let them rename multiple files to one single file
|
|
|
|
if ((pcs->nSourceFiles != 1) && !PathIsWild(szDestPath))
|
|
{
|
|
CopyError(pcs, c_szNULL, c_szNULL, DE_MANYSRC1DEST, pcs->lpfo->wFunc, 0);
|
|
return DE_MANYSRC1DEST;
|
|
}
|
|
fMultiDest = TRUE;
|
|
}
|
|
else // FO_COPY or FO_MOVE at this point
|
|
{
|
|
fMultiDest = ((pcs->fFlags & FOF_MULTIDESTFILES) &&
|
|
(pcs->nSourceFiles == CountFiles(pcs->lpfo->pTo)));
|
|
|
|
if (!fMultiDest)
|
|
{
|
|
// for backwards compat.
|
|
// copy c:\foo.bar c:\folder\foo.bar means
|
|
// multi dest if foo.bar doesn't exist.
|
|
// Hack if it is a root we special case this for the offline
|
|
// floppy case...
|
|
if (pcs->nSourceFiles == 1 && !PathIsRoot(szDestPath) &&
|
|
!PathIsDirectory(szDestPath))
|
|
{
|
|
fMultiDest = TRUE;
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
pcs->dth.fMultiDest = fMultiDest;
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
DWORD g_dwStopWatchMode = 0xffffffff; // Shell performance mode
|
|
|
|
// actually this does move/copy/rename/delete
|
|
int MoveCopyDriver(COPY_STATE *pcs)
|
|
{
|
|
int ret;
|
|
WIN32_FIND_DATA fdSrc;
|
|
WIN32_FIND_DATA fdDest;
|
|
HDPA hdpaDeletedFiles = NULL;
|
|
LPSHFILEOPSTRUCT lpfo = pcs->lpfo;
|
|
TCHAR szText[28];
|
|
BOOL bInitialAllowUndo = FALSE;
|
|
DWORD dwLastUpdateTime = 0;
|
|
BOOL fShouldSuspendEvents = FALSE;
|
|
HANDLE hEventRunning;
|
|
|
|
if (g_dwStopWatchMode)
|
|
{
|
|
if (g_dwStopWatchMode == 0xffffffff)
|
|
{
|
|
g_dwStopWatchMode = StopWatchMode(); // Since the stopwatch funcs live in shdocvw, delay this call so we don't load shdocvw until we need to
|
|
}
|
|
|
|
if (g_dwStopWatchMode)
|
|
{
|
|
lstrcpy((LPTSTR)szText, TEXT("Shell "));
|
|
switch (lpfo->wFunc)
|
|
{
|
|
case FO_COPY:
|
|
lstrcat((LPTSTR)szText, TEXT("Copy "));
|
|
break;
|
|
case FO_MOVE:
|
|
lstrcat((LPTSTR)szText, TEXT("Move "));
|
|
break;
|
|
case FO_DELETE:
|
|
lstrcat((LPTSTR)szText, TEXT("Delete"));
|
|
break;
|
|
case FO_RENAME:
|
|
lstrcat((LPTSTR)szText, TEXT("Rename"));
|
|
break;
|
|
default:
|
|
lstrcat((LPTSTR)szText, TEXT("Copy? "));
|
|
break;
|
|
}
|
|
lstrcat((LPTSTR)szText, TEXT(": Start"));
|
|
StopWatch_Start(SWID_COPY, (LPCTSTR)szText, SPMODE_SHELL | SPMODE_DEBUGOUT);
|
|
}
|
|
}
|
|
|
|
// start by assuming an error. Non-zero means an error has occured. If we don't
|
|
// start with this assumption then we will return success if MoveCopyInitPCS fails.
|
|
ret = ERROR_GEN_FAILURE;
|
|
|
|
if (!ValidFilenames(lpfo->pFrom))
|
|
{
|
|
CopyError(pcs, c_szNULL, c_szNULL, DE_INVALIDFILES, lpfo->wFunc, 0);
|
|
return ERROR_ACCESS_DENIED;
|
|
}
|
|
|
|
StartCopyEngine(&hEventRunning);
|
|
|
|
// Check the pcs destination directory to make sure it is valid for the given source file list
|
|
if (MoveCopyInitPCS(pcs))
|
|
{
|
|
goto ExitLoop; // Destination is invalid so we bail out
|
|
}
|
|
|
|
// Build a tree where each node is a source file, a dest file, and an operation to perform
|
|
ret = DTBuild(pcs);
|
|
if (ret)
|
|
{
|
|
goto ShowMessageBox;
|
|
}
|
|
|
|
// Speed optimization: for a delete, sending all FSNotifies really bogs down the system,
|
|
// so we skip it and rely on the file system notifies.
|
|
if ((lpfo->wFunc == FO_DELETE || lpfo->wFunc == FO_MOVE) && pcs->dth.dtAll.dwFiles > 100)
|
|
{
|
|
// Only suspend notifies for local moves
|
|
if (lpfo->wFunc == FO_MOVE)
|
|
{
|
|
if (lpfo->pTo)
|
|
{
|
|
int idDrive = PathGetDriveNumber(lpfo->pFrom);
|
|
if (idDrive == PathGetDriveNumber(lpfo->pTo) && !IsNetDrive(idDrive))
|
|
{
|
|
fShouldSuspendEvents = TRUE;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
fShouldSuspendEvents = TRUE;
|
|
}
|
|
}
|
|
|
|
if (fShouldSuspendEvents)
|
|
{
|
|
// SuspendSHNotify can fail if another thread is using it. Only one thread at a time can suspend notify.
|
|
fShouldSuspendEvents = SuspendSHNotify();
|
|
}
|
|
|
|
|
|
// save off the initial state of the allowundo flag
|
|
if (pcs->fFlags & FOF_ALLOWUNDO)
|
|
{
|
|
bInitialAllowUndo = TRUE;
|
|
}
|
|
|
|
// When first starting, we assume that stream loss is possible until we prove
|
|
// otherwise for the current directory. This gets reset to true each time we
|
|
// enter a new dir via EnterDir_Move or EnterDir_Copy
|
|
|
|
pcs->bStreamLossPossible = TRUE;
|
|
|
|
for (;;)
|
|
{
|
|
BOOL bUpdateAnimation = FALSE;
|
|
int result;
|
|
DWORD dwTickCount;
|
|
BOOL bTimeToUpdate = FALSE;
|
|
|
|
pcs->dth.oper = DTGoToNextNode(&pcs->dth,pcs);
|
|
|
|
dwTickCount = GetTickCount();
|
|
if ((dwTickCount - dwLastUpdateTime) > 10)
|
|
{
|
|
dwLastUpdateTime = dwTickCount;
|
|
bTimeToUpdate = TRUE;
|
|
}
|
|
|
|
if ((pcs->dth.oper & OPER_MASK) == OPER_ERROR)
|
|
{
|
|
CopyError(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, LOBYTE(pcs->dth.oper), pcs->lpfo->wFunc, OPER_DOFILE);
|
|
// If the directory is copied but a file inside that directory could not
|
|
// be copied because of long filename, check to see if this is
|
|
// a connected element. If so, invoke undo, sothat we getback the orginal html file
|
|
// in the same place as the associated folder.
|
|
if ((pcs->dth.oper == (OPER_ERROR | DE_INVALIDFILES)) &&
|
|
(DTNIsConnected(pcs->dth.pdtnCurrent)))
|
|
{
|
|
if (pcs->lpua)
|
|
{
|
|
pcs->lpua->foFlags |= FOF_NOCONFIRMATION;
|
|
FOUndo_Invoke(pcs->lpua);
|
|
pcs->lpua = NULL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!pcs->dth.oper || pcs->bAbort) // all done?
|
|
{
|
|
break;
|
|
}
|
|
|
|
if (DTNIsRootNode(pcs->dth.pdtnCurrent) && (pcs->dth.oper != OPER_LEAVEDIR))
|
|
{
|
|
int iDrive;
|
|
|
|
// check to see if we switched between doing a move to
|
|
// recycle bin and a true delete (this would happen when
|
|
// there was an object that was too big for the recycle bin)
|
|
if (!(pcs->fFlags & FOF_ALLOWUNDO) && bInitialAllowUndo)
|
|
{
|
|
// reset the allowundo flag since we have a new root node, and we
|
|
// want to attempt to send it to the recycle bin
|
|
pcs->fFlags |= FOF_ALLOWUNDO;
|
|
|
|
// we delay to update the progress animation till we are basically
|
|
// done, which allows us to keep the progress and animation in sync
|
|
bUpdateAnimation = TRUE;
|
|
}
|
|
|
|
pcs->fMerge = FALSE;
|
|
pcs->fFromCDRom = FALSE;
|
|
|
|
// Check source for being a CDRom
|
|
iDrive = PathGetDriveNumber(pcs->dth.szSrcPath);
|
|
if (-1 != iDrive)
|
|
{
|
|
TCHAR szDrive[4];
|
|
if (DRIVE_CDROM == GetDriveType(PathBuildRoot(szDrive, iDrive)))
|
|
{
|
|
pcs->fFromCDRom = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
DTGetWin32FindData(pcs->dth.pdtnCurrent, &fdSrc);
|
|
fdDest.dwFileAttributes = 0;
|
|
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("MoveCopyDriver(): Oper %x From(%s) To(%s)"), pcs->dth.oper, (LPCTSTR)pcs->dth.szSrcPath, (LPCTSTR)pcs->dth.szDestPath);
|
|
|
|
// some operation that may effect the destination (have a collision)
|
|
if ((pcs->lpfo->wFunc != FO_DELETE) && (pcs->dth.oper != OPER_LEAVEDIR))
|
|
{
|
|
// this compare needs to be case sensitive, and locale insensitive
|
|
if (!StrCmpC(pcs->dth.szSrcPath, pcs->dth.szDestPath) &&
|
|
!(pcs->fFlags & FOF_RENAMEONCOLLISION))
|
|
{
|
|
// Source and dest are the same file, and name collision
|
|
// resolution is not turned on, so we just return an error.
|
|
|
|
// TODO: Show the error dialog here and allow for SKIP
|
|
|
|
ret = DE_SAMEFILE;
|
|
goto ShowMessageBox;
|
|
}
|
|
}
|
|
|
|
result = AllConfirmations(pcs, &fdSrc, pcs->dth.oper, pcs->lpfo->wFunc, pcs->dth.szSrcPath,
|
|
pcs->dth.szDestPath, bTimeToUpdate, &fdDest, &ret);
|
|
switch (result)
|
|
{
|
|
case IDNO:
|
|
DTAbortCurrentNode(&pcs->dth);
|
|
lpfo->fAnyOperationsAborted = TRUE;
|
|
continue;
|
|
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
goto ExitLoop;
|
|
|
|
case IDYES:
|
|
break;
|
|
|
|
default:
|
|
ret = result;
|
|
goto ShowMessageBox;
|
|
}
|
|
|
|
/* Now determine which operation to perform */
|
|
|
|
switch (pcs->dth.oper | pcs->lpfo->wFunc)
|
|
{
|
|
// Note that ENTERDIR is not done for a root, even though LEAVEDIR is
|
|
case OPER_ENTERDIR | FO_MOVE: // Create dest, verify source delete
|
|
ret = EnterDir_Move(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE);
|
|
break;
|
|
|
|
case OPER_ENTERDIR | FO_COPY: // Create destination directory
|
|
ret = EnterDir_Copy(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE);
|
|
break;
|
|
|
|
case OPER_LEAVEDIR | FO_MOVE:
|
|
case OPER_LEAVEDIR | FO_DELETE:
|
|
ret = LeaveDir_Delete(pcs, pcs->dth.szSrcPath);
|
|
break;
|
|
|
|
case OPER_LEAVEDIR | FO_COPY:
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_COPY:
|
|
ret = DoFile_Copy(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE);
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_RENAME:
|
|
ret = DoFile_Rename(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE);
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_MOVE:
|
|
ret = DoFile_Move(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, &fdSrc, &fdDest, FALSE);
|
|
break;
|
|
|
|
case OPER_ENTERDIR | FO_DELETE:
|
|
ret = EnterDir_Delete(pcs, &fdSrc, pcs->dth.szSrcPath, &hdpaDeletedFiles);
|
|
break;
|
|
|
|
case OPER_DOFILE | FO_DELETE:
|
|
ret = DoFile_Delete(pcs, &fdSrc, pcs->dth.szSrcPath, &hdpaDeletedFiles, fShouldSuspendEvents);
|
|
break;
|
|
|
|
default:
|
|
DebugMsg(DM_ERROR, TEXT("Invalid file operation"));
|
|
ret = 0; // internal error
|
|
break;
|
|
} // switch (pcs->dth.oper | pcs->lpfo->wFunc)
|
|
|
|
if (pcs->bAbort)
|
|
break;
|
|
|
|
if (ret == IDNO)
|
|
{
|
|
pcs->lpfo->fAnyOperationsAborted = TRUE;
|
|
}
|
|
else if (ret)
|
|
{ // any errors?
|
|
ShowMessageBox:
|
|
// If source file is a connected item and is not found, that means that
|
|
// we have already moved/deleted/renamed it. So, don't report that as error!
|
|
if ((!pcs->dth.pdtnCurrent) || (!pcs->dth.pdtnCurrent->fConnectedElement) ||
|
|
((ret != ERROR_FILE_NOT_FOUND) && (ret != ERROR_PATH_NOT_FOUND)))
|
|
{
|
|
CopyError(pcs, pcs->dth.szSrcPath, pcs->dth.szDestPath, ret, pcs->lpfo->wFunc, pcs->dth.oper);
|
|
|
|
// If the directory is copied but a file inside that directory could not
|
|
// be copied because of long filename, check to see if this is
|
|
// a connected element. If so, invoke undo, sothat we getback the orginal html file
|
|
// in the same place as the associated folder.
|
|
if ((ret == ERROR_FILENAME_EXCED_RANGE) &&
|
|
(DTNIsConnected(pcs->dth.pdtnCurrent)))
|
|
{
|
|
if (pcs->lpua)
|
|
{
|
|
pcs->lpua->foFlags |= FOF_NOCONFIRMATION;
|
|
FOUndo_Invoke(pcs->lpua);
|
|
pcs->lpua = NULL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (bTimeToUpdate)
|
|
{
|
|
// perform the delayed update of the dialog
|
|
if (bUpdateAnimation)
|
|
{
|
|
UpdateProgressAnimation(pcs);
|
|
bUpdateAnimation = FALSE;
|
|
}
|
|
// We check to see if we are finished here (instead of at the
|
|
// start) since we want to keep the progress a step behind what
|
|
// we are doing to ensure we have the correct progress animation
|
|
// and text (since FOQueryAbort updates the progress text)
|
|
if (FOQueryAbort(pcs))
|
|
break;
|
|
}
|
|
}
|
|
|
|
ExitLoop:
|
|
|
|
// this happens in error cases where we broke out of the pcr loop
|
|
// without hitting the end
|
|
|
|
lpfo->hNameMappings = pcs->dth.hdsaRenamePairs;
|
|
|
|
DTCleanup(&pcs->dth);
|
|
BBFinishDelete(hdpaDeletedFiles);
|
|
|
|
if (fShouldSuspendEvents)
|
|
{
|
|
ResumeSHNotify();
|
|
|
|
if (lpfo->wFunc == FO_DELETE)
|
|
{
|
|
TCHAR szBBPath[MAX_PATH];
|
|
|
|
// Since we probably blew away any chance at having the FSNotify work, make sure
|
|
// we update item for this path... we can send the message on any drive since
|
|
// the bitbucket listens for changes on all drives.
|
|
DriveIDToBBPath(DriveIDFromBBPath(lpfo->pFrom), szBBPath);
|
|
SHChangeNotify(SHCNE_UPDATEDIR, SHCNF_PATH, szBBPath, NULL);
|
|
}
|
|
}
|
|
|
|
|
|
if (g_dwStopWatchMode)
|
|
{
|
|
lstrcpy((LPTSTR)&szText[12], TEXT(": Stop "));
|
|
StopWatch_Stop(SWID_COPY, (LPCTSTR)szText, SPMODE_SHELL | SPMODE_DEBUGOUT);
|
|
}
|
|
|
|
EndCopyEngine(hEventRunning);
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
void SetWindowTextFromRes(HWND hwnd, int id)
|
|
{
|
|
TCHAR szTemp[80];
|
|
|
|
LoadString(HINST_THISDLL, id, szTemp, ARRAYSIZE(szTemp));
|
|
SetWindowText(hwnd, szTemp);
|
|
}
|
|
|
|
int CountProgressPoints(COPY_STATE *pcs, PDIRTOTALS pdt)
|
|
{
|
|
// point value for each item
|
|
int iTotal = 0;
|
|
UINT uSize = pcs->uSize;
|
|
|
|
if (!uSize)
|
|
{
|
|
uSize = 32*1024;
|
|
}
|
|
// now add it up.
|
|
iTotal += (UINT)((pdt->liSize.QuadPart/uSize) * pcs->dth.iSizePoints);
|
|
iTotal += pdt->dwFiles * pcs->dth.iFilePoints;
|
|
iTotal += pdt->dwFolders * pcs->dth.iFolderPoints;
|
|
|
|
return iTotal;
|
|
}
|
|
|
|
void UpdateProgressDialog(COPY_STATE* pcs)
|
|
{
|
|
int iRange; // from 0 to iRange
|
|
int iPos; // how much is done.
|
|
|
|
if (pcs->fProgressOk)
|
|
{
|
|
|
|
if (pcs->dth.dtAll.fChanged)
|
|
{
|
|
pcs->dth.dtAll.fChanged = FALSE;
|
|
iRange = CountProgressPoints(pcs, &pcs->dth.dtAll);
|
|
SendProgressMessage(pcs, PBM_SETRANGE32, 0, iRange);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("UpdateProgressDialog iRange = %d "), iRange);
|
|
}
|
|
|
|
if (pcs->dth.dtDone.fChanged)
|
|
{
|
|
pcs->dth.dtDone.fChanged = FALSE;
|
|
iPos = CountProgressPoints(pcs, &pcs->dth.dtDone);
|
|
SendProgressMessage(pcs, PBM_SETPOS, iPos, 0);
|
|
DebugMsg(TF_DEBUGCOPY, TEXT("UpdateProgressDialog iPos = %d "), iPos);
|
|
}
|
|
}
|
|
}
|
|
|
|
// NOTE: !! do NOT refrence pcs->lpfo anywhere in this dialog proc !!
|
|
//
|
|
// It can be freed while we are still running. If you need to get information from it,
|
|
// add a new member to the FOUITHREADINFO struct and copy the value from the pcs->lpfo
|
|
// into the member (while holding the critsec) right before we create this dlg.
|
|
BOOL_PTR CALLBACK FOFProgressDlgProc(HWND hDlg, UINT wMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
FOUITHREADINFO* pfouiti = (FOUITHREADINFO*)GetWindowLongPtr(hDlg, DWLP_USER);
|
|
COPY_STATE *pcs = (pfouiti ? pfouiti->pcs : NULL);
|
|
|
|
if (WM_INITDIALOG == wMsg)
|
|
{
|
|
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
|
|
|
|
pfouiti = (FOUITHREADINFO*)lParam;
|
|
pcs = pfouiti->pcs;
|
|
|
|
SetWindowTextFromRes(hDlg, IDS_ACTIONTITLE + pfouiti->wFunc);
|
|
|
|
if (pcs->fFlags & FOF_SIMPLEPROGRESS)
|
|
{
|
|
TCHAR szFrom[MAX_PATH];
|
|
if (pcs->lpszProgressTitle)
|
|
{
|
|
if (IS_INTRESOURCE(pcs->lpszProgressTitle))
|
|
{
|
|
LoadString(HINST_THISDLL, PtrToUlong(pcs->lpszProgressTitle), szFrom, ARRAYSIZE(szFrom));
|
|
pcs->lpszProgressTitle = szFrom;
|
|
}
|
|
SetDlgItemText(hDlg, IDD_NAME, pcs->lpszProgressTitle);
|
|
// null it so we only set it once
|
|
pcs->lpszProgressTitle = NULL;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
if (pcs)
|
|
{
|
|
switch (wMsg)
|
|
{
|
|
case WM_TIMER:
|
|
if (IsWindowEnabled(hDlg))
|
|
SetProgressTime(pcs);
|
|
break;
|
|
|
|
case WM_SHOWWINDOW:
|
|
if (wParam)
|
|
{
|
|
int idAni;
|
|
HWND hwndAnimation;
|
|
|
|
ASSERT(pfouiti->wFunc >= FO_MOVE && pfouiti->wFunc <= FO_DELETE);
|
|
ASSERT(FO_COPY==FO_MOVE+1);
|
|
ASSERT(FO_DELETE==FO_COPY+1);
|
|
ASSERT(IDA_FILECOPY==IDA_FILEMOVE+1);
|
|
ASSERT(IDA_FILEDEL ==IDA_FILECOPY+1);
|
|
|
|
switch (pfouiti->wFunc)
|
|
{
|
|
case FO_DELETE:
|
|
if (pfouiti->bIsEmptyRBOp)
|
|
{
|
|
idAni = IDA_FILENUKE;
|
|
break;
|
|
}
|
|
else if (!(pcs->fFlags & FOF_ALLOWUNDO))
|
|
{
|
|
idAni = IDA_FILEDELREAL;
|
|
break;
|
|
}
|
|
// else fall through
|
|
|
|
default:
|
|
idAni = (IDA_FILEMOVE + (int)pfouiti->wFunc - FO_MOVE);
|
|
}
|
|
|
|
hwndAnimation = GetDlgItem(hDlg,IDD_ANIMATE);
|
|
|
|
Animate_Open(hwndAnimation, IntToPtr(idAni));
|
|
|
|
SetProp(hwndAnimation, TEXT("AnimationID"), IntToPtr(idAni));
|
|
|
|
// a timer every MS_TIMESLICE seconds to update the progress time estimate
|
|
SetTimer(hDlg, 1, MS_TIMESLICE, NULL);
|
|
}
|
|
break;
|
|
|
|
case WM_ENABLE:
|
|
if (wParam)
|
|
{
|
|
if (pcs->dwPreviousTime)
|
|
{
|
|
// if we're enabling it, set the previous time to now
|
|
// because no action has happened while we were disabled
|
|
pcs->dwPreviousTime = GetTickCount();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SetProgressTime(pcs);
|
|
}
|
|
PauseAnimation(pcs, wParam == 0);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (GET_WM_COMMAND_ID(wParam, lParam))
|
|
{
|
|
case IDCANCEL:
|
|
pcs->bAbort = TRUE;
|
|
ShowWindow(hDlg, SW_HIDE);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case PDM_SHUTDOWN:
|
|
// Make sure this window is shown before telling the user there
|
|
// is a problem
|
|
// ignore FOF_NOERRORUI here because of the nature of the situation
|
|
ShellMessageBox(HINST_THISDLL, hDlg, MAKEINTRESOURCE(IDS_CANTSHUTDOWN),
|
|
NULL, MB_OK | MB_ICONEXCLAMATION | MB_SETFOREGROUND);
|
|
break;
|
|
|
|
case PDM_NOOP:
|
|
// a dummy id that we can take so that folks can post to us and make
|
|
// us go through the main loop
|
|
break;
|
|
|
|
case PDM_UPDATE:
|
|
pcs->dth.fChangePosted = FALSE;
|
|
UpdateProgressDialog(pcs);
|
|
break;
|
|
|
|
case WM_QUERYENDSESSION:
|
|
// Post a message telling the dialog to show the "We can't shutdown now"
|
|
// dialog and return to USER right away, so we don't have to worry about
|
|
// the user not clicking the OK button before USER puts up its "this
|
|
// app didn't respond" dialog
|
|
PostMessage(hDlg, PDM_SHUTDOWN, 0, 0);
|
|
|
|
// Make sure the dialog box procedure returns FALSE
|
|
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, FALSE);
|
|
return TRUE;
|
|
|
|
default:
|
|
return FALSE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
int CALLBACK FOUndo_FileReallyDeletedCallback(UNDOATOM *lpua, LPARAM lParam)
|
|
{
|
|
LPTSTR * ppsz = (LPTSTR*)lParam;
|
|
// this is our signal to nuke the rest
|
|
if (!*ppsz)
|
|
return EUA_DELETE;
|
|
|
|
switch (lpua->uType)
|
|
{
|
|
case IDS_RENAME:
|
|
case IDS_COPY:
|
|
case IDS_MOVE:
|
|
case IDS_DELETE:
|
|
{
|
|
LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData;
|
|
HDPA hdpa = lpud->hdpa;
|
|
// only the destinations matter.
|
|
int i, iMax = DPA_GetPtrCount(hdpa);
|
|
for (i = 1; i <= iMax; i += 2)
|
|
{
|
|
LPTSTR lpsz = DPA_GetPtr(hdpa, i);
|
|
if (lstrcmpi(lpsz, *ppsz) == 0)
|
|
{
|
|
*ppsz = NULL;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
// this is our signal to nuke the rest
|
|
if (!*ppsz)
|
|
return EUA_DELETE;
|
|
else
|
|
return EUA_DONOTHING;
|
|
}
|
|
|
|
// someone really really deleted a file. make sure we no longer have
|
|
// any undo information pointing to it.
|
|
void FOUndo_FileReallyDeleted(LPTSTR lpszFile)
|
|
{
|
|
EnumUndoAtoms(FOUndo_FileReallyDeletedCallback, (LPARAM)&lpszFile);
|
|
}
|
|
|
|
|
|
int CALLBACK FOUndo_FileRestoredCallback(UNDOATOM *lpua, LPARAM lParam)
|
|
{
|
|
LPTSTR psz = (LPTSTR)lParam;
|
|
|
|
switch (lpua->uType)
|
|
{
|
|
case IDS_DELETE:
|
|
{
|
|
LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData;
|
|
HDPA hdpa = lpud->hdpa;
|
|
LPTSTR lpsz;
|
|
int i, iMax;
|
|
|
|
ASSERT(hdpa);
|
|
// only the destinations matter.
|
|
iMax = DPA_GetPtrCount(hdpa);
|
|
for (i = 1; i <= iMax; i += 2)
|
|
{
|
|
lpsz = DPA_GetPtr(hdpa, i);
|
|
if (lstrcmpi(lpsz, psz) == 0)
|
|
{
|
|
ENTERCRITICAL;
|
|
|
|
Str_SetPtr(&lpsz, NULL);
|
|
lpsz = DPA_GetPtr(hdpa, i - 1);
|
|
Str_SetPtr(&lpsz, NULL);
|
|
DPA_DeletePtr(hdpa, i);
|
|
DPA_DeletePtr(hdpa, i - 1);
|
|
|
|
LEAVECRITICAL;
|
|
|
|
if (DPA_GetPtrCount(hdpa))
|
|
return EUA_ABORT;
|
|
else
|
|
return EUA_DELETEABORT;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
return EUA_DONOTHING;
|
|
}
|
|
|
|
// this means someone restored a file (via ui in the bitbucket)
|
|
// so we need to clean up the undo info.
|
|
void FOUndo_FileRestored(LPCTSTR lpszFile)
|
|
{
|
|
EnumUndoAtoms(FOUndo_FileRestoredCallback, (LPARAM)lpszFile);
|
|
}
|
|
|
|
|
|
void FOUndo_AddInfo(UNDOATOM *lpua, LPTSTR lpszSrc, LPTSTR lpszDest, DWORD dwAttributes)
|
|
{
|
|
HDPA hdpa;
|
|
LPTSTR lpsz = NULL;
|
|
int i;
|
|
LPFOUNDODATA lpud;
|
|
|
|
if (lpua->lpData == (void *)-1)
|
|
return;
|
|
|
|
if (!lpua->lpData)
|
|
{
|
|
lpua->lpData = LocalAlloc(LPTR, sizeof(FOUNDODATA));
|
|
if (!lpua->lpData)
|
|
return;
|
|
|
|
((LPFOUNDODATA)lpua->lpData)->hdpa = (void *)DPA_Create(4);
|
|
}
|
|
|
|
lpud = lpua->lpData;
|
|
|
|
hdpa = lpud->hdpa;
|
|
if (!hdpa)
|
|
return;
|
|
|
|
// if it's a directory that got deleted, we're just going to save it's
|
|
// attributes so that we can recreate it later.
|
|
// directories do NOT get moved into the wastebasket
|
|
if ((lpua->uType == IDS_DELETE) && (dwAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
FOUNDO_DELETEDFILEINFO dfi;
|
|
if (!lpud->hdsa)
|
|
{
|
|
lpud->hdsa = DSA_Create(sizeof(FOUNDO_DELETEDFILEINFO), 4);
|
|
if (!lpud->hdsa)
|
|
return;
|
|
}
|
|
|
|
Str_SetPtr(&lpsz, lpszSrc);
|
|
dfi.lpszName = lpsz;
|
|
dfi.dwAttributes = dwAttributes;
|
|
DSA_AppendItem(lpud->hdsa, &dfi);
|
|
}
|
|
else
|
|
{
|
|
Str_SetPtr(&lpsz, lpszSrc);
|
|
if (!lpsz)
|
|
return;
|
|
|
|
if ((i = DPA_AppendPtr(hdpa, lpsz)) == -1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
lpsz = NULL;
|
|
Str_SetPtr(&lpsz, lpszDest);
|
|
if (!lpsz ||
|
|
DPA_AppendPtr(hdpa, lpsz) == -1)
|
|
{
|
|
DPA_DeletePtr(hdpa, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
LPTSTR DPA_ToFileList(HDPA hdpa, int iStart, int iEnd, int iIncr)
|
|
{
|
|
LPTSTR lpsz;
|
|
LPTSTR lpszReturn;
|
|
int ichSize;
|
|
int ichTemp;
|
|
int i;
|
|
|
|
// undo copy by deleting destinations
|
|
lpszReturn = (LPTSTR)(void*)LocalAlloc(LPTR, 1);
|
|
if (!lpszReturn)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
ichSize = 1;
|
|
// build the NULL separated file list
|
|
// go from the end to the front.. restore in reverse order!
|
|
for (i = iEnd; i >= iStart ; i -= iIncr)
|
|
{
|
|
LPTSTR psz;
|
|
|
|
lpsz = DPA_GetPtr(hdpa, i);
|
|
ASSERT(lpsz);
|
|
|
|
ichTemp = ichSize - 1;
|
|
|
|
ichSize += (lstrlen(lpsz) + 1);
|
|
psz = (LPTSTR)(void*)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR),
|
|
LMEM_MOVEABLE|LMEM_ZEROINIT);
|
|
if (!psz)
|
|
{
|
|
break;
|
|
}
|
|
lpszReturn = psz;
|
|
lstrcpy(lpszReturn + ichTemp, lpsz);
|
|
}
|
|
|
|
if ((i + iIncr) != iStart)
|
|
{
|
|
LocalFree((HLOCAL)lpszReturn);
|
|
lpszReturn = NULL;
|
|
}
|
|
return lpszReturn;
|
|
}
|
|
|
|
// from dpa to:
|
|
// 'file 1', 'file 2' and 'file 3'
|
|
LPTSTR DPA_ToQuotedFileList(HDPA hdpa, int iStart, int iEnd, int iIncr)
|
|
{
|
|
LPTSTR lpsz;
|
|
LPTSTR lpszReturn;
|
|
TCHAR szFile[MAX_PATH];
|
|
int ichSize;
|
|
int ichTemp;
|
|
int i;
|
|
SHELLSTATE ss;
|
|
|
|
// undo copy by deleting destinations
|
|
lpszReturn = (LPTSTR)(void*)LocalAlloc(LPTR, 1);
|
|
if (!lpszReturn)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS|SSF_SHOWALLOBJECTS, FALSE);
|
|
|
|
ichSize = 1;
|
|
// build the quoted file list
|
|
for (i = iStart; i < iEnd ; i += iIncr)
|
|
{
|
|
LPTSTR psz;
|
|
|
|
ichTemp = ichSize - 1;
|
|
|
|
// get the name (filename only without extension)
|
|
lpsz = DPA_GetPtr(hdpa, i);
|
|
lstrcpy(szFile, PathFindFileName(lpsz));
|
|
if (!ss.fShowExtensions)
|
|
{
|
|
PathRemoveExtension(szFile);
|
|
}
|
|
|
|
// grow the buffer and add it in
|
|
ichSize += lstrlen(szFile) + 2;
|
|
psz = (LPTSTR)(void*)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR),
|
|
LMEM_MOVEABLE|LMEM_ZEROINIT);
|
|
if (!psz)
|
|
{
|
|
LocalFree(lpszReturn);
|
|
lpszReturn = NULL;
|
|
break;
|
|
}
|
|
lpszReturn = psz;
|
|
|
|
// is it too long?
|
|
if (ichSize >= MAX_PATH)
|
|
{
|
|
lstrcat(lpszReturn, c_szEllipses);
|
|
return lpszReturn;
|
|
}
|
|
else
|
|
{
|
|
StrCatBuff(lpszReturn, TEXT("'"), ichSize); //A single quote BEFORE the filename.
|
|
StrCatBuff(lpszReturn, szFile, ichSize);
|
|
StrCatBuff(lpszReturn, TEXT("'"), ichSize); //A single quote AFTER the filename.
|
|
}
|
|
|
|
ASSERT(ichSize == ichTemp + (lstrlen(lpszReturn + ichTemp) + 1));
|
|
ichTemp = ichSize - 1;
|
|
|
|
// check to see if we need the "and"
|
|
if ((i + iIncr) < iEnd)
|
|
{
|
|
TCHAR szTemp[40];
|
|
int id;
|
|
|
|
ichSize += 40;
|
|
|
|
if ((i + (iIncr*2)) >= iEnd)
|
|
{
|
|
id = IDS_SPACEANDSPACE;
|
|
}
|
|
else
|
|
{
|
|
id = IDS_COMMASPACE;
|
|
}
|
|
|
|
psz = (LPTSTR)LocalReAlloc((HLOCAL)lpszReturn, ichSize * sizeof(TCHAR),
|
|
LMEM_MOVEABLE|LMEM_ZEROINIT);
|
|
if (!psz)
|
|
{
|
|
LocalFree(lpszReturn);
|
|
lpszReturn = NULL;
|
|
break;
|
|
}
|
|
lpszReturn = psz;
|
|
LoadString(HINST_THISDLL, id, szTemp, ARRAYSIZE(szTemp));
|
|
StrCatBuff(lpszReturn, szTemp, ichSize);
|
|
ichSize = ichTemp + (lstrlen(lpszReturn + ichTemp) + 1);
|
|
}
|
|
}
|
|
return lpszReturn;
|
|
}
|
|
|
|
|
|
void CALLBACK FOUndo_GetText(UNDOATOM *lpua, TCHAR * buffer, int type)
|
|
{
|
|
LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData;
|
|
HDPA hdpa = lpud->hdpa;
|
|
|
|
if (type == UNDO_MENUTEXT)
|
|
{
|
|
LoadString(HINST_THISDLL, lpua->uType, buffer, MAX_PATH);
|
|
}
|
|
else
|
|
{
|
|
TCHAR szTemplate[80];
|
|
// thank god for growable stacks..
|
|
TCHAR szFile1[MAX_PATH];
|
|
TCHAR szFile2[MAX_PATH];
|
|
TCHAR szFile1Short[30];
|
|
TCHAR szFile2Short[30];
|
|
TCHAR *lpszFile1;
|
|
TCHAR *lpszFile2;
|
|
|
|
// get the template
|
|
LoadString(HINST_THISDLL, lpua->uType + (IDS_UNDO_FILEOPHELP - IDS_UNDO_FILEOP), szTemplate, ARRAYSIZE(szTemplate));
|
|
|
|
if (lpua->uType == IDS_RENAME)
|
|
{
|
|
SHELLSTATE ss;
|
|
LPTSTR pszTemp;
|
|
|
|
// fill in the file names
|
|
lpszFile1 = DPA_GetPtr(hdpa, 0);
|
|
lpszFile2 = DPA_GetPtr(hdpa, 1);
|
|
lstrcpy(szFile1, PathFindFileName(lpszFile1));
|
|
lstrcpy(szFile2, PathFindFileName(lpszFile2));
|
|
|
|
SHGetSetSettings(&ss, SSF_SHOWEXTENSIONS, FALSE);
|
|
if (!ss.fShowExtensions)
|
|
{
|
|
PathRemoveExtension(szFile1);
|
|
PathRemoveExtension(szFile2);
|
|
}
|
|
|
|
// length sanity check
|
|
// don't just whack "..." at 30 bytes into szFile1 since that may be a dbcs character...
|
|
PathCompactPathEx(szFile1Short, szFile1, ARRAYSIZE(szFile1Short), 0);
|
|
PathCompactPathEx(szFile2Short, szFile2, ARRAYSIZE(szFile2Short), 0);
|
|
|
|
pszTemp = ShellConstructMessageString(HINST_THISDLL, szTemplate, szFile1Short, szFile2Short);
|
|
if (pszTemp)
|
|
{
|
|
StrCpyN(buffer, pszTemp, MAX_PATH);
|
|
LocalFree(pszTemp);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TCHAR *lpszFile1;
|
|
HDPA hdpaFull = hdpa;
|
|
// in the case of delete (where ther's an hdsa)
|
|
// we need to add in the names of folders deleted
|
|
// we do this by cloning the hdpa and tacking on our names.
|
|
if (lpud->hdsa)
|
|
{
|
|
hdpaFull = DPA_Clone(hdpa, NULL);
|
|
if (hdpaFull)
|
|
{
|
|
int iMax;
|
|
int i;
|
|
LPFOUNDO_DELETEDFILEINFO lpdfi;
|
|
iMax = DSA_GetItemCount(lpud->hdsa);
|
|
for (i = 0; i < iMax; i++)
|
|
{
|
|
lpdfi = DSA_GetItemPtr(lpud->hdsa, i);
|
|
DPA_AppendPtr(hdpaFull, lpdfi->lpszName);
|
|
DPA_AppendPtr(hdpaFull, lpdfi->lpszName);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hdpaFull = hdpa;
|
|
}
|
|
}
|
|
lpszFile1 = DPA_ToQuotedFileList(hdpaFull, 0, DPA_GetPtrCount(hdpaFull), 2);
|
|
wnsprintf(buffer, MAX_PATH, szTemplate, lpszFile1);
|
|
LocalFree((HLOCAL)lpszFile1);
|
|
if (hdpaFull != hdpa)
|
|
{
|
|
DPA_Destroy(hdpaFull);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CALLBACK FOUndo_Release(UNDOATOM *lpua)
|
|
{
|
|
LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData;
|
|
int i;
|
|
LPTSTR lpsz;
|
|
if (lpud && (lpud != (void *)-1))
|
|
{
|
|
HDPA hdpa = lpud->hdpa;
|
|
HDSA hdsa = lpud->hdsa;
|
|
if (hdpa)
|
|
{
|
|
i = DPA_GetPtrCount(hdpa) - 1;
|
|
for (; i >= 0; i--)
|
|
{
|
|
lpsz = DPA_FastGetPtr(hdpa, i);
|
|
Str_SetPtr(&lpsz, NULL);
|
|
}
|
|
DPA_Destroy(hdpa);
|
|
}
|
|
|
|
if (hdsa)
|
|
{
|
|
LPFOUNDO_DELETEDFILEINFO lpdfi;
|
|
i = DSA_GetItemCount(hdsa) - 1;
|
|
for (; i >= 0 ; i--)
|
|
{
|
|
lpdfi = DSA_GetItemPtr(hdsa, i);
|
|
Str_SetPtr(&lpdfi->lpszName, NULL);
|
|
}
|
|
DSA_Destroy(hdsa);
|
|
}
|
|
LocalFree(lpud);
|
|
lpua->lpData = (void *)-1;
|
|
}
|
|
}
|
|
|
|
DWORD WINAPI FOUndo_InvokeThreadInit(UNDOATOM *lpua)
|
|
{
|
|
LPFOUNDODATA lpud = (LPFOUNDODATA)lpua->lpData;
|
|
HDPA hdpa = lpud->hdpa;
|
|
HWND hwnd = lpua->hwnd;
|
|
BOOL fNukeAtom = TRUE;
|
|
SHFILEOPSTRUCT sFileOp =
|
|
{
|
|
hwnd,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
0,
|
|
} ;
|
|
int iMax;
|
|
|
|
SuspendUndo(TRUE);
|
|
iMax = DPA_GetPtrCount(hdpa);
|
|
switch (lpua->uType)
|
|
{
|
|
case IDS_RENAME:
|
|
{
|
|
TCHAR szFromPath[MAX_PATH + 1];
|
|
if (iMax < 2)
|
|
goto Exit;
|
|
|
|
sFileOp.wFunc = FO_RENAME;
|
|
sFileOp.pFrom = DPA_GetPtr(hdpa, 1);
|
|
sFileOp.pTo = DPA_GetPtr(hdpa, 0);
|
|
if (sFileOp.pFrom && sFileOp.pTo)
|
|
{
|
|
lstrcpy(szFromPath, sFileOp.pFrom);
|
|
szFromPath[lstrlen(sFileOp.pFrom) + 1] = 0;
|
|
sFileOp.pFrom = szFromPath;
|
|
SHFileOperation(&sFileOp);
|
|
if (sFileOp.fAnyOperationsAborted)
|
|
{
|
|
fNukeAtom = FALSE;
|
|
}
|
|
}
|
|
// In the rename case the DPA owns these pointers, in all other cases
|
|
// they must be freed below. To prevent freeing these during a rename
|
|
// we NULL them out when we're done with them
|
|
sFileOp.pFrom = NULL;
|
|
sFileOp.pTo = NULL;
|
|
}
|
|
break;
|
|
|
|
case IDS_COPY:
|
|
sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax - 1, 2);
|
|
if (!sFileOp.pFrom)
|
|
goto Exit;
|
|
sFileOp.wFunc = FO_DELETE;
|
|
//
|
|
// If this delete is occuring because of an automatic undo caused by
|
|
// connected files, then do not ask for confirmation.
|
|
//
|
|
if (lpua->foFlags & FOF_NOCONFIRMATION)
|
|
sFileOp.fFlags |= FOF_NOCONFIRMATION;
|
|
|
|
SHFileOperation(&sFileOp);
|
|
if (sFileOp.fAnyOperationsAborted)
|
|
{
|
|
fNukeAtom = FALSE;
|
|
}
|
|
break;
|
|
|
|
case IDS_MOVE:
|
|
sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax-1, 2);
|
|
sFileOp.pTo = DPA_ToFileList(hdpa, 0, iMax-2, 2);
|
|
if (!sFileOp.pFrom || !sFileOp.pTo)
|
|
goto Exit;
|
|
sFileOp.wFunc = FO_MOVE;
|
|
sFileOp.fFlags = FOF_MULTIDESTFILES;
|
|
if (lpua->foFlags & FOF_NOCOPYSECURITYATTRIBS)
|
|
{
|
|
sFileOp.fFlags |= FOF_NOCOPYSECURITYATTRIBS;
|
|
}
|
|
SHFileOperation(&sFileOp);
|
|
if (sFileOp.fAnyOperationsAborted)
|
|
{
|
|
fNukeAtom = FALSE;
|
|
}
|
|
break;
|
|
|
|
case IDS_DELETE:
|
|
{
|
|
// first create any directories
|
|
if (lpud->hdsa)
|
|
{
|
|
HDSA hdsa = lpud->hdsa;
|
|
int i;
|
|
// do it in reverse order to get the parentage right
|
|
for (i = DSA_GetItemCount(hdsa) - 1; i >= 0; i--)
|
|
{
|
|
LPFOUNDO_DELETEDFILEINFO lpdfi = DSA_GetItemPtr(hdsa, i);
|
|
if (lpdfi)
|
|
{
|
|
if (Win32CreateDirectory(lpdfi->lpszName, NULL))
|
|
{
|
|
SetFileAttributes(lpdfi->lpszName, lpdfi->dwAttributes & ~FILE_ATTRIBUTE_DIRECTORY);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (iMax)
|
|
{
|
|
sFileOp.pFrom = DPA_ToFileList(hdpa, 1, iMax-1, 2);
|
|
sFileOp.pTo = DPA_ToFileList(hdpa, 0, iMax-2, 2);
|
|
if (!sFileOp.pFrom || !sFileOp.pTo)
|
|
goto Exit;
|
|
UndoBBFileDelete(sFileOp.pTo, sFileOp.pFrom);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
SHChangeNotify(0, SHCNF_FLUSH | SHCNF_FLUSHNOWAIT, NULL, NULL);
|
|
|
|
Exit:
|
|
if (sFileOp.pFrom)
|
|
LocalFree((HLOCAL)sFileOp.pFrom);
|
|
if (sFileOp.pTo)
|
|
LocalFree((HLOCAL)sFileOp.pTo);
|
|
|
|
SuspendUndo(FALSE);
|
|
if (fNukeAtom)
|
|
NukeUndoAtom(lpua);
|
|
return 1;
|
|
}
|
|
|
|
void CALLBACK FOUndo_Invoke(UNDOATOM *lpua)
|
|
{
|
|
DWORD idThread;
|
|
HANDLE hthread = CreateThread(NULL, 0, FOUndo_InvokeThreadInit, lpua, 0, &idThread);
|
|
if (hthread)
|
|
CloseHandle(hthread);
|
|
}
|
|
|
|
UNDOATOM *FOAllocUndoAtom(LPSHFILEOPSTRUCT lpfo)
|
|
{
|
|
UNDOATOM *lpua = (UNDOATOM *)LocalAlloc(LPTR, sizeof(*lpua));
|
|
if (lpua)
|
|
{
|
|
lpua->uType = FOFuncToStringID(lpfo->wFunc);
|
|
lpua->GetText = FOUndo_GetText;
|
|
lpua->Invoke = FOUndo_Invoke;
|
|
lpua->Release = FOUndo_Release;
|
|
lpua->foFlags = 0;
|
|
|
|
if (lpfo->fFlags & FOF_NOCOPYSECURITYATTRIBS)
|
|
{
|
|
lpua->foFlags |= FOF_NOCOPYSECURITYATTRIBS;
|
|
}
|
|
}
|
|
return lpua;
|
|
}
|
|
|
|
//============================================================================
|
|
//
|
|
// The following function is the mainline function for COPYing, RENAMEing,
|
|
// DELETEing, and MOVEing single or multiple files.
|
|
//
|
|
// in:
|
|
// hwnd the parent to create the progress dialog from if FOF_CREATEPROGRESSDLG is set.
|
|
//
|
|
//
|
|
// wFunc operation to be performed:
|
|
// FO_DELETE - Delete files in pFrom (pTo unused)
|
|
// FO_RENAME - Rename files
|
|
// FO_MOVE - Move files in pFrom to pTo
|
|
// FO_COPY - Copy files in pFrom to pTo
|
|
//
|
|
// pFrom list of source file specs either qualified or
|
|
// unqualified. unqualified names will be qualified based on the current
|
|
// global current directories. examples include
|
|
// "foo.txt bar.txt *.bak ..\*.old dir_name"
|
|
//
|
|
// pTo destination file spec.
|
|
//
|
|
// fFlags flags that control the operation
|
|
//
|
|
// returns:
|
|
// 0 indicates success
|
|
// != 0 is the DE_ (dos error code) of last failed operation
|
|
//
|
|
//
|
|
//===========================================================================
|
|
|
|
int WINAPI SHFileOperation(LPSHFILEOPSTRUCT lpfo)
|
|
{
|
|
int ret;
|
|
BOOL bRecycledStuff = FALSE;
|
|
COPY_STATE *pcs;
|
|
|
|
if (!lpfo || !lpfo->pFrom)
|
|
{
|
|
// return an error instead of waiting to AV
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
lpfo->fAnyOperationsAborted = FALSE;
|
|
lpfo->hNameMappings = NULL;
|
|
|
|
if (lpfo->wFunc < FO_MOVE || lpfo->wFunc > FO_RENAME) // validate
|
|
{
|
|
// NOTE: We used to return 0 here (win95gold -> IE401).
|
|
//
|
|
// If we run into app compat bugs because they were relying on the old
|
|
// buggy return value, then add an app hack here.
|
|
//
|
|
// this is not a DE_ error, and I don't care!
|
|
return ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
pcs = (COPY_STATE*)LocalAlloc(LPTR, sizeof(COPY_STATE));
|
|
if (!pcs)
|
|
{
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
pcs->nRef = 1;
|
|
|
|
//
|
|
// REVIEW: We want to allow copying of a file within a given directory
|
|
// by having default renaming on collisions within a directory.
|
|
//
|
|
if (!(lpfo->fFlags & FOF_NOCONFIRMATION))
|
|
{
|
|
pcs->cd.fConfirm =
|
|
CONFIRM_DELETE_FILE |
|
|
CONFIRM_DELETE_FOLDER |
|
|
CONFIRM_REPLACE_FILE |
|
|
CONFIRM_REPLACE_FOLDER |
|
|
CONFIRM_WONT_RECYCLE_FILE |
|
|
CONFIRM_WONT_RECYCLE_FOLDER |
|
|
CONFIRM_PATH_TOO_LONG |
|
|
// CONFIRM_MOVE_FILE |
|
|
// CONFIRM_MOVE_FOLDER |
|
|
// CONFIRM_RENAME_FILE |
|
|
// CONFIRM_RENAME_FOLDER |
|
|
CONFIRM_SYSTEM_FILE |
|
|
CONFIRM_READONLY_FILE |
|
|
CONFIRM_MULTIPLE |
|
|
CONFIRM_PROGRAM_FILE |
|
|
CONFIRM_STREAMLOSS |
|
|
CONFIRM_FAILED_ENCRYPT |
|
|
CONFIRM_LFNTOFAT |
|
|
CONFIRM_WONT_RECYCLE_OFFLINE |
|
|
CONFIRM_LOST_ENCRYPT_FILE |
|
|
CONFIRM_LOST_ENCRYPT_FOLDER;
|
|
}
|
|
|
|
if (lpfo->fFlags & FOF_WANTNUKEWARNING)
|
|
{
|
|
// We will warn the user that the thing they thought was going to be recycled is
|
|
// now really going to be nuked. (eg drag-drop folder on recycle bin, but it turns
|
|
// out that the folder is too big for the bitbucket, so we confirm on the wont-recycle
|
|
// cases).
|
|
//
|
|
// Also, we keep the system file / readonly file / progran file warnings around for good
|
|
// measure.
|
|
pcs->cd.fConfirm |= CONFIRM_WONT_RECYCLE_FILE |
|
|
CONFIRM_WONT_RECYCLE_FOLDER |
|
|
CONFIRM_PATH_TOO_LONG |
|
|
CONFIRM_SYSTEM_FILE |
|
|
CONFIRM_READONLY_FILE |
|
|
CONFIRM_PROGRAM_FILE |
|
|
CONFIRM_WONT_RECYCLE_OFFLINE;
|
|
}
|
|
|
|
|
|
pcs->fFlags = lpfo->fFlags; // duplicate some stuff here
|
|
pcs->lpszProgressTitle = lpfo->lpszProgressTitle;
|
|
pcs->lpfo = lpfo;
|
|
|
|
// Check to see if we need to operate on the "connected" files and folders too!
|
|
if (!(pcs->fFlags & FOF_NO_CONNECTED_ELEMENTS))
|
|
{
|
|
DWORD dwFileFolderConnection = 0;
|
|
DWORD dwSize = sizeof(dwFileFolderConnection);
|
|
DWORD dwType = REG_DWORD;
|
|
|
|
if (SHGetValue(HKEY_CURRENT_USER, REGSTR_PATH_EXPLORER,
|
|
REG_VALUE_NO_FILEFOLDER_CONNECTION, &dwType, &dwFileFolderConnection,
|
|
&dwSize) == ERROR_SUCCESS)
|
|
{
|
|
//If the registry says "No connection", then set the flags accordingly.
|
|
if (dwFileFolderConnection == 1)
|
|
{
|
|
pcs->fFlags = pcs->fFlags | FOF_NO_CONNECTED_ELEMENTS;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Always create a progress dialog
|
|
// Note that it will be created invisible, and will be shown if the
|
|
// operation takes longer than a second to perform
|
|
// Note the parent of this window is NULL so it will get the QUERYENDSESSION
|
|
// message
|
|
if (!(pcs->fFlags & FOF_SILENT))
|
|
{
|
|
SHCreateThread(FOUIThreadProc, pcs, 0, AddRefPCS);
|
|
}
|
|
else
|
|
{
|
|
// To be compatible with Win95 semantics...
|
|
if (!lpfo->hwnd)
|
|
{
|
|
pcs->fFlags |= FOF_NOERRORUI;
|
|
}
|
|
}
|
|
|
|
if (lpfo->hwnd)
|
|
{
|
|
// The caller will be disabled if we ever show the progress window
|
|
// We need to make sure this is not disabled now because if it is and
|
|
// another dialog uses this as its parent, USER code will tell this
|
|
// window it got the focus while it is still disabled, which keeps it
|
|
// from passing that focus down to its children
|
|
// EnableWindow(lpfo->hwnd, FALSE);
|
|
pcs->hwndDlgParent = lpfo->hwnd;
|
|
}
|
|
|
|
// do this always.. even if this is not an undoable op, we could be
|
|
// affecting something that is.
|
|
SuspendUndo(TRUE);
|
|
|
|
if (lpfo->fFlags & FOF_ALLOWUNDO)
|
|
{
|
|
pcs->lpua = FOAllocUndoAtom(lpfo);
|
|
if (lpfo->wFunc == FO_DELETE)
|
|
{
|
|
// We check the shell state to see if the user has turned on the
|
|
// "Don't confirm deleting recycle bin contents" flag. If yes,
|
|
// then we store this flag and check against it if this case occures.
|
|
// Review: Not a super common case, why not just check when the
|
|
// flag is actually needed?
|
|
SHELLSTATE ss;
|
|
SHGetSetSettings(&ss, SSF_NOCONFIRMRECYCLE, FALSE);
|
|
pcs->fNoConfirmRecycle = ss.fNoConfirmRecycle;
|
|
|
|
if (InitBBGlobals())
|
|
{
|
|
// since we are going to be recycling stuff, we add ourselves to the
|
|
// global list of threads who are recycling
|
|
SHGlobalCounterIncrement(g_hgcNumDeleters);
|
|
bRecycledStuff = TRUE;
|
|
}
|
|
else
|
|
{
|
|
// this shouldnt happen, but if it does we can't send stuff to the Recycle
|
|
// Bin, instead we remove the undo flag so that everything is really nuked.
|
|
lpfo->fFlags &= ~FOF_ALLOWUNDO;
|
|
LocalFree(pcs->lpua);
|
|
pcs->lpua = NULL;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// While doing the file operation, tell PnP not to suspend
|
|
// the machine. Otherwise, you could be copying a lot of files
|
|
// over the network and have the laptop suddenly hibernate on you
|
|
// because PnP thought you were idle.
|
|
//
|
|
// Indicate that we only need the system. It's okay if the display
|
|
// goes into low-power mode, as long as we can keep copying.
|
|
//
|
|
|
|
SetThreadExecutionState(ES_CONTINUOUS | ES_SYSTEM_REQUIRED);
|
|
|
|
ret = MoveCopyDriver(pcs);
|
|
|
|
SetThreadExecutionState(ES_CONTINUOUS);
|
|
|
|
if (pcs->bAbort)
|
|
{
|
|
ASSERT(pcs->lpfo == lpfo);
|
|
lpfo->fAnyOperationsAborted = TRUE;
|
|
}
|
|
|
|
if (bRecycledStuff)
|
|
{
|
|
SHUpdateRecycleBinIcon();
|
|
|
|
if (0 == SHGlobalCounterDecrement(g_hgcNumDeleters))
|
|
{
|
|
// We were the last guy who was deleting stuff. Thus, we need to
|
|
// check to see if any of the bitbuckets info files neeed compacting or purging
|
|
CheckCompactAndPurge();
|
|
}
|
|
}
|
|
|
|
if (pcs->lpCopyBuffer)
|
|
{
|
|
LocalFree((HLOCAL)pcs->lpCopyBuffer);
|
|
pcs->lpCopyBuffer = NULL;
|
|
}
|
|
|
|
if (pcs->lpua)
|
|
{
|
|
if (pcs->lpua->lpData && (pcs->lpua->lpData != (void *)-1))
|
|
{
|
|
AddUndoAtom(pcs->lpua);
|
|
}
|
|
else
|
|
{
|
|
FOUndo_Release(pcs->lpua);
|
|
NukeUndoAtom(pcs->lpua);
|
|
}
|
|
}
|
|
|
|
// NTRAID89119 (toddb): This code is totally busted in respect to mounted volumes.
|
|
// We will send a change notify for the drive on which your volume is mounted
|
|
// instead of on the volume which actually had a free space change. We need
|
|
// to update PathGetDriveNumber to handle mounted volumes
|
|
|
|
// notify of freespace changes
|
|
// rename doesn't change drive usage
|
|
if (lpfo->wFunc != FO_RENAME)
|
|
{
|
|
int idDriveSrc;
|
|
int idDriveDest = -1;
|
|
DWORD dwDrives = 0; // bitfield for drives
|
|
|
|
if (lpfo->wFunc == FO_COPY)
|
|
{
|
|
// nothing changes on the source
|
|
idDriveSrc = -1;
|
|
}
|
|
else
|
|
{
|
|
idDriveSrc = PathGetDriveNumber(lpfo->pFrom);
|
|
}
|
|
|
|
if (lpfo->pTo)
|
|
{
|
|
idDriveDest = PathGetDriveNumber(lpfo->pTo);
|
|
}
|
|
|
|
if ((lpfo->wFunc == FO_MOVE) && (idDriveDest == idDriveSrc))
|
|
{
|
|
// no freespace nothing changes
|
|
idDriveSrc = -1;
|
|
idDriveDest = -1;
|
|
}
|
|
|
|
// NTRAID89119: What if idDriveSrc or idDriveDest are > 32? This is totally
|
|
// possible under NT by using mounted volumes. SHChangeNotify is busted
|
|
// in this respect.
|
|
|
|
if (idDriveSrc != -1)
|
|
{
|
|
dwDrives |= (1 << idDriveSrc);
|
|
}
|
|
|
|
if (idDriveDest != -1)
|
|
{
|
|
dwDrives |= (1 << idDriveDest);
|
|
}
|
|
|
|
if (dwDrives)
|
|
{
|
|
SHChangeNotify(SHCNE_FREESPACE, SHCNF_DWORD, IntToPtr(dwDrives), 0);
|
|
}
|
|
}
|
|
|
|
SuspendUndo(FALSE);
|
|
|
|
if (!(lpfo->fFlags & FOF_WANTMAPPINGHANDLE))
|
|
{
|
|
SHFreeNameMappings(lpfo->hNameMappings);
|
|
lpfo->hNameMappings = NULL;
|
|
}
|
|
|
|
// shut down the progress dialog
|
|
//
|
|
// this is necessary so that the ui thread won't block
|
|
pcs->fProgressOk = TRUE;
|
|
|
|
ENTERCRITICAL; // need to take critsec to sync w/ the UI thread
|
|
pcs->fDone = TRUE;
|
|
if (pcs->hwndProgress)
|
|
{
|
|
PostMessage(pcs->hwndProgress, PDM_NOOP, 0, 0);
|
|
}
|
|
LEAVECRITICAL;
|
|
|
|
if (lpfo->hwnd)
|
|
{
|
|
EnableWindow(lpfo->hwnd, TRUE);
|
|
}
|
|
|
|
ReleasePCS(pcs);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef UNICODE
|
|
int WINAPI SHFileOperationA(LPSHFILEOPSTRUCTA lpfo)
|
|
{
|
|
int iResult;
|
|
UINT uTotalSize;
|
|
UINT uSize;
|
|
UINT uSizeTitle;
|
|
UINT uSizeW;
|
|
SHFILEOPSTRUCTW shop;
|
|
LPCSTR lpAnsi;
|
|
LPWSTR lpBuffer;
|
|
LPWSTR lpTemp;
|
|
|
|
COMPILETIME_ASSERT(sizeof(SHFILEOPSTRUCTW) == sizeof(SHFILEOPSTRUCTA));
|
|
|
|
hmemcpy(&shop, lpfo, sizeof(SHFILEOPSTRUCTW));
|
|
|
|
//
|
|
// Thunk the strings as appropriate
|
|
//
|
|
uTotalSize = 0;
|
|
if (lpfo->pFrom)
|
|
{
|
|
lpAnsi = lpfo->pFrom;
|
|
do {
|
|
uSize = lstrlenA(lpAnsi) + 1;
|
|
uTotalSize += uSize;
|
|
lpAnsi += uSize;
|
|
} while (uSize != 1);
|
|
}
|
|
|
|
if (lpfo->pTo)
|
|
{
|
|
lpAnsi = lpfo->pTo;
|
|
do {
|
|
uSize = lstrlenA(lpAnsi) + 1;
|
|
uTotalSize += uSize;
|
|
lpAnsi += uSize;
|
|
} while (uSize != 1);
|
|
}
|
|
|
|
if ((lpfo->fFlags & FOF_SIMPLEPROGRESS) && lpfo->lpszProgressTitle != NULL)
|
|
{
|
|
uSizeTitle = lstrlenA(lpfo->lpszProgressTitle) + 1;
|
|
uTotalSize += uSizeTitle;
|
|
}
|
|
|
|
if (uTotalSize != 0)
|
|
{
|
|
lpTemp = lpBuffer = LocalAlloc(LPTR, uTotalSize*sizeof(WCHAR));
|
|
if (!lpBuffer)
|
|
{
|
|
SetLastError(ERROR_OUTOFMEMORY);
|
|
return ERROR_OUTOFMEMORY;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
lpBuffer = NULL;
|
|
}
|
|
|
|
//
|
|
// Now convert the strings
|
|
//
|
|
if (lpfo->pFrom)
|
|
{
|
|
shop.pFrom = lpTemp;
|
|
lpAnsi = lpfo->pFrom;
|
|
do
|
|
{
|
|
uSize = lstrlenA(lpAnsi) + 1;
|
|
uSizeW = MultiByteToWideChar(CP_ACP, 0,
|
|
lpAnsi, uSize,
|
|
lpTemp, uSize);
|
|
lpAnsi += uSize;
|
|
lpTemp += uSizeW;
|
|
} while (uSize != 1);
|
|
}
|
|
else
|
|
{
|
|
shop.pFrom = NULL;
|
|
}
|
|
|
|
if (lpfo->pTo)
|
|
{
|
|
shop.pTo = lpTemp;
|
|
lpAnsi = lpfo->pTo;
|
|
do
|
|
{
|
|
uSize = lstrlenA(lpAnsi) + 1;
|
|
uSizeW = MultiByteToWideChar(CP_ACP, 0,
|
|
lpAnsi, uSize,
|
|
lpTemp, uSize);
|
|
lpAnsi += uSize;
|
|
lpTemp += uSizeW;
|
|
} while (uSize != 1);
|
|
}
|
|
else
|
|
{
|
|
shop.pTo = NULL;
|
|
}
|
|
|
|
|
|
if ((lpfo->fFlags & FOF_SIMPLEPROGRESS) && lpfo->lpszProgressTitle != NULL)
|
|
{
|
|
shop.lpszProgressTitle = lpTemp;
|
|
MultiByteToWideChar(CP_ACP, 0,
|
|
lpfo->lpszProgressTitle, uSizeTitle,
|
|
lpTemp, uSizeTitle);
|
|
}
|
|
else
|
|
{
|
|
shop.lpszProgressTitle = NULL;
|
|
}
|
|
|
|
iResult = SHFileOperationW(&shop);
|
|
|
|
// link up the two things in the SHFILEOPSTRUCT that could have changed
|
|
lpfo->fAnyOperationsAborted = shop.fAnyOperationsAborted;
|
|
lpfo->hNameMappings = shop.hNameMappings;
|
|
|
|
if (lpBuffer)
|
|
LocalFree(lpBuffer);
|
|
|
|
return iResult;
|
|
}
|
|
|
|
#else
|
|
|
|
int WINAPI SHFileOperationW(LPSHFILEOPSTRUCTW lpfo)
|
|
{
|
|
return E_NOTIMPL;
|
|
}
|
|
#endif
|
|
|
|
|
|
// In:
|
|
// pcs: copy_state structure containing the state of the copy
|
|
//
|
|
// feedback: If the estimated time to copmplete a copy is larger than
|
|
// MINTIME4FEEDBACK, the user is given a time to completion estimate in minutes.
|
|
// The estimate is calculated using a MS_RUNAVG seconds running average. The
|
|
// initial estimate is done after MS_TIMESLICE
|
|
|
|
void SetProgressTime(COPY_STATE *pcs)
|
|
{
|
|
DWORD dwNow = GetTickCount();
|
|
|
|
if (pcs->dwPreviousTime)
|
|
{
|
|
|
|
int iPointsTotal = CountProgressPoints(pcs, &pcs->dth.dtAll);
|
|
int iPointsDone = CountProgressPoints(pcs, &pcs->dth.dtDone);
|
|
int iPointsDelta = iPointsDone - pcs->iLastProgressPoints;
|
|
DWORD dwTimeLeft;
|
|
|
|
//
|
|
// A couple of times the shell has reported bad time remaining
|
|
// we need to find out why.
|
|
//
|
|
ASSERT(iPointsTotal >= 0);
|
|
ASSERT(iPointsDone >= 0);
|
|
ASSERT(iPointsTotal >= iPointsDone);
|
|
ASSERT(iPointsDelta >= 0);
|
|
|
|
// has enough time elapsed to update the display
|
|
// We do this every 10 seconds, but we'll do the first one after
|
|
// only a few seconds
|
|
|
|
if (iPointsDelta && (iPointsDone > 0) && (dwNow - pcs->dwPreviousTime))
|
|
{
|
|
DWORD dwPointsPerSec;
|
|
DWORD dwTime; // how many tenths of a second have gone by
|
|
|
|
// We take 10 times the number of Points and divide by the number of
|
|
// tenths of a second to minimize both overflow and roundoff
|
|
dwTime = (dwNow - pcs->dwPreviousTime)/100;
|
|
if (dwTime == 0)
|
|
dwTime = 1;
|
|
dwPointsPerSec = iPointsDelta * 10 / dwTime;
|
|
if (!dwPointsPerSec)
|
|
{
|
|
// This could happen if the net went to sleep for a couple
|
|
// minutes while trying to copy a small (512 byte) buffer
|
|
dwPointsPerSec = 1;
|
|
}
|
|
|
|
// if we didn't have enough time to get a good sample,
|
|
// don't use this last bit as a time estimater
|
|
if ((dwNow - pcs->dwPreviousTime) < (MS_TIMESLICE/2))
|
|
{
|
|
dwPointsPerSec = pcs->dwPointsPerSec;
|
|
}
|
|
|
|
if (pcs->dwPointsPerSec)
|
|
{
|
|
// Take a weighted average of the current transfer rate and the
|
|
// previously computed one, just to try to smooth out
|
|
// some random fluctuations
|
|
|
|
dwPointsPerSec = (dwPointsPerSec + (pcs->dwPointsPerSec * 2)) / 3;
|
|
}
|
|
|
|
// never allow 0 points per second.. just tack it on to next time
|
|
if (dwPointsPerSec)
|
|
{
|
|
pcs->dwPointsPerSec = dwPointsPerSec;
|
|
|
|
// Calculate time remaining (round up by adding 1)
|
|
// We only get here every 10 seconds, so always update
|
|
dwTimeLeft = ((iPointsTotal - iPointsDone) / dwPointsPerSec) + 1;
|
|
|
|
// It would be odd to show "1 second left" and then immediately
|
|
// clear it
|
|
if (dwTimeLeft >= MIN_MINTIME4FEEDBACK)
|
|
{
|
|
// display new estimate of time left
|
|
SetProgressTimeEst(pcs, dwTimeLeft);
|
|
}
|
|
}
|
|
|
|
}
|
|
// Reset previous time and # of Points read
|
|
pcs->dwPreviousTime = dwNow;
|
|
pcs->iLastProgressPoints = iPointsDone;
|
|
}
|
|
}
|
|
|
|
void InitClipConfirmDlg(HWND hDlg, CONFDLG_DATA *pcd)
|
|
{
|
|
TCHAR szMessage[255];
|
|
TCHAR szDeleteWarning[80];
|
|
SHFILEINFO sfiDest;
|
|
LPTSTR pszFileDest = NULL;
|
|
LPTSTR pszMsg, pszSource;
|
|
int i;
|
|
int cxWidth;
|
|
RECT rc;
|
|
|
|
// get the size of the text boxes
|
|
GetWindowRect(GetDlgItem(hDlg, pcd->idText), &rc);
|
|
cxWidth = rc.right - rc.left;
|
|
|
|
// get the source display name
|
|
pszSource = PathFindFileName(pcd->pFileSource);
|
|
PathCompactPath(NULL, pszSource, cxWidth);
|
|
|
|
// get the dest display name
|
|
SHGetFileInfo(pcd->pFileDest, 0,
|
|
&sfiDest, sizeof(sfiDest), SHGFI_DISPLAYNAME | SHGFI_USEFILEATTRIBUTES);
|
|
pszFileDest = sfiDest.szDisplayName;
|
|
PathCompactPath(NULL, pszFileDest, cxWidth);
|
|
|
|
// if we're supposed to show the date info, grab the icons and format the date string
|
|
if (pcd->bShowDates)
|
|
{
|
|
SHFILEINFO sfi2;
|
|
TCHAR szDateSrc[64], szDateDest[64];
|
|
|
|
// likely that this data may be incomplete... leave it saying "Unknown date and size"
|
|
if (BuildDateLine(szDateSrc, pcd->pfdSource, pcd->pFileSource))
|
|
SetDlgItemText(hDlg, IDD_FILEINFO_NEW, szDateSrc);
|
|
|
|
BuildDateLine(szDateDest, pcd->pfdDest, pcd->pFileDest);
|
|
SetDlgItemText(hDlg, IDD_FILEINFO_OLD, szDateDest);
|
|
|
|
SHGetFileInfo(pcd->pFileSource, pcd->pfdSource ? pcd->pfdSource->dwFileAttributes : 0, &sfi2, sizeof(sfi2),
|
|
pcd->pfdSource ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON));
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_NEW, sfi2.hIcon);
|
|
|
|
SHGetFileInfo(pcd->pFileDest, pcd->pfdDest ? pcd->pfdDest->dwFileAttributes : 0, &sfi2, sizeof(sfi2),
|
|
pcd->pfdDest ? (SHGFI_USEFILEATTRIBUTES|SHGFI_ICON|SHGFI_LARGEICON) : (SHGFI_ICON|SHGFI_LARGEICON));
|
|
ReplaceDlgIcon(hDlg, IDD_ICON_OLD, sfi2.hIcon);
|
|
}
|
|
|
|
// there are 5 controls:
|
|
// IDD_TEXT contains regular text (normal file/folder)
|
|
// IDD_TEXT1 through IDD_TEXT4 contain optional secondary text
|
|
for (i = IDD_TEXT; i <= IDD_TEXT4; i++)
|
|
{
|
|
if (i == pcd->idText)
|
|
{
|
|
szMessage[0] = 0;
|
|
GetDlgItemText(hDlg, i, szMessage, ARRAYSIZE(szMessage));
|
|
}
|
|
else
|
|
{
|
|
HWND hwndCtl = GetDlgItem(hDlg, i);
|
|
if (hwndCtl)
|
|
{
|
|
ShowWindow(hwndCtl, SW_HIDE);
|
|
}
|
|
}
|
|
}
|
|
|
|
szDeleteWarning[0] = 0;
|
|
|
|
pszMsg = ShellConstructMessageString(HINST_THISDLL, szMessage,
|
|
pszSource, pszFileDest, szDeleteWarning);
|
|
|
|
if (pszMsg)
|
|
{
|
|
SetDlgItemText(hDlg, pcd->idText, pszMsg);
|
|
LocalFree(pszMsg);
|
|
}
|
|
}
|
|
|
|
void FileDescToWin32FileData(LPFILEDESCRIPTOR pfdsc, LPWIN32_FIND_DATA pwfd)
|
|
{
|
|
ZeroMemory(pwfd, sizeof(*pwfd));
|
|
|
|
if (pfdsc->dwFlags & FD_ATTRIBUTES)
|
|
pwfd->dwFileAttributes = pfdsc->dwFileAttributes;
|
|
if (pfdsc->dwFlags & FD_CREATETIME)
|
|
hmemcpy(&pwfd->ftCreationTime, &pfdsc->ftCreationTime, sizeof(FILETIME));
|
|
if (pfdsc->dwFlags & FD_ACCESSTIME)
|
|
hmemcpy(&pwfd->ftLastAccessTime, &pfdsc->ftLastAccessTime, sizeof(FILETIME));
|
|
if (pfdsc->dwFlags & FD_WRITESTIME)
|
|
hmemcpy(&pwfd->ftLastWriteTime, &pfdsc->ftLastWriteTime, sizeof(FILETIME));
|
|
if (pfdsc->dwFlags & FD_FILESIZE)
|
|
{
|
|
pwfd->nFileSizeHigh = pfdsc->nFileSizeHigh;
|
|
pwfd->nFileSizeLow = pfdsc->nFileSizeLow;
|
|
}
|
|
lstrcpy(pwfd->cFileName, pfdsc->cFileName);
|
|
}
|
|
|
|
INT_PTR ValidateCreateFileFromClip(HWND hwnd, LPFILEDESCRIPTOR pfdscSrc, TCHAR *pszPathDest, PYNLIST pynl)
|
|
{
|
|
WIN32_FIND_DATA wfdSrc, wfdDest;
|
|
CONFDLG_DATA cdd;
|
|
CONFIRM_DATA cd;
|
|
COPY_STATE cs;
|
|
INT_PTR result;
|
|
|
|
//
|
|
// If the destination does not exist, we are done.
|
|
//
|
|
HANDLE hff = FindFirstFile(pszPathDest, &wfdDest);
|
|
if (hff == INVALID_HANDLE_VALUE)
|
|
{
|
|
return IDYES;
|
|
}
|
|
FindClose(hff);
|
|
|
|
//
|
|
// Maybe this was just a short name collision and
|
|
// we can quickly get out of here.
|
|
//
|
|
if (ResolveShortNameCollisions(pszPathDest, &wfdDest))
|
|
{
|
|
return IDYES;
|
|
}
|
|
|
|
//
|
|
// Most of the helper functions want a WIN32_FILE_DATA
|
|
// and not a FILEDESCRIPTOR, so we create wfd for the
|
|
// source file on the fly.
|
|
//
|
|
FileDescToWin32FileData(pfdscSrc, &wfdSrc);
|
|
|
|
//
|
|
// Take care of the easy cases - can't copy a file to a dir
|
|
// or a dir to a file.
|
|
//
|
|
if ((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) &&
|
|
((wfdSrc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0))
|
|
{
|
|
ZeroMemory(&cs, sizeof(cs));
|
|
cs.hwndDlgParent = hwnd;
|
|
|
|
CopyError(&cs, wfdSrc.cFileName, pszPathDest, DE_FILEDESTISFLD | ERRORONDEST, FO_COPY, OPER_DOFILE);
|
|
return IDNO;
|
|
}
|
|
else if (((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) &&
|
|
(wfdSrc.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY))
|
|
{
|
|
ZeroMemory(&cs, sizeof(cs));
|
|
cs.hwndDlgParent = hwnd;
|
|
|
|
CopyError(&cs, wfdSrc.cFileName, pszPathDest, DE_FLDDESTISFILE | ERRORONDEST, FO_COPY, OPER_DOFILE);
|
|
|
|
AddToNoList(pynl, pszPathDest);
|
|
|
|
return IDNO;
|
|
}
|
|
|
|
//
|
|
// We need a confirmation dialog. Fill in the
|
|
// ConfirmDialogData (cdd) here.
|
|
//
|
|
|
|
ZeroMemory(&cdd, sizeof(cdd));
|
|
|
|
cdd.InitConfirmDlg = InitClipConfirmDlg;
|
|
cdd.idText = IDD_TEXT;
|
|
cdd.pFileSource = pfdscSrc->cFileName;
|
|
cdd.pfdSource = &wfdSrc;
|
|
cdd.pFileDest = pszPathDest;
|
|
cdd.pfdDest = &wfdDest;
|
|
cdd.bShowDates = FALSE;
|
|
cdd.pcd = &cd;
|
|
|
|
ZeroMemory(&cd, sizeof(cd));
|
|
cd.fConfirm = CONFIRM_REPLACE_FILE;
|
|
cdd.fYesToAllMask = CONFIRM_REPLACE_FILE;
|
|
|
|
if (((wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0) &&
|
|
(wfdDest.dwFileAttributes & (FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_READONLY)))
|
|
{
|
|
if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM)
|
|
{
|
|
cdd.idText = IDD_TEXT2;
|
|
}
|
|
else if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
|
|
{
|
|
cdd.idText = IDD_TEXT1;
|
|
}
|
|
}
|
|
|
|
//
|
|
// What we do now depends on whether we are processing a directory
|
|
// or a file.
|
|
//
|
|
if (wfdDest.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
//
|
|
// If this directory is already in the yes list,
|
|
// the parent directory must have already conflicted
|
|
// and the user said "yes, move the dir contents over".
|
|
//
|
|
if (IsInYesList(pynl, pszPathDest))
|
|
{
|
|
result = IDYES;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Copying directory to a destination with the same directory.
|
|
//
|
|
result = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_REPLACE_FOLDER), hwnd, ConfirmDlgProc, (LPARAM)&cdd);
|
|
|
|
if (result == IDYES)
|
|
{
|
|
if (cd.fConfirm & CONFIRM_REPLACE_FILE)
|
|
{
|
|
AddToYesList(pynl, pszPathDest);
|
|
}
|
|
else
|
|
{
|
|
SetYesToAll(pynl);
|
|
}
|
|
}
|
|
else if (result == IDNO)
|
|
{
|
|
AddToNoList(pynl, pszPathDest);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (IsInYesList(pynl, pszPathDest))
|
|
{
|
|
result = IDYES;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Copying a file to a destination with the same file.
|
|
//
|
|
cdd.bShowDates = TRUE;
|
|
|
|
result = DialogBoxParam(HINST_THISDLL, MAKEINTRESOURCE(DLG_REPLACE_FILE), hwnd, ConfirmDlgProc, (LPARAM)&cdd);
|
|
|
|
if (result == IDYES)
|
|
{
|
|
if ((cd.fConfirm & CONFIRM_REPLACE_FILE) == 0)
|
|
{
|
|
SetYesToAll(pynl);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// We can get transient file locks for moving files, for example extracting a thumbnail on a background task
|
|
// so we wrap our single check in a loop of multiple checks with a short nap between. We'd expect
|
|
// to get the ERROR_SHARING_VIOLATION, but in practice we also say ERROR_ACCESS_DENIED, so we'll try that
|
|
// as well
|
|
|
|
#define MAX_DELETE_ATTEMPTS 5
|
|
#define SLEEP_DELETE_ATTEMPT 1000
|
|
|
|
BOOL _IsFileDeletable(LPCTSTR pszFile)
|
|
{
|
|
int iAttempt = 0;
|
|
BOOL bRet;
|
|
while (!(bRet = IsFileDeletable(pszFile)) && (iAttempt < MAX_DELETE_ATTEMPTS))
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
|
|
if ((dwError == ERROR_ACCESS_DENIED) || (dwError == ERROR_SHARING_VIOLATION))
|
|
{
|
|
iAttempt++;
|
|
Sleep(SLEEP_DELETE_ATTEMPT);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (bRet);
|
|
}
|
|
|
|
BOOL _IsDirectoryDeletable(LPCTSTR pszDir)
|
|
{
|
|
int iAttempt = 0;
|
|
BOOL bRet;
|
|
while (!(bRet = IsDirectoryDeletable(pszDir)) && (iAttempt < MAX_DELETE_ATTEMPTS))
|
|
{
|
|
DWORD dwError = GetLastError();
|
|
|
|
if ((dwError == ERROR_ACCESS_DENIED) || (dwError == ERROR_SHARING_VIOLATION))
|
|
{
|
|
iAttempt++;
|
|
Sleep(SLEEP_DELETE_ATTEMPT);
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (bRet);
|
|
}
|
|
|
|
// This function adds up the sizes of the files in pszDir, and
|
|
// also makes sure that all those files are "delete-able"
|
|
//
|
|
// return: ERROR_SUCCESS - everything is fine, all the files in the dir are deleteable
|
|
// else - the dir cant be deleted because something inside is non-deletable
|
|
//
|
|
// NOTE: other in-out params are in the pfdi
|
|
//
|
|
LONG CheckFolderSizeAndDeleteability(LPCTSTR pszDir, FOLDERDELETEINFO* pfdi, LPCOPY_STATE pcs)
|
|
{
|
|
LONG lRet = ERROR_SUCCESS; // keep stack to a minimum as this is a recursive function!
|
|
BOOL bHasChildren = FALSE;
|
|
|
|
if (FOQueryAbort(pcs))
|
|
return ERROR_CANCELLED;
|
|
|
|
if (NULL == pszDir)
|
|
return E_INVALIDARG;
|
|
|
|
// do the root specific processing
|
|
if (!pfdi->bProcessedRoot)
|
|
{
|
|
// since the the destination folder could be something like "DC100000.oldext", calculate how many characters are
|
|
// going to be in the new destination directory: "C:\recycler\sid" + "\" + "DC100000.oldext" == the new root directory length
|
|
pfdi->cchDelta = (pfdi->cchBBDir + 1 + 8 + 1 + lstrlen(PathFindExtension(pszDir))) - lstrlen(pszDir);
|
|
|
|
// set this so that we only do the above processing for the root folder
|
|
pfdi->bProcessedRoot = TRUE;
|
|
}
|
|
|
|
if (PathCombine(pfdi->szPath, pszDir, c_szStarDotStar))
|
|
{
|
|
HANDLE hfind = FindFirstFile(pfdi->szPath, &pfdi->fd);
|
|
|
|
// remove the *.* we added, because we will be recycling this buffer
|
|
PathRemoveFileSpec(pfdi->szPath);
|
|
|
|
if (hfind != INVALID_HANDLE_VALUE)
|
|
{
|
|
do
|
|
{
|
|
if (!PathIsDotOrDotDot(pfdi->fd.cFileName))
|
|
{
|
|
bHasChildren = TRUE;
|
|
|
|
// append the subfile/subfolder to the parent path
|
|
if (!PathAppend(pfdi->szPath, pfdi->fd.cFileName))
|
|
{
|
|
// PathAppend failed, try to append the short name
|
|
if (!pfdi->fd.cAlternateFileName[0] || !PathAppend(pfdi->szPath, pfdi->fd.cAlternateFileName))
|
|
{
|
|
// no alternate name or we failed to append that as well, assume we failed because the path is too long
|
|
lRet = ERROR_FILENAME_EXCED_RANGE;
|
|
|
|
// pass back the name of the non-deleteable file/folder in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
}
|
|
|
|
if (lRet == ERROR_SUCCESS)
|
|
{
|
|
// we have to check to see if the path will exceed MAX_PATH if we were to move this file to the recycle
|
|
// bin (C:\Recycler\<sid>). the increase in path length due to the recycle bin dir could be enough to
|
|
// put us over MAX_PATH and we would have problems later.
|
|
if ((lstrlen(pfdi->szPath) + pfdi->cchDelta + 1) > MAX_PATH) // +1 for NULL
|
|
{
|
|
TraceMsg(TF_BITBUCKET, "CheckFolderSizeAndDeleteability: path '%s' would exceed MAX_PATH if moved to the recycle bin!", pfdi->szPath);
|
|
lRet = ERROR_FILENAME_EXCED_RANGE;
|
|
|
|
// pass back the name of the non-deleteable file/folder in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
else
|
|
{
|
|
if (pfdi->fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
|
{
|
|
// its a directory, so recurse
|
|
lRet = CheckFolderSizeAndDeleteability(pfdi->szPath, pfdi, pcs);
|
|
}
|
|
else
|
|
{
|
|
// its a file.
|
|
ULARGE_INTEGER ulTemp;
|
|
|
|
if (!_IsFileDeletable(pfdi->szPath))
|
|
{
|
|
// we cant delete this file, find out why
|
|
lRet = GetLastError();
|
|
ASSERT(lRet != ERROR_SUCCESS);
|
|
|
|
// pass back the name of the non-deleteable file in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pfdi->szPath, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
|
|
ulTemp.LowPart = pfdi->fd.nFileSizeLow;
|
|
ulTemp.HighPart = pfdi->fd.nFileSizeHigh;
|
|
pfdi->cbSize += ulTemp.QuadPart;
|
|
}
|
|
}
|
|
}
|
|
|
|
// remove the file/dir name we appended
|
|
PathRemoveFileSpec(pfdi->szPath);
|
|
}
|
|
|
|
} while ((lRet == ERROR_SUCCESS) && FindNextFile(hfind, &pfdi->fd));
|
|
|
|
FindClose(hfind);
|
|
|
|
// if this dir has no children, see if we can simply delete it
|
|
if (!bHasChildren && !_IsDirectoryDeletable(pszDir))
|
|
{
|
|
lRet = GetLastError();
|
|
ASSERT(lRet != ERROR_SUCCESS);
|
|
|
|
// pass back the name of the non-deleteable file in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if FindFirstFile fails, check to see if the directory itself is deleteable
|
|
if (!_IsDirectoryDeletable(pszDir))
|
|
{
|
|
lRet = GetLastError();
|
|
ASSERT(lRet != ERROR_SUCCESS);
|
|
|
|
// pass back the name of the non-deleteable file in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// if PathCombine fails, assume its because the path is too long
|
|
lRet = ERROR_FILENAME_EXCED_RANGE;
|
|
|
|
// pass back the name of the non-deleteable file in pfdi->szNonDeletableFile
|
|
lstrcpyn(pfdi->szNonDeletableFile, pszDir, ARRAYSIZE(pfdi->szNonDeletableFile));
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
// This takes over for what BBDeleteFile used to do (init, check, delete)... but does it with the ability to cancel
|
|
BOOL DeleteFileBB(LPTSTR pszFile, INT *piRet, COPY_STATE *pcs, BOOL fIsDir, WIN32_FIND_DATA *pfd, HDPA *phdpaDeletedFiles)
|
|
{
|
|
ULARGE_INTEGER ulSize;
|
|
int idDrive = DriveIDFromBBPath(pszFile);
|
|
|
|
// Init
|
|
if (!BBDeleteFileInit(pszFile, piRet))
|
|
return FALSE;
|
|
|
|
// Check if we can delete this properly
|
|
if (fIsDir)
|
|
{
|
|
DWORD dwError;
|
|
FOLDERDELETEINFO fdi = {0};
|
|
|
|
fdi.cchBBDir = BBRecyclePathLength(idDrive);
|
|
|
|
dwError = CheckFolderSizeAndDeleteability(pszFile, &fdi, pcs);
|
|
|
|
if (dwError != ERROR_SUCCESS)
|
|
{
|
|
// if CheckFolderSizeAndDeleteability can fail if a file cant be recycled.
|
|
// In this case, it appends the name of the file to pszFile, so we know who
|
|
// the undeletable file is.
|
|
if ((dwError == ERROR_FILENAME_EXCED_RANGE) ||
|
|
(dwError == ERROR_BUFFER_OVERFLOW))
|
|
{
|
|
// it failed because a new path would be to long after being moveed under the "C:\recycler\sid" directory
|
|
*piRet = BBDELETE_PATH_TOO_LONG;
|
|
}
|
|
else if (dwError == ERROR_CANCELLED)
|
|
{
|
|
// user hit the cancel button
|
|
*piRet = BBDELETE_CANCELLED;
|
|
}
|
|
else
|
|
{
|
|
// must be a non-deletable directory, so set piRet = BBDELETE_CANNOT_DELETE so our caller
|
|
// can detect this case, also pass the name of the non-deletable file back out so we can give
|
|
// a better error message to the user
|
|
*piRet = BBDELETE_CANNOT_DELETE;
|
|
ASSERT(*fdi.szPath);
|
|
lstrcpy(pszFile, fdi.szNonDeletableFile);
|
|
}
|
|
|
|
TraceMsg(TF_BITBUCKET, "DeleteFileBB : early error (%x) on file (%s)", dwError, pszFile);
|
|
return FALSE;
|
|
}
|
|
|
|
ulSize.QuadPart = fdi.cbSize;
|
|
}
|
|
else
|
|
{
|
|
if (!_IsFileDeletable(pszFile))
|
|
{
|
|
// We set piRet = BBDELETE_CANNOT_DELETE so our caller can detect
|
|
// that this file cant be recycled.
|
|
*piRet = BBDELETE_CANNOT_DELETE;
|
|
return FALSE;
|
|
}
|
|
|
|
ulSize.LowPart = pfd->nFileSizeLow;
|
|
ulSize.HighPart = pfd->nFileSizeHigh;
|
|
}
|
|
|
|
// check to make sure it's not bigger than the allowed wastebasket..
|
|
if (!BBCheckDeleteFileSize(idDrive, ulSize))
|
|
{
|
|
// we set piRet = BBDELETE_SIZE_TOO_BIG so our caller can
|
|
// detect the "file/folder too big" case
|
|
*piRet = BBDELETE_SIZE_TOO_BIG;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return BBDeleteFile(pszFile, piRet, pcs->lpua, fIsDir, phdpaDeletedFiles, ulSize);
|
|
}
|
|
|
|
void StartCopyEngine(HANDLE *phEventRunning)
|
|
{
|
|
*phEventRunning = CreateEvent(CreateAllAccessSecurityAttributes(NULL, NULL, NULL), TRUE, FALSE, L"ShellCopyEngineRunning");
|
|
if (*phEventRunning)
|
|
{
|
|
SetEvent(*phEventRunning);
|
|
}
|
|
}
|
|
|
|
void EndCopyEngine(HANDLE hEventRunning)
|
|
{
|
|
// signal that we're done. this will always trigger so there will be some weirdness if the
|
|
// user does simultaneous copies, but it's not worth making a semaphore to keep track.
|
|
HANDLE hEventFinished = CreateEvent(CreateAllAccessSecurityAttributes(NULL, NULL, NULL), TRUE, FALSE, L"ShellCopyEngineFinished");
|
|
if (hEventFinished)
|
|
{
|
|
SetEvent(hEventFinished);
|
|
CloseHandle(hEventFinished);
|
|
}
|
|
|
|
if (hEventRunning)
|
|
{
|
|
// close out the event that says we're running.
|
|
ResetEvent(hEventRunning);
|
|
CloseHandle(hEventRunning);
|
|
}
|
|
}
|
|
|
|
BOOL IsCopyEngineRunning()
|
|
{
|
|
BOOL bRet=FALSE;
|
|
HANDLE hEventCopyRunning = OpenEvent(SYNCHRONIZE, FALSE, L"ShellCopyEngineRunning");
|
|
if (hEventCopyRunning)
|
|
{
|
|
// probe the event with a wait, if it times out the copy engine isn't running so we're done.
|
|
bRet = (WAIT_OBJECT_0 == WaitForSingleObject(hEventCopyRunning, 0));
|
|
CloseHandle(hEventCopyRunning);
|
|
}
|
|
return bRet;
|
|
}
|