//---------------------------------------------------------------------------- // // Copyright (c) 1997-1999 Microsoft Corporation // All rights reserved. // // File Name: // copyfil1.c // // Description: // This file has the dlgproc for the CopyFiles1 page. This is the // page just before the gas-guage. // //---------------------------------------------------------------------------- #include "pch.h" #include "sku.h" static TCHAR *StrServerCdName; static TCHAR *StrWorkStationCdName; static NAMELIST DosnetPaths; TCHAR szDosnetPath[MAX_PATH + 1]; #define WORKSTATION 0 #define SERVER 1 #define ENTERPRISE 2 #define PERSONAL 4 #define WEBBLADE 5 static LPTSTR s_lpSourceDirs[] = { DIR_CD_IA64, // Must be before x86 because ia64 has both dirs. DIR_CD_X86, // Should always be last in the list. }; //---------------------------------------------------------------------------- // // Function: OnMultipleDosnetInitDialog // // Purpose: Fill the dosnet list box with the possible path choices for // the user. // // Arguments: IN HWND hwnd - handle to the dialog // // Returns: VOID // //---------------------------------------------------------------------------- static VOID OnMultipleDosnetInitDialog( IN HWND hwnd ) { INT i; INT nEntries; TCHAR *pDosnetPath; nEntries = GetNameListSize( &DosnetPaths ); for( i = 0; i < nEntries; i++ ) { pDosnetPath = GetNameListName( &DosnetPaths, i ); SendDlgItemMessage( hwnd, IDC_LB_DOSNET_PATHS, LB_ADDSTRING, (WPARAM) 0, (LPARAM) pDosnetPath ); } } //---------------------------------------------------------------------------- // // Function: OnMultipleDosnetOk // // Purpose: // // Arguments: IN HWND hwnd - handle to the dialog // // Returns: BOOL - TRUE if safe to close the pop-up, FALSE to keep the pop-up // open // //---------------------------------------------------------------------------- static BOOL OnMultipleDosnetOk( IN HWND hwnd ) { INT_PTR iRetVal; iRetVal = SendDlgItemMessage( hwnd, IDC_LB_DOSNET_PATHS, LB_GETCURSEL, 0, 0 ); if( iRetVal == LB_ERR ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NO_PATH_CHOSEN ); return( FALSE ); } else { SendDlgItemMessage( hwnd, IDC_LB_DOSNET_PATHS, LB_GETTEXT, (WPARAM) iRetVal, (LPARAM) szDosnetPath ); return( TRUE ); } } //---------------------------------------------------------------------------- // // Function: MultipleDosnetDlg // // Purpose: Dialog procedure for the user to select what windows source file // dir they want to tree copy. // // Arguments: standard Win32 dialog proc arguments // // Returns: standard Win32 dialog proc return value -- whether the message // was handled or not // //---------------------------------------------------------------------------- INT_PTR CALLBACK MultipleDosnetDlg( IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam ) { BOOL bStatus = TRUE; switch (uMsg) { case WM_INITDIALOG: OnMultipleDosnetInitDialog( hwnd ); break; case WM_COMMAND: { int nButtonId; switch ( nButtonId = LOWORD (wParam ) ) { case IDOK: { BOOL bSelectionMade; bSelectionMade = OnMultipleDosnetOk( hwnd ); if( bSelectionMade ) { EndDialog( hwnd, TRUE ); } break; } case IDCANCEL: EndDialog( hwnd, FALSE ); break; } } default: bStatus = FALSE; break; } return( bStatus ); } //---------------------------------------------------------------------------- // // Function: GreyUnGreyCopyFile1 // // Purpose: Called to grey/ungrey the controls. Call this routine each // time a radio button is clicked or set. // //---------------------------------------------------------------------------- VOID GreyUnGreyCopyFile1(HWND hwnd) { BOOL bUnGrey = IsDlgButtonChecked(hwnd, IDC_COPYFROMPATH); EnableWindow(GetDlgItem(hwnd, IDT_SOURCEPATH), bUnGrey); EnableWindow(GetDlgItem(hwnd, IDC_BROWSE), bUnGrey); EnableWindow(GetDlgItem(hwnd, IDC_GREYTEXT), bUnGrey); } //---------------------------------------------------------------------------- // // Function: OnSetActiveCopyFiles1 // // Purpose: Called at SETACTIVE time // //---------------------------------------------------------------------------- VOID OnSetActiveCopyFiles1(HWND hwnd) { CheckRadioButton(hwnd, IDC_COPYFROMCD, IDC_COPYFROMPATH, WizGlobals.bCopyFromPath ? IDC_COPYFROMPATH : IDC_COPYFROMCD); GreyUnGreyCopyFile1(hwnd); ZeroMemory( &DosnetPaths, sizeof(NAMELIST) ); WIZ_BUTTONS(hwnd, PSWIZB_BACK | PSWIZB_NEXT); } //---------------------------------------------------------------------------- // // Function: OnRadioButtonCopyFiles1 // // Purpose: Called when a radio button is pushed. We must grey/ungrey // controls when this happens. // //---------------------------------------------------------------------------- VOID OnRadioButtonCopyFiles1(HWND hwnd, int nButtonId) { CheckRadioButton(hwnd, IDC_COPYFROMCD, IDC_COPYFROMPATH, nButtonId); GreyUnGreyCopyFile1(hwnd); } //---------------------------------------------------------------------------- // // Function: OnBrowseCopyFiles1 // // Purpose: Called when user pushes the BROWSE button // //---------------------------------------------------------------------------- VOID OnBrowseCopyFiles1(HWND hwnd) { BOOL bGoodSource = FALSE; while (!bGoodSource && BrowseForFolder(hwnd, IDS_BROWSEFOLDER, WizGlobals.CopySourcePath, BIF_DONTGOBELOWDOMAIN | BIF_RETURNONLYFSDIRS | BIF_EDITBOX | BIF_VALIDATE)) { TCHAR szPath[MAX_PATH] = NULLSTR; LPTSTR lpEnd, lpEnd2; // Make our own copy of the path we got back. // lstrcpyn(szPath, WizGlobals.CopySourcePath,AS(szPath)); // First check and see if we have the inf we need right here. // lpEnd = szPath + lstrlen(szPath); AddPathN(szPath, FILE_DOSNET_INF, AS(szPath)); if ( !(bGoodSource = FileExists(szPath)) ) { DWORD dwSearch; // Search for all the possible source directories that could be on the CD. // for ( dwSearch = 0; !bGoodSource && ( dwSearch < AS(s_lpSourceDirs) ); dwSearch++ ) { // First test for the directory. // *lpEnd = NULLCHR; AddPathN(szPath, s_lpSourceDirs[dwSearch],AS(szPath)); if ( DirectoryExists(szPath) ) { // Also make sure that the inf file we need is there. // lpEnd2 = szPath + lstrlen(szPath); AddPathN(szPath, FILE_DOSNET_INF,AS(szPath)); if ( bGoodSource = FileExists(szPath) ) lpEnd = lpEnd2; } } } // Let the user know that they have a bad source // if ( !bGoodSource) { MsgBox(GetParent(hwnd), IDS_ERR_BADSOURCE, IDS_APPNAME, MB_ERRORBOX); } } // Set the source in the dialog only if the source was good // if ( bGoodSource ) { SetDlgItemText(hwnd, IDT_SOURCEPATH, WizGlobals.CopySourcePath); } } //---------------------------------------------------------------------------- // // Function: CanConnectToNetworkShare // // Purpose: To determine if the currently logged in user has permission to // access the UNC path given. // // Arguments: // TCHAR *szSourceFilesPath - path to the source files that contains the // UNC path to see if we can connect // // Returns: // TRUE if user has permission to access the network share // FALSE if not // //---------------------------------------------------------------------------- static BOOL CanConnectToNetworkShare( IN TCHAR *pszSourceFilesPath ) { TCHAR *pPathEnd; TCHAR szUncPath[MAX_PATH + 1]; INT nBackSlashCount = 0; DWORD dwResult; NETRESOURCE NetResource; // // Verify it is a UNC path. // AssertMsg( ( pszSourceFilesPath[0] == _T('\\') && pszSourceFilesPath[1] == _T('\\') ), "This is not a UNC path." ); // ISSUE-2002/02/28-stelo- in the next release it would be nice to prompt the user for a // name and password to connect to the network share lstrcpyn( szUncPath, pszSourceFilesPath, AS(szUncPath) ); // // Strip off the extra dir info so we are just left with \\computername\sharename // pPathEnd = szUncPath; // // Advance past the 2 leading backslashes // pPathEnd = pPathEnd + 2; while( *pPathEnd != _T('\0') ) { if( *pPathEnd == _T('\\') ) { if( nBackSlashCount == 0 ) { // // Found the backslash that separates the computername and sharename // nBackSlashCount++; } else // nBackSlashCount >= 1 { // // Found the end of the sharename // *pPathEnd = _T('\0'); break; } } pPathEnd++; } // // Assign values to the NETRESOURCE structure. // NetResource.dwType = RESOURCETYPE_ANY; NetResource.lpLocalName = NULL; NetResource.lpRemoteName = (LPTSTR) szUncPath; NetResource.lpProvider = NULL; // // Try to connect as the local user // dwResult = WNetAddConnection2( &NetResource, NULL, NULL, FALSE ); switch( dwResult ) { case NO_ERROR: case ERROR_ALREADY_ASSIGNED: return( TRUE ); break; case ERROR_ACCESS_DENIED: case ERROR_LOGON_FAILURE: ReportErrorId( NULL, MSGTYPE_ERR, IDS_ERR_NETWORK_ACCESS_DENIED, szUncPath ); return( FALSE ); break; case ERROR_NO_NETWORK: ReportErrorId( NULL, MSGTYPE_ERR, IDS_ERR_NETWORK_NO_NETWORK, szUncPath ); return( FALSE ); break; default: // // some other error // ReportErrorId( NULL, MSGTYPE_ERR, IDS_ERR_NETWORK_UNKNOWN_ERROR, szUncPath ); return( FALSE ); break; } } //---------------------------------------------------------------------------- // // Function: IsCorrectNtVersion // // Purpose: Checks the txtsetup.sif to make sure the files are at least NT5 // and that it is the correct version (workstation or server). // // Arguments: // TCHAR *szSourceFilesPath - path to the source files to validate // // Returns: // TRUE if NT version info is correct // FALSE if not the correct version // //---------------------------------------------------------------------------- BOOL IsCorrectNtVersion( IN HWND hwnd, IN TCHAR *szSourceFilesPath ) { HINF hTxtsetupSif; INFCONTEXT TxtsetupSifContext; TCHAR szTempBuffer[MAX_INILINE_LEN]; INT iMajorVersion; INT iPlatformType; TCHAR szMajorVersionNumber[MAX_STRING_LEN]; TCHAR szPlatformType[MAX_STRING_LEN]; TCHAR szTxtsetupSif[MAX_PATH] = _T(""); BOOL bKeepReading = TRUE; BOOL bFoundVersion = FALSE; BOOL bFoundProductType = FALSE; HRESULT hrCat; lstrcpyn( szTxtsetupSif, szSourceFilesPath, AS(szTxtsetupSif) ); hrCat=StringCchCat( szTxtsetupSif,AS(szTxtsetupSif), _T("\\txtsetup.sif") ); hTxtsetupSif = SetupOpenInfFile( szTxtsetupSif, NULL, INF_STYLE_OLDNT | INF_STYLE_WIN4, NULL ); if( hTxtsetupSif == INVALID_HANDLE_VALUE ) { // ISSUE-2002/02/28-stelo- alert an error that we couldn't open the file or just // skip over in this case? return( FALSE ); } TxtsetupSifContext.Inf = hTxtsetupSif; TxtsetupSifContext.CurrentInf = hTxtsetupSif; bKeepReading = SetupFindFirstLine( hTxtsetupSif, _T("SetupData"), NULL, &TxtsetupSifContext ); // // Look for the ProductType key and the MajorVersion key // while( bKeepReading && ( ! bFoundVersion || ! bFoundProductType ) ) { SetupGetStringField( &TxtsetupSifContext, 0, szTempBuffer, MAX_INILINE_LEN, NULL ); if( LSTRCMPI( szTempBuffer, _T("ProductType") ) == 0 ) { SetupGetStringField( &TxtsetupSifContext, 1, szPlatformType, MAX_STRING_LEN, NULL ); bFoundProductType = TRUE; } if( LSTRCMPI( szTempBuffer, _T("MajorVersion") ) == 0 ) { SetupGetStringField( &TxtsetupSifContext, 1, szMajorVersionNumber, MAX_STRING_LEN, NULL ); bFoundVersion = TRUE; } // // move to the next line of the answer file // bKeepReading = SetupFindNextLine( &TxtsetupSifContext, &TxtsetupSifContext ); } SetupCloseInfFile( hTxtsetupSif ); // // Convert the NT version number and product type from a string to an int // iMajorVersion = _wtoi( szMajorVersionNumber ); iPlatformType = _wtoi( szPlatformType ); // // Make sure it is at least NT5 (Windows 2000) files // if( bFoundVersion ) { if( iMajorVersion < 5 ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_NT5_FILES ); return( FALSE ); } } else { INT iRet; iRet = ReportErrorId( hwnd, MSGTYPE_YESNO, IDS_ERR_CANNOT_DETERMINE_VERSION ); if( iRet == IDNO ) { return( FALSE ); } } // // Make sure they are actually giving us workstation files, if they // specified workstation or server files if they specified server. // if( bFoundVersion ) { if( WizGlobals.iPlatform == PLATFORM_PERSONAL ) { if( iPlatformType != PERSONAL ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_PERSONAL_FILES ); return( FALSE ); } } else if( WizGlobals.iPlatform == PLATFORM_WORKSTATION ) { if( iPlatformType != WORKSTATION ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_WORKSTATION_FILES ); return( FALSE ); } } else if( WizGlobals.iPlatform == PLATFORM_SERVER ) { if( iPlatformType != SERVER ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_SERVER_FILES ); return( FALSE ); } } else if( WizGlobals.iPlatform == PLATFORM_WEBBLADE ) { if( iPlatformType != WEBBLADE ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_WEBBLADE_FILES ); return( FALSE ); } } else if( WizGlobals.iPlatform == PLATFORM_ENTERPRISE ) { if( iPlatformType != ENTERPRISE ) { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_NOT_ENTERPRISE_FILES ); return( FALSE ); } } else { // // If we get to this page, the product install type has to be either // workstation or server. // AssertMsg( FALSE, "Bad product install type." ); } } else { INT iRet; iRet = ReportErrorId( hwnd, MSGTYPE_YESNO, IDS_ERR_CANNOT_DETERMINE_PRODUCT ); if( iRet == IDNO ) { return( FALSE ); } } return( TRUE ); } //---------------------------------------------------------------------------- // // Function: RecurseDirectories // // Purpose: // // Arguments: // // Returns: // //---------------------------------------------------------------------------- static VOID RecurseDirectories( IN HWND hwnd, IN OUT LPTSTR RootBuffer, IN DWORD cbSize ) { LPTSTR RootPathEnd = RootBuffer + lstrlen( RootBuffer ); HANDLE FindHandle; WIN32_FIND_DATA FindData; TCHAR szOriginalPath[MAX_PATH + 1] = _T(""); // // Backup the original path so it can be restored later // lstrcpyn( szOriginalPath, RootBuffer, AS(szOriginalPath) ); // // Look for * in this dir // if( ! ConcatenatePaths( RootBuffer, _T("*") , NULL) ) { // // Restore the original path before returning // lstrcpyn( RootBuffer, szOriginalPath, cbSize ); return; } FindHandle = FindFirstFile( RootBuffer, &FindData ); if( FindHandle == INVALID_HANDLE_VALUE ) { // // Restore the original path before returning // lstrcpyn( RootBuffer, szOriginalPath, cbSize ); return; } do { *RootPathEnd = _T('\0'); // // skip over the . and .. entries // if( 0 == lstrcmp( FindData.cFileName, _T("." ) ) || 0 == lstrcmp( FindData.cFileName, _T("..") ) ) { continue; } if( LSTRCMPI( FindData.cFileName, _T("dosnet.inf") ) == 0 ) { AddNameToNameList( &DosnetPaths, RootBuffer ); } else if( FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) { // // If this is a dirent, recurse. // if( ! ConcatenatePaths( RootBuffer, FindData.cFileName, NULL ) ) { continue; } RecurseDirectories( hwnd, RootBuffer, cbSize); } } while ( FindNextFile( FindHandle, &FindData ) ); *RootPathEnd = _T('\0'); FindClose( FindHandle ); // // Restore the original path // lstrcpyn( RootBuffer, szOriginalPath, cbSize ); } //---------------------------------------------------------------------------- // // Function: FindWindowsSourceFilesPaths // // Purpose: Find all the dirs on the CD that contain dosnet.inf. If there // is more than one pop-up a dialog and have the user pick one. // // Arguments: // // Returns: // //---------------------------------------------------------------------------- static BOOL FindWindowsSourceFilesPaths( IN HWND hwnd, LPTSTR PathBuffer, DWORD cbSize ) { TCHAR *pDosnetPath; RecurseDirectories( hwnd, PathBuffer, cbSize ); if( GetNameListSize( &DosnetPaths ) > 1 ) { if( DialogBox( FixedGlobals.hInstance, MAKEINTRESOURCE( IDD_MULTIPLE_DOSNET_POPUP ), hwnd, MultipleDosnetDlg ) ) { lstrcpyn( PathBuffer, szDosnetPath, cbSize ); return( TRUE ); } else { return( FALSE ); } } else { pDosnetPath = GetNameListName( &DosnetPaths, 0 ); lstrcpyn( PathBuffer, pDosnetPath, cbSize ); if ( PathBuffer[0] ) return(TRUE); else return(FALSE); } } //---------------------------------------------------------------------------- // // Function: GetCdPath // // Purpose: Figures out the full pathname of the NT source files on the CD. // // Arguments: // HWND hwnd - current dialog // // Returns: // TRUE if all is ok // FALSE if errors, Don't let wizard proceed // // WizGlobals.CdSourcePath will contain the valid path to the source // files on success. // // Note, we don't override CopySourcePath because it displays to the // user. He shouldn't see a CD path appear in this edit field when // choosing to "Copy from CD". // // Notes: // - We look only at the 1st cd drive we find // - We figure out i386 or alpha based on what is in the drive // //---------------------------------------------------------------------------- BOOL GetCdPath(HWND hwnd) { TCHAR DriveLetters[MAX_PATH], *p, *pEnd, PathBuffer[MAX_PATH + 1]; int i; TCHAR *pProductName; if( WizGlobals.iPlatform == PLATFORM_SERVER ) pProductName = StrServerCdName; else pProductName = StrWorkStationCdName; // // Find the CD-ROM // // GetLogicalDriveStrings() fills in the DriveLetters buffer, and it // looks like: // // c:\(null)d:\(null)x:\(null)(null) // // (i.e. double-null at the end) // // ISSUE-2002/02/28-stelo- only checks the first CD-ROM drive on this machine if ( ! GetLogicalDriveStrings(MAX_PATH, DriveLetters) ) DriveLetters[0] = _T('\0'); p = DriveLetters; while ( *p ) { if ( GetDriveType(p) == DRIVE_CDROM ) { lstrcpyn(PathBuffer, p, AS(PathBuffer)); break; } while ( *p++ ); } // // No cd-rom drive on this machine // // ISSUE-2002/02/28-stelo- We should check this earlier and grey out the choice // if there isn't a CD-ROM drive on the machine. And btw, // what happens if I connect to a CD over the net??? // if ( PathBuffer[0] == _T('\0') ) { ReportErrorId(hwnd, MSGTYPE_ERR, IDS_ERR_NO_CDROM_DRIVE); return FALSE; } /* // // We now have D:\ (or E:\ etc) in PathBuffer. // // We need to look for and find either: // d:\i386\dosnet.inf // d:\alpha\dosnet.inf // // Look for both of these files and stop when you find one. // pEnd = PathBuffer + lstrlen(PathBuffer); for ( i=0; i<2; i++ ) { if ( i == 0 ) lstrcpy(pEnd, I386_DOSNET); else lstrcpy(pEnd, ALPHA_DOSNET); if ( GetFileAttributes(PathBuffer) != (DWORD) -1 ) break; } // // Add the platform // if ( i == 0 ) { lstrcpy(pEnd, I386_DIR); } else if ( i == 1 ) { lstrcpy(pEnd, ALPHA_DIR); } else { ReportErrorId( hwnd, MSGTYPE_ERR, IDS_ERR_INSERT_CD, pProductName ); return( FALSE ); } */ if( ! FindWindowsSourceFilesPaths( hwnd, PathBuffer, AS(PathBuffer) ) ) { ReportErrorId(hwnd, MSGTYPE_ERR, IDS_ERR_NOTWINDOWSCD); return( FALSE ); } lstrcpyn( WizGlobals.CdSourcePath, PathBuffer, AS(WizGlobals.CdSourcePath) ); return( TRUE ); } //---------------------------------------------------------------------------- // // Function: OnWizNextCopyFiles1 // // Purpose: Called when user pushes the NEXT button. // //---------------------------------------------------------------------------- BOOL OnWizNextCopyFiles1(HWND hwnd) { TCHAR PathBuffer[MAX_PATH]; TCHAR szFilesPath[MAX_PATH] = _T(""); BOOL bStayHere = FALSE; TCHAR *lpszArchitecture = NULL; // // Get the control settings // WizGlobals.bCopyFromPath = IsDlgButtonChecked(hwnd, IDC_COPYFROMPATH); SendDlgItemMessage(hwnd, IDT_SOURCEPATH, WM_GETTEXT, (WPARAM) MAX_PATH, (LPARAM) WizGlobals.CopySourcePath); // // If dosnet.inf doesn't exist, this isn't a good path to the source files // if ( WizGlobals.bCopyFromPath ) { if ( WizGlobals.CopySourcePath[0] == _T('\0') ) { ReportErrorId(hwnd, MSGTYPE_ERR, IDS_ERR_ENTER_SETUP_PATH); bStayHere = TRUE; goto FinishUp; } // // If it is a UNC path, prepend \\?\UNC\ to the front of the path // if( WizGlobals.CopySourcePath[0] == _T('\\') && WizGlobals.CopySourcePath[1] == _T('\\') ) { lstrcpyn( szFilesPath, _T("\\\\?\\UNC\\"), AS(szFilesPath) ); // // Make sure user has access to the share by attempting to // connect to it // if( ! CanConnectToNetworkShare( WizGlobals.CopySourcePath ) ) { bStayHere = TRUE; goto FinishUp; } } ConcatenatePaths( szFilesPath, WizGlobals.CopySourcePath, NULL ); lstrcpyn( PathBuffer, szFilesPath, AS(PathBuffer) ); ConcatenatePaths( PathBuffer, _T("dosnet.inf"), NULL ); if ( ! DoesFileExist(PathBuffer) ) { ReportErrorId(hwnd, MSGTYPE_ERR, IDS_ERR_NOT_PRODUCT, WizGlobals.CopySourcePath); bStayHere = TRUE; goto FinishUp; } } else { if ( ! GetCdPath(hwnd) ) { bStayHere = TRUE; goto FinishUp; } lstrcpyn( szFilesPath, WizGlobals.CdSourcePath, AS(szFilesPath) ); } if( ! IsCorrectNtVersion( hwnd, szFilesPath ) ) { bStayHere = TRUE; goto FinishUp; } FinishUp: // Figure out the architecture (i.e. i386 or alpha) from the SrcPath // The SrcPath will be something like d:\i386, or \\net\share\foo\bar\i386 // so we just need to strip off the last part of the path string, and append // it to the dest path lpszArchitecture = szFilesPath + lstrlen(szFilesPath) - 1; while ((lpszArchitecture >= szFilesPath) && (*lpszArchitecture != _T('\\')) ) lpszArchitecture--; // Move forward 1, to get to the next char after the backslash lpszArchitecture++; lstrcpyn (WizGlobals.Architecture, lpszArchitecture, AS(WizGlobals.Architecture)); // // Free the memory in the DosnetPaths namelist // ResetNameList( &DosnetPaths ); return ( !bStayHere ); } //---------------------------------------------------------------------------- // // Function: DlgCopyFile1Page // // Purpose: Dialog procedure for the IDD_COPYFILES1 page // //---------------------------------------------------------------------------- INT_PTR CALLBACK DlgCopyFiles1Page( IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam) { BOOL bStatus = TRUE; BOOL bStayHere = FALSE; switch (uMsg) { case WM_INITDIALOG: StrServerCdName = MyLoadString(IDS_SERVER_CD_NAME); StrWorkStationCdName = MyLoadString(IDS_WORKSTATION_CD_NAME); break; case WM_COMMAND: { int nButtonId=LOWORD(wParam); switch ( nButtonId ) { case IDC_COPYFROMCD: case IDC_COPYFROMPATH: if ( HIWORD(wParam) == BN_CLICKED ) OnRadioButtonCopyFiles1(hwnd, nButtonId); break; case IDC_BROWSE: if ( HIWORD(wParam) == BN_CLICKED ) OnBrowseCopyFiles1(hwnd); break; default: bStatus = FALSE; break; } } break; case WM_NOTIFY: { LPNMHDR pnmh = (LPNMHDR)lParam; switch( pnmh->code ) { case PSN_QUERYCANCEL: WIZ_CANCEL(hwnd); break; case PSN_SETACTIVE: g_App.dwCurrentHelp = IDH_LOC_SETUP; if ( (WizGlobals.iProductInstall != PRODUCT_UNATTENDED_INSTALL) || WizGlobals.bStandAloneScript ) WIZ_SKIP( hwnd ); else OnSetActiveCopyFiles1(hwnd); break; case PSN_WIZBACK: bStatus = FALSE; break; case PSN_WIZNEXT: if ( !OnWizNextCopyFiles1(hwnd) ) WIZ_FAIL(hwnd); else bStatus = FALSE; break; case PSN_HELP: WIZ_HELP(); break; default: bStatus = FALSE; break; } } break; default: bStatus = FALSE; break; } return bStatus; }