able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/clcreator/copyflop.c

952 lines
29 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
COPYFLOP.C
Abstract:
Floppy disk creation setup dialog
Author:
Bob Watson (a-robw)
Revision History:
17 Feb 94 Written
--*/
//
// Windows Include Files
//
#include <windows.h>
#include <stdio.h>
#include <malloc.h>
#include <tchar.h> // unicode macros
//
// app include files
//
#include "otnboot.h"
#include "otnbtdlg.h"
//
// static data for this module
//
//
// mszDirNameList is the local list of directories that corresponds to the
// items displayed in the Client List. This buffer is loaded by the
// LoadClientList routine and the entry index of the directory is the
// Item Data for the list box name entry.
//
static TCHAR mszDirNameList[SMALL_BUFFER_SIZE];
//
// These string arrays are used to cross reference the drive selected
// to the "drive name" for IOCTL functions or the Dir name for file
// operations.
//
static LPCTSTR szDriveNames[2] = {TEXT("\\\\.\\A:"), TEXT("\\\\.\\B:")};
static LPCTSTR szDriveDirs[2] = {TEXT("A:"), TEXT("B:")};
#ifdef TERMSRV
extern TCHAR szCommandLineVal[MAX_PATH];
extern BOOL bUseCleanDisks;
#endif // TERMSRV
static
MEDIA_TYPE
GetDriveTypeFromList (
IN HWND hwndDlg
)
/*++
Routine Description:
Gets the selected drive from the drive list box and looks up the drive
type using the IOCTL function. The drive type enum value is
returned.
NOTE: This function may cause a system error box if there is no media
in the drive or there is a device/drive error.
Arguments:
IN HWND hwndDlg
handle to the dialog box window
Return Value:
value of type MEDIA_TYPE that corresponds to the drive type of the
drive selected in the drive list box.
--*/
{
int nSelIndex;
HANDLE hFloppy;
DWORD dwRetSize;
DISK_GEOMETRY dgFloppy;
// get selected drive
nSelIndex = (int)SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST,
LB_GETCURSEL, 0, 0);
// open device to get type
hFloppy = CreateFile (
szDriveNames[nSelIndex],
0,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFloppy != INVALID_HANDLE_VALUE) {
// get drive information
if (!DeviceIoControl (hFloppy,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL, 0,
&dgFloppy,
sizeof(DISK_GEOMETRY),
&dwRetSize,
NULL) ){
// unable to get data so set to unknown
dgFloppy.MediaType = Unknown;
} // else return data from returned structure
CloseHandle (hFloppy);
} else {
// unable to access floppy, so return unknown
dgFloppy.MediaType = Unknown;
}
return dgFloppy.MediaType;
}
static
VOID
FillDriveList (
IN HWND hwndDlg
)
/*++
Routine Description:
Loads the text strings into the drive selection list box.
NOTE: The order of these entries is significant in that it is
used to index into the static device and drive name arrays.
Arguments:
IN HWND hwndDlg
handle to dialog box window
Return Value:
NONE
--*/
{
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
PDISK_GEOMETRY pDiskGeometry;
HANDLE hDrive;
LPTSTR szDrive;
TCHAR cDriveName;
BYTE nCounter;
BOOL bFloppy;
BOOL bRet;
DWORD dwArryCount;
DWORD dwLastError;
DWORD dwMediaType;
DWORD dwLogicalDrive;
DWORD dwReturnedByteCount;
#endif
// clear list box
SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST, LB_RESETCONTENT, 0, 0);
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
szDrive = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szDrive != NULL) {
dwLogicalDrive = GetLogicalDrives();
for (cDriveName = *cszAColon, nCounter = 0;
cDriveName <= *cszLastDrive;
cDriveName++, nCounter++) {
if ((dwLogicalDrive>>nCounter)&NCDU_LOGICAL_DRIVE_MASK) {
bFloppy = FALSE;
wsprintf (szDrive, TEXT("%s%s%s%c%s"),
cszDoubleBackslash, cszDot, cszBackslash, cDriveName, cszColon);
hDrive = CreateFile (szDrive,
0,
(FILE_SHARE_READ | FILE_SHARE_WRITE),
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hDrive != INVALID_HANDLE_VALUE) {
dwArryCount = 1;
pDiskGeometry = NULL;
do {
if (!pDiskGeometry)
pDiskGeometry = (PDISK_GEOMETRY)
GlobalLock (GlobalAlloc (GHND,
sizeof(DISK_GEOMETRY)*dwArryCount));
else
pDiskGeometry = (PDISK_GEOMETRY)
GlobalLock (GlobalReAlloc (GlobalHandle (pDiskGeometry),
sizeof(DISK_GEOMETRY)*dwArryCount,
GHND));
if (!pDiskGeometry) break;
bRet = DeviceIoControl (hDrive,
IOCTL_DISK_GET_MEDIA_TYPES,
NULL,
0,
pDiskGeometry,
sizeof(DISK_GEOMETRY)*dwArryCount,
&dwReturnedByteCount,
NULL);
dwLastError = GetLastError();
GlobalUnlock(GlobalHandle(pDiskGeometry));
dwArryCount++;
} while ( ! bRet && ( dwLastError == ERROR_INSUFFICIENT_BUFFER ||
dwLastError == ERROR_MORE_DATA ) );
if (pDiskGeometry) {
pDiskGeometry = (PDISK_GEOMETRY)GlobalLock(GlobalHandle(pDiskGeometry));
for (dwMediaType = 0; dwMediaType < (dwArryCount-1); dwMediaType++) {
if (((pDiskGeometry+dwMediaType)->MediaType != Unknown) &&
((pDiskGeometry+dwMediaType)->MediaType != RemovableMedia) &&
((pDiskGeometry+dwMediaType)->MediaType != FixedMedia))
bFloppy = TRUE;
}
GlobalUnlock(GlobalHandle(pDiskGeometry));
GlobalFree(GlobalHandle(pDiskGeometry));
}
if (bFloppy) {
wsprintf (szDrive, TEXT("%c%s"), cDriveName, cszColon);
SendDlgItemMessage (hwndDlg,
NCDU_DRIVE_LIST,
LB_ADDSTRING,
0,
(LPARAM)szDrive);
}
CloseHandle (hDrive);
}
}
}
FREE_IF_ALLOC (szDrive);
} else {
#else
SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST, LB_ADDSTRING, 0, (LPARAM)cszAColon);
SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST, LB_ADDSTRING, 0, (LPARAM)cszBColon);
#endif
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
}
#endif
SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST, LB_SETCURSEL, 0, 0);
}
static
DWORD
NumberOfDisks (
IN HWND hwndDlg
)
/*++
Routine Description:
Counts the number of "disk" directories in the currently selected client
installation disk dir. The method used to count disks relies on the
assumption that each disk's files are in a directory and the
directories are mamed Disk1, Disk2, etc. The count is performed by
looking for each disk directory in sequence and stopping when a
dir is not found. i.e. if disk5 is not found, then 4 disks are
assumed.
Arguments:
Handle to dialog box window
Return Value:
count of directorys ("disks") found
--*/
{
LPTSTR szFromPath;
LPTSTR szDirStart;
BOOL bCounting;
UINT nClientIndex;
DWORD nDiskNumber = 0;
szFromPath = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szFromPath != NULL) {
// get root dir of dist tree
lstrcpy (szFromPath, pAppInfo->szDistPath);
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
// append client sw subdir
nClientIndex = (UINT)SendDlgItemMessage (hwndDlg, NCDU_CLIENT_SOFTWARE_LIST,
LB_GETCURSEL, 0, 0);
lstrcat (szFromPath, GetEntryInMultiSz (mszDirNameList, nClientIndex+1));
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
lstrcat (szFromPath, cszDisksSubDir);
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
szDirStart = &szFromPath[lstrlen(szFromPath)];
// count directories
bCounting = TRUE;
nDiskNumber = 0;
while (bCounting) {
nDiskNumber++;
_stprintf (szDirStart, fmtDiskNumber,
nDiskNumber);
bCounting = IsPathADir (szFromPath);
}
// account for last directory that wasn't found
nDiskNumber -= 1;
FREE_IF_ALLOC (szFromPath);
}
return nDiskNumber; // for now
}
static
BOOL
UpdateDiskCount (
IN HWND hwndDlg
)
/*++
Routine Description:
updates the disk count text displayed in the dialog box.
Arguments:
IN HWND hwndDlg
handle to dialog box window
Return Value:
TRUE if display updated successfully
FALSE if not.
--*/
{
LPTSTR szBuffer;
DWORD dwNumDisks;
szBuffer = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szBuffer != NULL) {
dwNumDisks = NumberOfDisks (hwndDlg);
if (dwNumDisks == 1) {
_stprintf (szBuffer, GetStringResource (FMT_1_DISK_REQUIRED));
} else {
_stprintf (szBuffer, GetStringResource (FMT_N_DISKS_REQUIRED),
dwNumDisks);
}
SetDlgItemText (hwndDlg, NCDU_NUM_DISKS_REQUIRED, szBuffer);
FREE_IF_ALLOC (szBuffer);
return TRUE;
} else {
return FALSE;
}
}
static
BOOL
CopyFlopDlg_WM_INITDIALOG (
IN HWND hwndDlg,
IN WPARAM wParam,
IN LPARAM lParam
)
/*++
Routine Description:
Dialog box initialization routine. Loads list boxes in dialog
Arguments:
IN HWND hwndDlg
Handle to dialog box window
IN WPARAM wParam
Not used
IN LPARAM lParam
Not used
Return Value:
FALSE, always.
--*/
{
// update dialog window menu and position
RemoveMaximizeFromSysMenu (hwndDlg);
PositionWindow (hwndDlg);
// load clients to display
LoadClientList (hwndDlg, NCDU_CLIENT_SOFTWARE_LIST,
pAppInfo->szDistPath, CLT_FLOPPY_INSTALL, mszDirNameList);
// set selection
SendDlgItemMessage (hwndDlg, NCDU_CLIENT_SOFTWARE_LIST,
LB_SETCURSEL, (WPARAM)0, (LPARAM)0);
// load drives to select from
FillDriveList(hwndDlg);
// update disk count to reflect default selection
UpdateDiskCount (hwndDlg);
// clear old Dialog and register current
PostMessage (GetParent(hwndDlg), NCDU_CLEAR_DLG, (WPARAM)hwndDlg, IDOK);
PostMessage (GetParent(hwndDlg), NCDU_REGISTER_DLG,
NCDU_CREATE_INSTALL_DISKS_DLG, (LPARAM)hwndDlg);
// set cursor and focus
SetCursor(LoadCursor(NULL, IDC_ARROW));
SetFocus (GetDlgItem(hwndDlg, NCDU_MAKE_DISKS));
return FALSE;
}
static
BOOL
CopyFlopDlg_NCDU_MAKE_DISKS (
IN HWND hwndDlg
)
/*++
Routine Description:
Function to copy the client files to the floppy disks.
Selects the source directory using the client name and
disk type then copies the files to the floppy disks
sequentially assuming that the contents of each disk
are stored in sub directory named "DiskX" where X is the
decimal number indicating the disk sequence (e.g. 1, 2, 3, etc.)
Arguments:
IN HWND hwndDlg
Handle to dialog box window
Return Value:
FALSE, always.
--*/
{
MEDIA_TYPE mtFloppy;
LPTSTR szFromPath;
LPTSTR szInfName;
TCHAR szSubDir[16];
TCHAR szDestRoot[4];
TCHAR szDriveRoot[8];
LPTSTR szClientName;
LPTSTR szDisplayName;
LPTSTR szDirStart;
LPTSTR szDiskName;
LPTSTR szClientSection;
LPTSTR szDisplayString;
LPTSTR szVolumeLabel;
DWORD dwFileAttr;
BOOL bCopyFiles;
int nSelIndex;
int nClientIndex;
int nCancelResult = 0;
int nDiskNumber;
CF_DLG_DATA cfData;
BOOL bFormatDisks;
#ifdef TERMSRV
int nDiskCount;
#endif // TERMSRV
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
//
// Buffer for real FD path
//
TCHAR szDriveName[10];
TCHAR szDriveDir[5];
#endif
szFromPath = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szInfName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szClientName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szDisplayName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szDiskName = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szClientSection = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
szVolumeLabel = (LPTSTR)GlobalAlloc (GPTR, MAX_PATH_BYTES);
if ((szFromPath == NULL) ||
(szClientName == NULL) ||
(szClientSection == NULL) ||
(szInfName == NULL) ||
(szDiskName == NULL) ||
(szVolumeLabel == NULL) ||
(szDisplayName == NULL)) {
// message not processed
return FALSE;
}
// check floppy selection to see if it's supported
//
// This function is really flakey, so for now, (for ever?)
// we'll assume they are using a HD disk drive
//
// mtFloppy = GetDriveTypeFromList (hwndDlg);
//
mtFloppy = F3_1Pt44_512;
if ((mtFloppy == F5_1Pt2_512) || // 5.25 HD
(mtFloppy == F3_1Pt44_512)) { // 3.5 HD
// get format check box state
bFormatDisks = (BOOL)(IsDlgButtonChecked (hwndDlg, NCDU_FORMAT_DISKS) == CHECKED);
// then this is a supported format
// make source path using:
// dist tree + client type + "disks" + drive type
//
// get root dir of dist tree
lstrcpy (szFromPath, pAppInfo->szDistPath);
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
// append client sw subdir
nClientIndex = (int)SendDlgItemMessage (hwndDlg, NCDU_CLIENT_SOFTWARE_LIST,
LB_GETCURSEL, 0, 0);
lstrcat (szFromPath, GetEntryInMultiSz (mszDirNameList, nClientIndex+1));
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
lstrcat (szFromPath, cszDisksSubDir);
// make INF file Name
lstrcpy (szInfName, pAppInfo->szDistPath);
if (szInfName[lstrlen(szInfName)-1] != cBackslash) lstrcat (szInfName, cszBackslash);
lstrcat (szInfName, cszAppInfName);
// get client name
SendDlgItemMessage (hwndDlg, NCDU_CLIENT_SOFTWARE_LIST,
LB_GETTEXT, (WPARAM)nClientIndex, (LPARAM)szClientName);
if (szFromPath[lstrlen(szFromPath)-1] != cBackslash) lstrcat (szFromPath, cszBackslash);
szDirStart = &szFromPath[lstrlen(szFromPath)];
nSelIndex = (int)SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST,
LB_GETCURSEL, 0, 0);
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
// get real FD path
SendDlgItemMessage (hwndDlg, NCDU_DRIVE_LIST,
LB_GETTEXT, nSelIndex, (LPARAM)szDriveDir);
wsprintf(szDriveName, TEXT("%s%s%s%s"), cszBackslash,cszBackslash,cszColon,cszBackslash);
lstrcat(szDriveName, szDriveDir);
#endif
// format client name key used to look up disk names in INF
lstrcpy (szClientSection, GetEntryInMultiSz (mszDirNameList, nClientIndex+1));
lstrcat (szClientSection, cszNames);
// set the destination path
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
lstrcpy (szDestRoot, szDriveDir);
lstrcpy (szDriveRoot, szDriveName);
lstrcat (szDriveRoot, cszBackslash);
#else
lstrcpy (szDestRoot, szDriveDirs[nSelIndex]);
lstrcpy (szDriveRoot, szDriveNames[nSelIndex]);
lstrcat (szDriveRoot, cszBackslash);
#endif
nDiskNumber = 1;
_stprintf (szSubDir, fmtDiskNumber, nDiskNumber);
lstrcpy (szDirStart, szSubDir);
if ((dwFileAttr = QuietGetFileAttributes(szFromPath)) != 0xFFFFFFFF) {
bCopyFiles = TRUE;
} else {
bCopyFiles = FALSE;
}
// initialize counter fields
cfData.dwFilesCopied = 0;
cfData.dwDirsCreated = 0;
while (bCopyFiles) {
if ((dwFileAttr & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY) {
// see if this disk has a name, if so display it, otherwise
// just show the disk number
if (QuietGetPrivateProfileString (szClientSection, szSubDir,
cszEmptyString, szDiskName, MAX_PATH, szInfName) == 0) {
lstrcpy (szDiskName, szSubDir);
} else {
// append "disk" to the name string
lstrcat (szDiskName, cszDisk);
}
// display "load the floppy" message
_stprintf (szDisplayName,
GetStringResource (FMT_CLIENT_DISK_AND_DRIVE),
#ifdef JAPAN
// fixed kkntbug #11940
// Network client administrator can not make install disks on PC with C drive as FD
szClientName, szDiskName, szDriveDir);
#else
szClientName, szDiskName, szDriveDirs[nSelIndex]);
#endif
nCancelResult = MessageBox (
hwndDlg,
szDisplayName,
GetStringResource (FMT_INSERT_FLOPPY),
MB_OKCANCEL_TASK_INFO);
if (nCancelResult == IDOK) {
// format the copying files message
_stprintf (szDisplayName,
GetStringResource (FMT_CLIENT_DISPLAY_NAME),
szClientName, szDiskName);
// set the disk volume label if one is in the INF
lstrcat (szSubDir, cszLabel);
if (QuietGetPrivateProfileString (szClientSection, szSubDir,
cszEmptyString, szVolumeLabel, MAX_PATH, szInfName) > 0) {
}
if (bFormatDisks) {
while (!FormatDiskInDrive (hwndDlg,
szDestRoot[0],
szVolumeLabel,
TRUE)) {
// an error occured so see if they want to try again or bail out
if (DisplayMessageBox (hwndDlg,
IDS_CORRECT_FMT_ERROR,
FMT_INSERT_FLOPPY,
MB_OKCANCEL_TASK_EXCL) == IDCANCEL) {
bCopyFiles = FALSE;
nCancelResult = IDCANCEL;
break; // now exit retry loop
}
}
if (!bCopyFiles) continue; // bail out at the top
}
cfData.szDisplayName = szDisplayName;
cfData.szSourceDir = szFromPath;
cfData.szDestDir = szDestRoot;
cfData.dwCopyFlags = CD_FLAGS_COPY_SUB_DIR | CD_FLAGS_COPY_ATTR | CD_FLAGS_IGNORE_ERROR;
cfData.dwTotalSize = 0;
if (bUseCleanDisks) {
WIN32_FIND_DATA fdSearch;
TCHAR filesToFind[8];
HANDLE hSearch;
BOOL bDiskContainsFiles;
lstrcpy(filesToFind, szDestRoot);
if (filesToFind[lstrlen(filesToFind)-1] != cBackslash) {
lstrcat (filesToFind, cszBackslash);
}
lstrcat(filesToFind, cszWildcard);
// loop till the user inserts an empty disk, or hits cancel.
do {
nCancelResult = IDOK;
bDiskContainsFiles = FALSE;
hSearch = FindFirstFile(filesToFind, &fdSearch);
if(hSearch != INVALID_HANDLE_VALUE) {
BOOL bSearching = TRUE;
while (bSearching) {
if (!DotOrDotDotDir(fdSearch.cFileName)) {
//
// looks like some files are already existing there..
//
bDiskContainsFiles = TRUE;
nCancelResult = DisplayMessageBox (
hwndDlg,
NCDU_CLEAN_DISK_REQUIRED,
0,
(MB_OKCANCEL | MB_ICONERROR | MB_TASKMODAL));
break;
}
bSearching = FindNextFile(hSearch, &fdSearch);
}
FindClose(hSearch);
}
}
while (bDiskContainsFiles && nCancelResult != IDCANCEL);
if (nCancelResult == IDCANCEL) {
bCopyFiles = FALSE;
}
}
if (!bCopyFiles) continue; // bail out at the top
nCancelResult = (int)DialogBoxParam (
(HANDLE)GetWindowLongPtr(GetParent(hwndDlg), GWLP_HINSTANCE),
MAKEINTRESOURCE(NCDU_COPYING_FILES_DLG),
hwndDlg,
CopyFileDlgProc,
(LPARAM)&cfData);
if (nCancelResult == IDCANCEL) {
bCopyFiles = FALSE;
} else {
// set volume label (if not set already)
if ((!bFormatDisks) & (lstrlen(szVolumeLabel) > 0)) {
// set volume label here
LabelDiskInDrive (hwndDlg, szDestRoot[0], szVolumeLabel);
}
}
} else {
bCopyFiles = FALSE;
}
}
if (bCopyFiles) {
_stprintf (szSubDir, fmtDiskNumber, ++nDiskNumber);
lstrcpy (szDirStart, szSubDir);
if ((dwFileAttr = QuietGetFileAttributes(szFromPath)) != 0xFFFFFFFF) {
bCopyFiles = TRUE;
} else {
bCopyFiles = FALSE;
}
}
}
if (nCancelResult != IDCANCEL) {
szDisplayString = GlobalAlloc (GPTR, MAX_PATH_BYTES);
if (szDisplayString == NULL) {
// unable to allocate string buffer so try default message
DisplayMessageBox (
hwndDlg,
NCDU_COPY_COMPLETE,
0,
MB_OK_TASK_INFO);
} else {
#ifdef TERMSRV
nDiskCount = NumberOfDisks(hwndDlg);
_stprintf (szDisplayString,
GetStringResource (
//(cfData.dwDirsCreated == 1) ?
(nDiskCount == 1) ?
FMT_COPY_COMPLETE_STATS1 :
FMT_COPY_COMPLETE_STATS2),
nDiskCount, cfData.dwFilesCopied);
#else // TERMSRV
_stprintf (szDisplayString,
GetStringResource (FMT_COPY_COMPLETE_STATS),
cfData.dwDirsCreated, cfData.dwFilesCopied);
#endif // TERMSRV
MessageBox (
hwndDlg, szDisplayString,
GetStringResource (SZ_APP_TITLE),
MB_OK_TASK_INFO);
FREE_IF_ALLOC (szDisplayString);
}
} else {
DisplayMessageBox (
hwndDlg,
NCDU_DISK_NOT_DONE,
0,
MB_OK_TASK_EXCL);
}
PostMessage (GetParent(hwndDlg), NCDU_SHOW_SW_CONFIG_DLG, 0, 0);
SetCursor(LoadCursor(NULL, IDC_WAIT));
} else {
// unsupported format
nCancelResult = DisplayMessageBox (
hwndDlg,
NCDU_UNKNOWN_FLOPPY,
0,
MB_OK_TASK_EXCL);
}
FREE_IF_ALLOC (szFromPath);
FREE_IF_ALLOC (szClientName);
FREE_IF_ALLOC (szDisplayName);
FREE_IF_ALLOC (szInfName);
FREE_IF_ALLOC (szDiskName);
FREE_IF_ALLOC (szVolumeLabel);
FREE_IF_ALLOC (szClientSection);
return TRUE;
}
static
BOOL
CopyFlopDlg_WM_COMMAND (
IN HWND hwndDlg,
IN WPARAM wParam,
IN LPARAM lParam
)
/*++
Routine Description:
processes the WM_COMMAND windows message. The only buttons processed
are:
IDCANCEL which will cause the dlg box to exit.
Make Disks start the copy file process
Arguments:
IN HWND hwndDlg
Handle to dialog box window
IN WPARAM wParam
LOWORD has ID of control selected
IN LPARAM lParam
Not Used.
Return Value:
TRUE if message not processed,
otherwise value returned by selected function
--*/
{
switch (LOWORD(wParam)) {
case IDCANCEL:
switch (HIWORD(wParam)) {
case BN_CLICKED:
#ifdef TERMSRV
if ( szCommandLineVal[0] != 0x00 )
PostQuitMessage(ERROR_SUCCESS);
#endif // TERMSRV
PostMessage (GetParent(hwndDlg), NCDU_SHOW_SHARE_NET_SW_DLG, 0, 0);
SetCursor(LoadCursor(NULL, IDC_WAIT));
return TRUE;
default:
return FALSE;
}
case NCDU_CLIENT_SOFTWARE_LIST:
switch (HIWORD(wParam)) {
case LBN_SELCHANGE:
// update the disk count for the currently selected client
UpdateDiskCount (hwndDlg);
return TRUE;
case LBN_DBLCLK:
// pretend that the OK buton was pressed
PostMessage (hwndDlg, WM_COMMAND,
MAKEWPARAM (NCDU_MAKE_DISKS, BN_CLICKED),
(LPARAM)GetDlgItem(hwndDlg, NCDU_MAKE_DISKS));
return TRUE;
default:
return FALSE;
}
case NCDU_MAKE_DISKS: return CopyFlopDlg_NCDU_MAKE_DISKS (hwndDlg);
case NCDU_CREATE_INSTALL_DISKS_HELP:
switch (HIWORD(wParam)) {
case BN_CLICKED:
// return ShowAppHelp (hwndDlg, LOWORD(wParam));
return PostMessage (GetParent(hwndDlg), WM_HOTKEY,
(WPARAM)NCDU_HELP_HOT_KEY, 0);
default:
return FALSE;
}
default: return TRUE;
}
}
INT_PTR CALLBACK
CopyFlopDlgProc (
IN HWND hwndDlg,
IN UINT message,
IN WPARAM wParam,
IN LPARAM lParam
)
/*++
Routine Description:
Main window processing routine. Processes the following messages by
dispatching to the local processing routine. All other messages
are handled by the default dialog procedure.
WM_INITDIALOG: dialog box initialization
WM_COMMAND: user input message
WM_PAINT: for painting icon when minimized
WM_MOVE: for saving the new location of the window
WM_SYSCOMMAND: for processing menu messages
Arguments:
standard WNDPROC arguments
Return Value:
FALSE if message not processed here, otherwise
value returned by dispatched routine.
--*/
{
switch (message) {
case WM_INITDIALOG: return (CopyFlopDlg_WM_INITDIALOG (hwndDlg, wParam, lParam));
case WM_COMMAND: return (CopyFlopDlg_WM_COMMAND (hwndDlg, wParam, lParam));
case WM_PAINT: return (Dlg_WM_PAINT (hwndDlg, wParam, lParam));
case WM_MOVE: return (Dlg_WM_MOVE (hwndDlg, wParam, lParam));
case WM_SYSCOMMAND: return (Dlg_WM_SYSCOMMAND (hwndDlg, wParam, lParam));
default: return FALSE;
}
}
Reference in a new issue Copy permalink