able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/opktools/setupmgr/main/copyfile.c

1102 lines
31 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//----------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
// All rights reserved.
//
// File Name:
// copyfile.c
//
// Description:
// This file has the dlgproc for the copy files page.
//
//----------------------------------------------------------------------------
#include "pch.h"
#include "resource.h"
#define DAYS_IN_A_WEEK 7
#define MONTHS_IN_A_YEAR 12
//
// This struct and is used to pack the input args passed to the tree
// copy thread.
//
typedef struct {
TCHAR lpSourceBuffer[MAX_PATH];
TCHAR lpDestBuffer[MAX_PATH];
HWND hwnd;
} COPY_THREAD_PARAMS;
//
// String constants loaded from resource
//
static TCHAR *StrBuildingList;
static TCHAR *StrCopyingFiles;
static TCHAR *StrFileAlreadyExists;
static TCHAR *StrModified;
static TCHAR *StrBytes;
static TCHAR *StrJanuary;
static TCHAR *StrFebruary;
static TCHAR *StrMarch;
static TCHAR *StrApril;
static TCHAR *StrMay;
static TCHAR *StrJune;
static TCHAR *StrJuly;
static TCHAR *StrAugust;
static TCHAR *StrSeptember;
static TCHAR *StrOctober;
static TCHAR *StrNovember;
static TCHAR *StrDecember;
static TCHAR *StrSunday;
static TCHAR *StrMonday;
static TCHAR *StrTuesday;
static TCHAR *StrWednesday;
static TCHAR *StrThursday;
static TCHAR *StrFriday;
static TCHAR *StrSaturday;
static TCHAR *rgMonthsOfYear[MONTHS_IN_A_YEAR];
static TCHAR *rgDaysOfWeek[DAYS_IN_A_WEEK + 1];
//
// Messages for the dialog procedure
//
#define WMX_BEGINCOPYING (WM_USER+1)
#define WMX_FILECOPIED (WM_USER+2)
#define WMX_ENDCOPYING (WM_USER+3)
//
// Global counters
//
HDSKSPC ghDiskSpaceList;
int gnFilesCopied = 0;
int gnTotalFiles = 0;
//
// Misc constants
//
#define ONE_MEG ( 1024 * 1024 )
//
// Confirm File replace constants
//
#define YES 1
#define YESTOALL 2
#define NO 3
#define NOTOALL 4
#define CANCEL 5
#define MAX_DAY_OF_WEEK_LEN 64
#define MAX_MONTHS_OF_YEAR_LEN 64
static TCHAR g_szFileAlreadyExistsText[MAX_STRING_LEN] = _T("");
static TCHAR g_szSrcFileDate[MAX_STRING_LEN] = _T("");
static TCHAR g_szDestFileDate[MAX_STRING_LEN] = _T("");
static TCHAR g_szSrcFileSize[MAX_STRING_LEN] = _T("");
static TCHAR g_szDestFileSize[MAX_STRING_LEN] = _T("");
static BOOL g_SetFocusYes;
//
// Dialog proc that runs in the copying thread's context
//
INT_PTR CALLBACK
ConfirmFileReplaceDlgProc( IN HWND hwnd,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam);
//---------------------------------------------------------------------------
//
// This section of code runs in the context of a spawned thread. We do the
// NT source copy work in a separate thread so that the dialog repaints
// and such.
//
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
//
// Function: CountSpaceNeeded
//
// Purpose: Routine that walks a tree and counts how many files there are
// and how much diskspace is needed at the dest drive.
//
// Returns: VOID
//
//---------------------------------------------------------------------------
VOID CountSpaceNeeded(HWND hwnd,
LPTSTR SrcRootPath,
LPTSTR DestRootPath)
{
LPTSTR SrcRootPathEnd = SrcRootPath + lstrlen(SrcRootPath);
LPTSTR DestRootPathEnd = DestRootPath + lstrlen(DestRootPath);
LONGLONG llFileSize;
HANDLE FindHandle;
WIN32_FIND_DATA FindData;
//
// Look for * in this dir
//
if ( ! ConcatenatePaths(SrcRootPath, _T("*"), NULL) )
return;
FindHandle = FindFirstFile(SrcRootPath, &FindData);
if ( FindHandle == INVALID_HANDLE_VALUE )
return;
do {
*SrcRootPathEnd = _T('\0');
*DestRootPathEnd = _T('\0');
if (lstrcmp(FindData.cFileName, _T(".") ) == 0 ||
lstrcmp(FindData.cFileName, _T("..") ) == 0 )
continue;
if ( ! ConcatenatePaths(SrcRootPath, FindData.cFileName, NULL) ||
! ConcatenatePaths(DestRootPath, FindData.cFileName, NULL) )
continue;
//
// If a file, increment space and TotalFile counters else
// recurse down
//
if ( ! (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
llFileSize = (((LONGLONG) FindData.nFileSizeHigh) << 32) |
FindData.nFileSizeLow;
SetupAddToDiskSpaceList(ghDiskSpaceList,
DestRootPath,
llFileSize,
FILEOP_COPY,
NULL,
0);
gnTotalFiles++;
} else {
CountSpaceNeeded(hwnd,
SrcRootPath,
DestRootPath);
}
} while ( FindNextFile(FindHandle, &FindData) );
*SrcRootPathEnd = _T('\0');
*DestRootPathEnd = _T('\0');
FindClose(FindHandle);
}
//---------------------------------------------------------------------------
//
// Function: BuildTimeString
//
// Purpose:
//
// Arguments:
//
// Returns:
//
//---------------------------------------------------------------------------
VOID
BuildTimeString( IN FILETIME *FileTime, OUT TCHAR *szTimeString, IN DWORD cbSize )
{
// ISSUE-2002/02/28-stelo- should probably strip all of this low-level Time stuff out of here
// and put in supplib
FILETIME LocalTime;
SYSTEMTIME LastWriteSystemTime;
HRESULT hrPrintf;
FileTimeToLocalFileTime( FileTime, &LocalTime);
FileTimeToSystemTime( &LocalTime, &LastWriteSystemTime );
hrPrintf=StringCchPrintf( szTimeString, cbSize,
_T("%s: %s, %s %d, %d, %d:%.2d:%.2d"),
StrModified,
rgDaysOfWeek[LastWriteSystemTime.wDayOfWeek],
rgMonthsOfYear[LastWriteSystemTime.wMonth-1],
LastWriteSystemTime.wDay,
LastWriteSystemTime.wYear,
LastWriteSystemTime.wHour,
LastWriteSystemTime.wMinute,
LastWriteSystemTime.wSecond );
}
//---------------------------------------------------------------------------
//
// Function: CheckIfCancel
//
// Purpose: Ask user "You sure you want to cancel the file copy"?
// And if user says YES, jump the wizard to the unsucessful
// completion page.
//
// Returns:
// TRUE - wizard is now canceled, quit copying files
// FALSE - user wants to keep trying
//
//---------------------------------------------------------------------------
BOOL CheckIfCancel(HWND hwnd)
{
UINT iRet;
iRet = ReportErrorId(hwnd, MSGTYPE_YESNO, IDS_WARN_COPY_CANCEL);
if ( iRet == IDYES ) {
PostMessage(GetParent(hwnd),
PSM_SETCURSELID,
(WPARAM) 0,
(LPARAM) IDD_FINISH2);
return TRUE;
}
return FALSE;
}
//---------------------------------------------------------------------------
//
// Function: CopySingleFile
//
// Purpose: Copies a file, does all error reporting and interacting with
// the user.
//
// If there are copy errors and the user cancels, this routine
// cancels the whole wizard by jumping to the cancel page. In
// that case it returns FALSE.
//
// After a file is successfully copied, gnFilesCopied will be
// incremented and the gas-guage dlgproc will be notified.
//
// Note that this code runs in the spawned thread.
//
// Returns:
// TRUE if file was copied
// FALSE if file was not copied (user canceled)
//
//---------------------------------------------------------------------------
BOOL CopySingleFile(HWND hwnd, LPTSTR Src, LPTSTR Dest)
{
BOOL bRetry = TRUE;
UINT iRet, iRet2;
static iOverwriteFiles = YES;
HRESULT hrPrintf;
// ISSUE-2002/02/28-stelo- I think this is actually going to have to be resolved so
// it doesn't mess up copies on an edit, when a distrib folder is
// already there, they just want to add files to it.
//
// ISSUE-2002/02/28-stelo- POSTPONED
//
// When we CopyFile from the CD, the readonly attribute is set on the
// dest. So we call SetFileAttributes and reset it. If the user has
// to redo the copy, he doesn't get a 1000 "Access Denied" errors.
//
// If the user cancels on the main wizard page, that thread jumps to
// IDD_FINISH2. This thread keeps running.
//
// When the user finally clicks the Finish button, this thread gets
// terminated the hard way because WinMain() in thread0 exits.
//
// Due to this, there will frequently be a file at the dest that still
// has the readonly bit set when user cancels on the main wizard page.
//
// To fix this, we would need to synchronize with the wizard having
// been canceled and back out gracefully (before the user has time to
// push the Finish button).
//
// Note that when the wizard is canceled because a copy error already
// ocurred, thread1 (this thread) does the popping up and it is this
// thread that jumps to IDD_FINISH2. In this case we do back out
// gracefully. This bug only happens when the user presses Cancel
// on the wizard page while the gas-guage is happily painting.
//
// ISSUE-2002/02/28-stelo- this function needs to be cleaned up. To many if statements
// scattered. Don't make if conditional so long.
if( iOverwriteFiles != YESTOALL )
{
if( DoesFileExist( Dest ) )
{
INT_PTR iRetVal;
HANDLE hSrcFile;
HANDLE hDestFile;
DWORD dwSrcSize;
DWORD dwDestSize;
FILETIME LastWriteTimeSrc;
FILETIME LastWriteTimeDest;
SYSTEMTIME LastWriteSystemTime;
if( iOverwriteFiles == NOTOALL )
{
//
// Give the illusion the file was copied
//
SendMessage( hwnd,
WMX_FILECOPIED,
(WPARAM) 0,
(LPARAM) 0 );
gnFilesCopied++;
return( TRUE );
}
hrPrintf=StringCchPrintf( g_szFileAlreadyExistsText, AS(g_szFileAlreadyExistsText),
StrFileAlreadyExists,
MyGetFullPath( Dest ) );
//
// Open the files
//
hDestFile = CreateFile( Dest, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
hSrcFile = CreateFile( Src, GENERIC_READ, FILE_SHARE_READ, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
GetFileTime( hSrcFile, NULL, NULL, &LastWriteTimeSrc );
GetFileTime( hDestFile, NULL, NULL, &LastWriteTimeDest );
// ISSUE-2002/02/28-stelo- need to display AM or PM, but what about other countries
BuildTimeString( &LastWriteTimeSrc, g_szSrcFileDate, AS(g_szSrcFileDate) );
BuildTimeString( &LastWriteTimeDest, g_szDestFileDate, AS(g_szSrcFileDate) );
//
// Default to NO if file times are equal
//
if( CompareFileTime( &LastWriteTimeSrc, &LastWriteTimeDest ) < 0 )
{
g_SetFocusYes = FALSE;
}
else
{
g_SetFocusYes = TRUE;
}
// ISSUE-2002/02/28-stelo- doesn't handle file sized > 2^32 bytes, need to catch
// 2nd parameter value
dwSrcSize = GetFileSize( hSrcFile, NULL );
dwDestSize = GetFileSize( hDestFile, NULL );
// ISSUE-2002/02/28-stelo- need to insert commas into size so it looks pretty
hrPrintf=StringCchPrintf( g_szSrcFileSize,AS(g_szSrcFileSize), _T("%d %s"), dwSrcSize, StrBytes );
hrPrintf=StringCchPrintf( g_szDestFileSize,AS(g_szDestFileSize), _T("%d %s"), dwDestSize, StrBytes );
CloseHandle( hSrcFile );
CloseHandle( hDestFile );
iRetVal = DialogBox( FixedGlobals.hInstance,
(LPCTSTR) IDD_CONFIRM_FILE_REPLACE,
hwnd,
ConfirmFileReplaceDlgProc );
if( iRetVal == NO )
{
//
// Give the illusion the file was copied
//
SendMessage( hwnd,
WMX_FILECOPIED,
(WPARAM) 0,
(LPARAM) 0 );
gnFilesCopied++;
return( TRUE );
}
else if( iRetVal == YESTOALL )
{
iOverwriteFiles = YESTOALL;
}
else if( iRetVal == NOTOALL )
{
iOverwriteFiles = NOTOALL;
}
else if( iRetVal == CANCEL )
{
return( FALSE );
}
//
// Not handling the YES case because that is the default, let this
// function proceed and overwrite the file.
//
}
}
do
{
if ( CopyFile( Src, Dest, FALSE ) )
{
SetFileAttributes(Dest, FILE_ATTRIBUTE_NORMAL);
SendMessage(hwnd,
WMX_FILECOPIED,
(WPARAM) 0,
(LPARAM) 0);
gnFilesCopied++;
bRetry = FALSE;
}
else
{
iRet = ReportErrorId(hwnd,
MSGTYPE_RETRYCANCEL | MSGTYPE_WIN32,
IDS_ERR_COPY_FILE,
Src, Dest);
if ( iRet != IDRETRY ) {
if ( CheckIfCancel(hwnd) )
return FALSE;
}
}
} while ( bRetry );
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: CopyTheFiles
//
// Purpose: Recursive routine to oversee the copying of the bits.
//
// Returns:
// TRUE if the whole tree was copied,
// FALSE if user bailed on the tree copy
//
// Note that in the FALSE case CopySingleFile would have caused
// thread0 to the FINISH2 wizard page (unsuccessful completion)
// and thread1 (this code) will back out without further copies.
//
//---------------------------------------------------------------------------
BOOL CopyTheFiles(HWND hwnd,
LPTSTR SrcRootPath,
LPTSTR DestRootPath)
{
LPTSTR SrcRootPathEnd = SrcRootPath + lstrlen(SrcRootPath);
LPTSTR DestRootPathEnd = DestRootPath + lstrlen(DestRootPath);
HANDLE FindHandle;
WIN32_FIND_DATA FindData;
BOOL bRet = TRUE;
//
// Look for * in this dir
//
if ( ! ConcatenatePaths(SrcRootPath, _T("*"), NULL) )
return bRet;
FindHandle = FindFirstFile(SrcRootPath, &FindData);
if ( FindHandle == INVALID_HANDLE_VALUE )
return bRet;
do {
*SrcRootPathEnd = _T('\0');
*DestRootPathEnd = _T('\0');
//
// Don't copy the . and .. files (obviously)
// If we run across an unattend.txt, don't copy it
//
if ( ( lstrcmp(FindData.cFileName, _T(".") ) == 0 ) ||
( lstrcmp(FindData.cFileName, _T("..") ) == 0 ) ||
( LSTRCMPI( FindData.cFileName, _T("unattend.txt") ) == 0 ) )
continue;
if ( ! ConcatenatePaths(SrcRootPath, FindData.cFileName, NULL) ||
! ConcatenatePaths(DestRootPath, FindData.cFileName, NULL) )
continue;
if ( ! (FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) {
if ( ! CopySingleFile(hwnd, SrcRootPath, DestRootPath) ) {
bRet = FALSE;
goto CleanupAndReturn;
}
} else {
//
// Create the dir and recurse
//
if ( ! EnsureDirExists(DestRootPath) ) {
UINT iRet;
iRet = ReportErrorId(
hwnd,
MSGTYPE_RETRYCANCEL | MSGTYPE_WIN32,
IDS_ERR_CREATE_FOLDER,
DestRootPath);
if ( iRet != IDRETRY ) {
if ( CheckIfCancel(hwnd) ) {
bRet = FALSE;
goto CleanupAndReturn;
}
}
}
if ( ! CopyTheFiles(hwnd, SrcRootPath, DestRootPath) ) {
bRet = FALSE;
goto CleanupAndReturn;
}
}
} while ( FindNextFile(FindHandle, &FindData) );
CleanupAndReturn:
*SrcRootPathEnd = _T('\0');
*DestRootPathEnd = _T('\0');
FindClose(FindHandle);
return bRet;
}
//----------------------------------------------------------------------------
//
// Function: AsyncTreeCopy
//
// Purpose: The real thread entry
//
// Args: VOID *Args - really COPY_THREAD_PARAMS *
//
// Returns: 0
//
//----------------------------------------------------------------------------
UINT AsyncTreeCopy(VOID* Args)
{
COPY_THREAD_PARAMS *InputArgs = (COPY_THREAD_PARAMS*) Args;
TCHAR *CopySrc = InputArgs->lpSourceBuffer;
TCHAR *CopyDest = InputArgs->lpDestBuffer;
HWND hwnd = InputArgs->hwnd;
BOOL bRet;
LONGLONG llSpaceNeeded, llSpaceAvail;
//
// Figure out how much disk space is needed to copy the CD.
//
ghDiskSpaceList = SetupCreateDiskSpaceList(0, 0, 0);
if (ghDiskSpaceList == NULL)
{
TerminateTheWizard(IDS_ERROR_OUTOFMEMORY);
}
CountSpaceNeeded(hwnd, CopySrc, CopyDest);
//
// Is there enough free space?
//
// NOTE:
//
// We give the user a retry_cancel, hopefully user can free up space
// on the drive.
//
// We could popup and let them change the destpath. However, we may
// have copied files on the AdditionalDirs page. So allowing them to
// change the path means you need to check diskspace requirements for
// OemFilesPath and treecopy it as well. If we ever allow changing
// OemFilesPath, then the script would have to be updated as well,
// and it has already been written out.
//
// We could check way back on the DistFolder page. But then we
// would have to find the SourcePath before we know if it's a CD
// or netpath and we couldn't know how much they might copy on the
// AdditionalDirs page.
//
llSpaceNeeded =
MySetupQuerySpaceRequiredOnDrive(ghDiskSpaceList, CopyDest);
llSpaceAvail = MyGetDiskFreeSpace(CopyDest);
if ( llSpaceAvail < llSpaceNeeded ) {
UINT iRet;
iRet = ReportErrorId(
hwnd,
MSGTYPE_RETRYCANCEL,
IDS_ERR_INSUFICIENT_SPACE,
CopyDest, // ISSUE-2002-02-28-stelo-
(UINT) (llSpaceNeeded / ONE_MEG),
(UINT) (llSpaceAvail / ONE_MEG));
if ( iRet != IDRETRY ) {
if ( CheckIfCancel(hwnd) )
goto CleanupAndReturn;
}
}
//
// Update the message on the wizard page and start copying the files
//
SetDlgItemText(hwnd, IDC_TEXT, StrCopyingFiles);
if ( CopyTheFiles(hwnd, CopySrc, CopyDest) ) {
SendMessage(hwnd, WMX_ENDCOPYING, (WPARAM) 0, (LPARAM) 0);
}
//
// Cleanup and return
//
CleanupAndReturn:
SetupDestroyDiskSpaceList(ghDiskSpaceList);
return 0;
}
//----------------------------------------------------------------------------
//
// This section of code runs in thread0.
//
//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//
// Function: TreeCopyNtSources
//
// Purpose: Entry point for copying the NT sources (either from CD or
// a net path).
//
// The dialog proc calls this one, and it takes care of the
// details of spawning the thread.
//
// Arguments:
// HWND hwnd - window to receive copy notifications (the dlgproc)
// UINT Message - message to send on copy notifications (to dlgproc)
// LPTSTR lpSource - root of copy source
// LPTSTR lpDest - root of copy dest
//
// Returns: void
//
// Notes:
// - Input strings will not be modified.
//
//----------------------------------------------------------------------------
VOID TreeCopyNtSources(HWND hwnd,
LPTSTR lpSource,
LPTSTR lpDest)
{
DWORD dwThreadId;
HANDLE hCopyThread;
static COPY_THREAD_PARAMS ThreadParams;
//
// Fill in the ThreadParams and spawn it
//
// NTRAID#NTBUG9-551874-2002/02/27-stelo,swamip - CreateDistFolder, ShareTheDistFolder should use the code from OEM mode, reduce attack surface
lstrcpyn(ThreadParams.lpSourceBuffer, lpSource,AS(ThreadParams.lpSourceBuffer));
lstrcpyn(ThreadParams.lpDestBuffer, lpDest, AS(ThreadParams.lpDestBuffer));
MyGetFullPath(ThreadParams.lpSourceBuffer);
MyGetFullPath(ThreadParams.lpDestBuffer);
ThreadParams.hwnd = hwnd;
hCopyThread = CreateThread(NULL,
0,
AsyncTreeCopy,
&ThreadParams,
0,
&dwThreadId);
}
//----------------------------------------------------------------------------
//
// Function: BuildCopyDestPath
//
// Purpose:
//
// DestPath is assumed to be of MAX_PATH length
//
// Arguments:
//
// Returns: VOID
//
//----------------------------------------------------------------------------
VOID
BuildCopyDestPath( IN TCHAR *DestPath, IN DWORD cbSize )
{
HRESULT hrCat;
//
// If the dist folder begins with a drive letter, just use that
// If it is a UNC, then build the computer and share name and use that
//
if( WizGlobals.UncDistFolder[0] != _T('\\') )
{
lstrcpyn( DestPath, WizGlobals.UncDistFolder, cbSize );
}
else
{
GetComputerNameFromUnc( WizGlobals.UncDistFolder, DestPath, cbSize );
hrCat=StringCchCat( DestPath, cbSize, _T("\\") );
hrCat=StringCchCat( DestPath, cbSize, WizGlobals.DistShareName );
}
hrCat=StringCchCat( DestPath, cbSize, _T("\\") );
hrCat=StringCchCat( DestPath, cbSize, WizGlobals.Architecture );
}
//----------------------------------------------------------------------------
//
// Function: OnCopyFilesInitDialog
//
// Purpose:
//
// Arguments: IN HWND hwnd - handle to the dialog
//
// Returns: VOID
//
//----------------------------------------------------------------------------
static VOID
OnCopyFilesInitDialog( IN HWND hwnd )
{
StrBuildingList = MyLoadString( IDS_COPYMSG1 );
StrCopyingFiles = MyLoadString( IDS_COPYMSG2 );
StrFileAlreadyExists = MyLoadString( IDS_FILE_ALREADY_EXISTS );
StrModified = MyLoadString( IDS_MODIFIED );
StrBytes = MyLoadString( IDS_BYTES );
SetDlgItemText(hwnd, IDC_TEXT, StrBuildingList);
//
// Load Months
//
StrJanuary = MyLoadString( IDS_JANUARY );
StrFebruary = MyLoadString( IDS_FEBRUARY );
StrMarch = MyLoadString( IDS_MARCH );
StrApril = MyLoadString( IDS_APRIL );
StrMay = MyLoadString( IDS_MAY );
StrJune = MyLoadString( IDS_JUNE );
StrJuly = MyLoadString( IDS_JULY );
StrAugust = MyLoadString( IDS_AUGUST );
StrSeptember = MyLoadString( IDS_SEPTEMBER );
StrOctober = MyLoadString( IDS_OCTOBER );
StrNovember = MyLoadString( IDS_NOVEMBER );
StrDecember = MyLoadString( IDS_DECEMBER );
rgMonthsOfYear[0] = StrJanuary;
rgMonthsOfYear[1] = StrFebruary;
rgMonthsOfYear[2] = StrMarch;
rgMonthsOfYear[3] = StrApril;
rgMonthsOfYear[4] = StrMay;
rgMonthsOfYear[5] = StrJune;
rgMonthsOfYear[6] = StrJuly;
rgMonthsOfYear[7] = StrAugust;
rgMonthsOfYear[8] = StrSeptember;
rgMonthsOfYear[9] = StrOctober;
rgMonthsOfYear[10] = StrNovember;
rgMonthsOfYear[11] = StrDecember;
//
// Load Days of Week
//
StrSunday = MyLoadString( IDS_SUNDAY );
StrMonday = MyLoadString( IDS_MONDAY );
StrTuesday = MyLoadString( IDS_TUESDAY );
StrWednesday = MyLoadString( IDS_WEDNESDAY );
StrThursday = MyLoadString( IDS_THURSDAY );
StrFriday = MyLoadString( IDS_FRIDAY );
StrSaturday = MyLoadString( IDS_SATURDAY );
rgDaysOfWeek[0] = StrSunday;
rgDaysOfWeek[1] = StrMonday;
rgDaysOfWeek[2] = StrTuesday;
rgDaysOfWeek[3] = StrWednesday;
rgDaysOfWeek[4] = StrThursday;
rgDaysOfWeek[5] = StrFriday;
rgDaysOfWeek[6] = StrSaturday;
rgDaysOfWeek[7] = StrSunday;
}
//----------------------------------------------------------------------------
//
// Function: DlgCopyFilesPage
//
// Purpose: This is the dialog procedure the copy files page
//
//----------------------------------------------------------------------------
INT_PTR CALLBACK DlgCopyFilesPage(
IN HWND hwnd,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam)
{
UINT nPercent;
BOOL bStatus = TRUE;
switch (uMsg) {
case WM_INITDIALOG:
OnCopyFilesInitDialog( hwnd );
break;
case WMX_BEGINCOPYING:
{
TCHAR *SrcPath;
TCHAR DestPath[MAX_PATH + 1];
if ( WizGlobals.bCopyFromPath )
SrcPath = WizGlobals.CopySourcePath;
else
SrcPath = WizGlobals.CdSourcePath;
SendDlgItemMessage(hwnd,
IDC_PROGRESS1,
PBM_SETPOS,
0,
0);
BuildCopyDestPath( DestPath, AS(DestPath) );
TreeCopyNtSources(hwnd,
SrcPath,
DestPath);
}
break;
case WMX_ENDCOPYING:
SendDlgItemMessage(hwnd,
IDC_PROGRESS1,
PBM_SETPOS,
(WPARAM) 100,
0);
PropSheet_SetWizButtons(GetParent(hwnd), PSWIZB_NEXT);
//
// The CD is done copying so Auto-Advance to the next page
//
// ISSUE-2002/02/28-stelo- this works, but I should really go through
// RouteToProperPage or send a NEXT message but neither work
PostMessage( GetParent(hwnd),
PSM_SETCURSELID,
(WPARAM) 0,
(LPARAM) IDD_FINISH );
break;
case WMX_FILECOPIED:
nPercent = (gnFilesCopied * 100) / gnTotalFiles;
SendDlgItemMessage(hwnd,
IDC_PROGRESS1,
PBM_SETPOS,
(WPARAM) nPercent,
0);
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_QUERYCANCEL:
CancelTheWizard(hwnd);
break;
case PSN_SETACTIVE:
PropSheet_SetWizButtons(GetParent(hwnd), 0);
PostMessage(hwnd, WMX_BEGINCOPYING, 0, 0);
break;
// Can't go back in the wizard from here
case PSN_WIZBACK:
break;
case PSN_WIZNEXT:
break;
default:
bStatus = FALSE;
break;
}
}
break;
default:
bStatus = FALSE;
break;
}
return bStatus;
}
//----------------------------------------------------------------------------
//
// Function: ConfirmFileReplaceDlgProc
//
// Purpose: Confirm file replace dialog proc. Allows the user to chose to
// overwrite the file, overwrite all files, do not overwrite or cancel the
// copy all together. Runs in the copying thread's context
//
// Arguments: standard Win32 dialog proc arguments
//
// Returns: the button the user pressed(Yes, Yes to All, No, Cancel)
//
//----------------------------------------------------------------------------
INT_PTR CALLBACK
ConfirmFileReplaceDlgProc( IN HWND hwnd,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam ) {
BOOL bStatus = TRUE;
switch( uMsg ) {
case WM_INITDIALOG: {
SetWindowText( GetDlgItem( hwnd, IDC_REPLACE_FILE_TEXT),
g_szFileAlreadyExistsText );
SetWindowText( GetDlgItem( hwnd, IDC_SRC_FILE_DATE),
g_szSrcFileDate );
SetWindowText( GetDlgItem( hwnd, IDC_SRC_FILE_SIZE),
g_szSrcFileSize );
SetWindowText( GetDlgItem( hwnd, IDC_DEST_FILE_DATE),
g_szDestFileDate );
SetWindowText( GetDlgItem( hwnd, IDC_DEST_FILE_SIZE),
g_szDestFileSize );
if( g_SetFocusYes ) {
SetFocus( GetDlgItem( hwnd, IDC_YES_BUTTON ) );
}
else {
SetFocus( GetDlgItem( hwnd, IDC_NO_BUTTON ) );
}
break;
}
case WM_COMMAND: {
int nButtonId = LOWORD( wParam );
switch ( nButtonId ) {
case IDC_YES_BUTTON:
{
EndDialog( hwnd, YES );
break;
}
case IDC_YESTOALL:
{
EndDialog( hwnd, YESTOALL );
break;
}
case IDC_NO_BUTTON:
{
EndDialog( hwnd, NO );
break;
}
case IDC_NOTOALL:
{
EndDialog( hwnd, NOTOALL );
break;
}
case IDCANCEL:
{
if( CheckIfCancel( hwnd ) )
{
EndDialog( hwnd, CANCEL );
}
break;
}
}
}
default:
bStatus = FALSE;
break;
}
return( bStatus );
}
Reference in a new issue Copy permalink