mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1114 lines
41 KiB
1114 lines
41 KiB
#include "migwiz.h"
|
|
#include "migwnprc.h"
|
|
#include "migeng.h"
|
|
#include "migutil.h"
|
|
#include "miginf.h"
|
|
#include "shellapi.h"
|
|
#include "resource.h"
|
|
|
|
|
|
HINSTANCE g_hInstance = NULL;
|
|
BOOL g_fLastResponse; // did the user hit ok to the last callback message?
|
|
extern MigrationWizard* g_migwiz;
|
|
extern BOOL g_fHaveNet; // OLD COMPUTER ONLY: this means we can use the network
|
|
extern BOOL g_fReadFromNetwork; // NEW COMPUTER ONLY: this means go ahead and read from the network immediately
|
|
extern BOOL g_fStoreToNetwork; // OLD COMPUTER ONLY: this means we've selected to store to the network
|
|
extern HWND g_hwndCurrent;
|
|
extern CRITICAL_SECTION g_csDialogCritSection;
|
|
extern CRITICAL_SECTION g_AppInfoCritSection;
|
|
extern BOOL g_fUberCancel;
|
|
DWORD g_HTMLErrArea = 0;
|
|
DWORD g_HTMLErrInstr = 0;
|
|
PCTSTR g_HTMLErrObjectType = NULL;
|
|
PCTSTR g_HTMLErrObjectName = NULL;
|
|
|
|
POBJLIST g_HTMLWrnFile = NULL;
|
|
POBJLIST g_HTMLWrnAltFile = NULL;
|
|
POBJLIST g_HTMLWrnRas = NULL;
|
|
POBJLIST g_HTMLWrnNet = NULL;
|
|
POBJLIST g_HTMLWrnPrn = NULL;
|
|
POBJLIST g_HTMLWrnGeneral = NULL;
|
|
|
|
TCHAR g_szMultiDests[20 * MAX_PATH];
|
|
BOOL g_fReceivedMultiDest = FALSE; // we only respond to the first multi-dest message we receive
|
|
|
|
extern MIG_PROGRESSPHASE g_AppInfoPhase;
|
|
extern UINT g_AppInfoSubPhase;
|
|
extern MIG_OBJECTTYPEID g_AppInfoObjectTypeId;
|
|
extern TCHAR g_AppInfoObjectName [4096];
|
|
extern TCHAR g_AppInfoText [4096];
|
|
|
|
MigrationWizard::MigrationWizard() : _fInit(FALSE), _pszUsername(NULL)
|
|
{
|
|
}
|
|
|
|
MigrationWizard::~MigrationWizard()
|
|
{
|
|
CloseAppInf();
|
|
|
|
// Destroy the fonts
|
|
if (_hTitleFont)
|
|
{
|
|
DeleteObject(_hTitleFont);
|
|
DeleteObject(_h95HeaderFont);
|
|
}
|
|
|
|
if (_pszUsername)
|
|
{
|
|
LocalFree(_pszUsername);
|
|
}
|
|
|
|
if (_fDelCs) {
|
|
DeleteCriticalSection (&g_csDialogCritSection);
|
|
_fDelCs = FALSE;
|
|
}
|
|
}
|
|
|
|
HRESULT MigrationWizard::Init(HINSTANCE hInstance, LPTSTR pszUsername)
|
|
{
|
|
HRESULT hr;
|
|
BOOL fWinXP = FALSE;
|
|
|
|
_hInstance = hInstance;
|
|
if (pszUsername)
|
|
{
|
|
_pszUsername = (LPTSTR)LocalAlloc(LPTR, (lstrlen(pszUsername) + 1) * sizeof (TCHAR));
|
|
if (_pszUsername)
|
|
{
|
|
lstrcpy(_pszUsername, pszUsername);
|
|
}
|
|
}
|
|
|
|
__try {
|
|
InitializeCriticalSection (&g_csDialogCritSection);
|
|
} __except (EXCEPTION_CONTINUE_EXECUTION) {
|
|
// Might raise an out of memory exception
|
|
// -1 ignores
|
|
}
|
|
_fDelCs = TRUE;
|
|
|
|
__try {
|
|
InitializeCriticalSection (&g_AppInfoCritSection);
|
|
} __except (EXCEPTION_CONTINUE_EXECUTION) {
|
|
// Might raise an out of memory exception
|
|
// -1 ignores
|
|
}
|
|
|
|
// do we run in OOBE mode? check for oobemode.dat in the curr dir
|
|
_fOOBEMode = FALSE; // default
|
|
TCHAR szPath[MAX_PATH];
|
|
if (GetCurrentDirectory(ARRAYSIZE(szPath), szPath))
|
|
{
|
|
PathAppend(szPath, TEXT("oobemode.dat"));
|
|
HANDLE hFile = CreateFile(szPath, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
|
|
if (INVALID_HANDLE_VALUE != hFile)
|
|
{
|
|
_fOOBEMode = TRUE;
|
|
CloseHandle(hFile);
|
|
}
|
|
}
|
|
|
|
OpenAppInf(NULL);
|
|
|
|
// do we run in legacy mode? (collect-only)
|
|
UINT uiVer = GetVersion();
|
|
_fLegacyMode = (uiVer >= 0x80000000 || LOBYTE(LOWORD(uiVer)) < 5);
|
|
_fWin9X = (uiVer >= 0x80000000);
|
|
_fWinNT4 = (uiVer < 0x80000000 && LOBYTE(LOWORD(uiVer)) == 4);
|
|
fWinXP = ((uiVer < 0x80000000) && (LOBYTE(LOWORD(uiVer)) == 5) && (HIBYTE(LOWORD(uiVer)) >= 1));
|
|
|
|
#ifndef PRERELEASE
|
|
// in release mode, run legacy on for Win2k
|
|
if (HIBYTE(LOWORD(uiVer)) < 1)
|
|
{
|
|
_fLegacyMode = TRUE;
|
|
}
|
|
#endif
|
|
|
|
// do we run with old-style wizard?
|
|
_fOldStyle = (uiVer >= 0x80000000 || LOBYTE(LOWORD(uiVer)) < 5); // hack, for now win9x is old-style
|
|
|
|
|
|
// Init common controls
|
|
INITCOMMONCONTROLSEX icex;
|
|
|
|
icex.dwSize = sizeof(INITCOMMONCONTROLSEX);
|
|
if (fWinXP) {
|
|
icex.dwICC = ICC_USEREX_CLASSES | ICC_LINK_CLASS;
|
|
} else {
|
|
icex.dwICC = ICC_USEREX_CLASSES;
|
|
}
|
|
InitCommonControlsEx(&icex);
|
|
|
|
// Init the imagelist
|
|
SHFILEINFO sfi = {0};
|
|
_hil = (HIMAGELIST)SHGetFileInfo(TEXT(".txt"), FILE_ATTRIBUTE_NORMAL, &sfi, sizeof(sfi),
|
|
SHGFI_SMALLICON | SHGFI_SYSICONINDEX | SHGFI_USEFILEATTRIBUTES);
|
|
|
|
//
|
|
//Create the Wizard pages
|
|
//
|
|
hr = _CreateWizardPages();
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
//Create the property sheet
|
|
|
|
_psh.hInstance = _hInstance;
|
|
_psh.hwndParent = NULL;
|
|
_psh.phpage = _rghpsp;
|
|
if (!_fOldStyle)
|
|
{
|
|
_psh.dwSize = sizeof(_psh);
|
|
_psh.dwFlags = PSH_WIZARD97|PSH_WATERMARK|PSH_HEADER;
|
|
_psh.pszbmWatermark = MAKEINTRESOURCE(IDB_WATERMARK);
|
|
_psh.pszbmHeader = MAKEINTRESOURCE(IDB_BANNER);
|
|
}
|
|
else
|
|
{
|
|
_psh.dwSize = PROPSHEETHEADER_V1_SIZE;
|
|
_psh.dwFlags = PSH_WIZARD;
|
|
}
|
|
_psh.nStartPage = 0;
|
|
_psh.nPages = NUMPAGES;
|
|
|
|
|
|
//Set up the font for the titles on the intro and ending pages
|
|
NONCLIENTMETRICS ncm = {0};
|
|
ncm.cbSize = sizeof(ncm);
|
|
SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0, &ncm, 0);
|
|
|
|
//Create the intro/end title font
|
|
LOGFONT TitleLogFont = ncm.lfMessageFont;
|
|
// ISSUE: we don't want to do this, this can break us on non-English builds.
|
|
TitleLogFont.lfWeight = FW_BOLD;
|
|
lstrcpy(TitleLogFont.lfFaceName, TEXT("MS Shell Dlg"));
|
|
|
|
HDC hdc = GetDC(NULL); //gets the screen DC
|
|
TitleLogFont.lfHeight = 0 - GetDeviceCaps(hdc, LOGPIXELSY) * 12 / 72;
|
|
_hTitleFont = CreateFontIndirect(&TitleLogFont);
|
|
|
|
|
|
CHAR szFontSize[MAX_LOADSTRING];
|
|
DWORD dwFontSize = 8;
|
|
if (LoadStringA(g_hInstance, IDS_WIN9X_HEADER_FONTSIZE, szFontSize, ARRAYSIZE(szFontSize))) {
|
|
dwFontSize = strtoul(szFontSize, NULL, 10);
|
|
}
|
|
|
|
TitleLogFont.lfHeight = 0 - GetDeviceCaps(hdc, LOGPIXELSY) * dwFontSize / 72;
|
|
lstrcpy(TitleLogFont.lfFaceName, TEXT("MS Shell Dlg"));
|
|
_h95HeaderFont = CreateFontIndirect(&TitleLogFont);
|
|
|
|
ReleaseDC(NULL, hdc);
|
|
|
|
g_hInstance = _hInstance; // HACK: allows message callback to get an hinstance to load strings
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT MigrationWizard::Execute()
|
|
{
|
|
//Display the wizard
|
|
PropertySheet(&_psh);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
#define WIZDLG(name, dlgproc) \
|
|
psp.dwFlags = _fOldStyle ? PSP_DEFAULT : PSP_DEFAULT|PSP_USEHEADERTITLE;\
|
|
psp.pszHeaderTitle = _fOldStyle ? NULL : MAKEINTRESOURCE(IDS_##name##TITLE);\
|
|
psp.pszHeaderSubTitle = NULL;\
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_##name##);\
|
|
psp.pfnDlgProc = ##dlgproc##;\
|
|
_rghpsp[uiCounter++] = CreatePropertySheetPage(&psp)
|
|
|
|
#define WIZDLG_TITLE(name, dlgproc) \
|
|
psp.dwFlags = _fOldStyle ? PSP_DEFAULT : PSP_DEFAULT|PSP_HIDEHEADER;\
|
|
psp.pszHeaderTitle = NULL;\
|
|
psp.pszHeaderSubTitle = NULL;\
|
|
psp.pszTemplate = MAKEINTRESOURCE(IDD_##name##);\
|
|
psp.pfnDlgProc = ##dlgproc##;\
|
|
_rghpsp[uiCounter++] = CreatePropertySheetPage(&psp)
|
|
|
|
HRESULT MigrationWizard::_CreateWizardPages()
|
|
{
|
|
UINT uiCounter = 0;
|
|
|
|
PROPSHEETPAGE psp = {0}; //defines the property sheet page
|
|
psp.dwSize = sizeof(psp);
|
|
psp.hInstance = _hInstance;
|
|
psp.lParam = (LPARAM)this;
|
|
|
|
//Opening page
|
|
|
|
if (_fOOBEMode)
|
|
{
|
|
WIZDLG_TITLE(INTROOOBE, _IntroOOBEDlgProc);
|
|
}
|
|
else if (!_fLegacyMode)
|
|
{
|
|
WIZDLG_TITLE(INTRO, _IntroDlgProc);
|
|
}
|
|
else
|
|
{
|
|
WIZDLG_TITLE(INTROLEGACY, _IntroLegacyDlgProc);
|
|
}
|
|
|
|
// Interior pages
|
|
WIZDLG(GETSTARTED, _GetStartedDlgProc);
|
|
WIZDLG(ASKCD, _AskCDDlgProc);
|
|
WIZDLG(DISKPROGRESS, _DiskProgressDlgProc);
|
|
WIZDLG(DISKINSTRUCTIONS, _InstructionsDlgProc);
|
|
WIZDLG(CDINSTRUCTIONS, _CDInstructionsDlgProc);
|
|
WIZDLG(PICKAPPLYSTORE, _PickApplyStoreDlgProc);
|
|
WIZDLG(APPLYPROGRESS, _ApplyProgressDlgProc);
|
|
WIZDLG(WAIT, _StartEngineDlgProc);
|
|
WIZDLG(PICKMETHOD, _PickMethodDlgProc);
|
|
WIZDLG(CUSTOMIZE, _CustomizeDlgProc);
|
|
WIZDLG(PICKCOLLECTSTORE, _PickCollectStoreDlgProc);
|
|
WIZDLG(COLLECTPROGRESS, _CollectProgressDlgProc);
|
|
WIZDLG(DIRECTCABLE, _DirectCableDlgProc);
|
|
WIZDLG(FAILCLEANUP, _CleanUpDlgProc);
|
|
WIZDLG(APPINSTALL, _AppInstallDlgProc);
|
|
|
|
//Final pages
|
|
WIZDLG_TITLE(ENDAPPLY, _EndApplyDlgProc);
|
|
WIZDLG_TITLE(ENDAPPLYFAIL, _EndFailDlgProc);
|
|
WIZDLG_TITLE(ENDCOLLECT, _EndCollectDlgProc);
|
|
WIZDLG_TITLE(ENDCOLLECTNET, _EndCollectNetDlgProc);
|
|
WIZDLG_TITLE(ENDCOLLECTFAIL, _EndFailDlgProc);
|
|
WIZDLG_TITLE(ENDOOBE, _EndOOBEDlgProc);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// this lets us know if the user cancelled
|
|
void MigrationWizard::ResetLastResponse()
|
|
{
|
|
g_fLastResponse = TRUE;
|
|
}
|
|
|
|
BOOL MigrationWizard::GetLastResponse()
|
|
{
|
|
return g_fLastResponse;
|
|
}
|
|
|
|
INT_PTR CALLBACK _WaitDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
INT_PTR CALLBACK _DisplayPasswordDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static PPASSWORD_DATA passwordData = NULL;
|
|
DWORD waitResult;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG :
|
|
{
|
|
passwordData = (PPASSWORD_DATA) lParam;
|
|
if (passwordData) {
|
|
if (passwordData->Key) {
|
|
SendMessageA (GetDlgItem(hwndDlg, IDC_DISPLAY_PASSWORD), WM_SETTEXT, 0, (LPARAM)passwordData->Key);
|
|
}
|
|
}
|
|
SetTimer (hwndDlg, NULL, 100, NULL);
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDCANCEL:
|
|
EndDialog(hwndDlg, FALSE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case WM_TIMER:
|
|
if (passwordData) {
|
|
waitResult = WaitForSingleObject (passwordData->Event, 0);
|
|
if (waitResult != WAIT_TIMEOUT) {
|
|
EndDialog(hwndDlg, FALSE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
INT_PTR CALLBACK _GatherPasswordDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
static PPASSWORD_DATA passwordData = NULL;
|
|
DWORD waitResult;
|
|
|
|
switch (uMsg)
|
|
{
|
|
case WM_INITDIALOG :
|
|
{
|
|
passwordData = (PPASSWORD_DATA) lParam;
|
|
if (passwordData) {
|
|
if (passwordData->Key) {
|
|
SendMessageA (GetDlgItem(hwndDlg, IDC_GATHER_PASSWORD), WM_SETTEXT, 0, (LPARAM)passwordData->Key);
|
|
}
|
|
Edit_LimitText(GetDlgItem(hwndDlg, IDC_GATHER_PASSWORD), passwordData->KeySize - 1);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
if (passwordData && passwordData->Key) {
|
|
SendMessageA (GetDlgItem(hwndDlg, IDC_GATHER_PASSWORD), WM_GETTEXT, passwordData->KeySize, (LPARAM)passwordData->Key);
|
|
EndDialog(hwndDlg, TRUE);
|
|
} else {
|
|
EndDialog(hwndDlg, FALSE);
|
|
}
|
|
return TRUE;
|
|
case IDCANCEL:
|
|
EndDialog(hwndDlg, FALSE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
INT_PTR CALLBACK _ChooseDestDlgProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (uMsg)
|
|
{
|
|
case WM_NOTIFY :
|
|
switch (((LPNMHDR)lParam)->code)
|
|
{
|
|
case NM_DBLCLK:
|
|
// On this dialog, this message can only come from the listview.
|
|
// If there is something selected, that means the user doubleclicked on an item
|
|
// On a doubleclick we will trigger the OK button
|
|
if (ListView_GetSelectedCount(GetDlgItem(hwndDlg, IDC_DESTPICKER_LIST)) > 0)
|
|
{
|
|
SendMessage (GetDlgItem(hwndDlg, IDOK), BM_CLICK, 0, 0);
|
|
}
|
|
break;
|
|
case LVN_ITEMCHANGED:
|
|
if (ListView_GetSelectedCount(GetDlgItem(hwndDlg, IDC_DESTPICKER_LIST)) > 0)
|
|
{
|
|
Button_Enable(GetDlgItem(hwndDlg, IDOK), TRUE);
|
|
}
|
|
else
|
|
{
|
|
Button_Enable(GetDlgItem(hwndDlg, IDOK), FALSE);
|
|
}
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case WM_INITDIALOG :
|
|
{
|
|
HWND hwndList = GetDlgItem(hwndDlg, IDC_DESTPICKER_LIST);
|
|
ListView_DeleteAllItems(hwndList);
|
|
|
|
LVCOLUMN lvcolumn;
|
|
lvcolumn.mask = LVCF_WIDTH;
|
|
lvcolumn.cx = 250; // BUGBUG: should read width from box
|
|
ListView_InsertColumn(hwndList, 0, &lvcolumn);
|
|
|
|
LVITEM lvitem = {0};
|
|
lvitem.mask = LVIF_TEXT;
|
|
|
|
Button_Enable(GetDlgItem(hwndDlg, IDOK), FALSE);
|
|
|
|
LPTSTR pszPtr = g_szMultiDests;
|
|
|
|
BOOL fDone = FALSE;
|
|
while (*pszPtr != NULL)
|
|
{
|
|
lvitem.iItem = lvitem.iItem = ListView_GetItemCount(hwndList);
|
|
lvitem.pszText = pszPtr;
|
|
ListView_InsertItem(hwndList, &lvitem);
|
|
pszPtr += (lstrlen(pszPtr) + 1);
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (LOWORD(wParam))
|
|
{
|
|
case IDOK:
|
|
{
|
|
UINT uiSelected = ListView_GetSelectionMark(GetDlgItem(hwndDlg, IDC_DESTPICKER_LIST));
|
|
ListView_GetItemText(GetDlgItem(hwndDlg, IDC_DESTPICKER_LIST), uiSelected, 0, g_szMultiDests, ARRAYSIZE(g_szMultiDests));
|
|
g_szMultiDests[lstrlen(g_szMultiDests) + 1] = 0; // double-null terminate the multi-sz
|
|
EndDialog(hwndDlg, TRUE);
|
|
return TRUE;
|
|
}
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hwndDlg, FALSE);
|
|
return TRUE;
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
BOOL
|
|
_ExclusiveMessageBoxVaArgs (
|
|
IN PTSTR pszTitle,
|
|
IN BOOL RetryCancel,
|
|
IN DWORD dwResourceId,
|
|
...
|
|
)
|
|
{
|
|
TCHAR szErrMsg[MAX_LOADSTRING];
|
|
TCHAR szErrStr[MAX_LOADSTRING];
|
|
va_list args;
|
|
|
|
LoadString(g_hInstance, dwResourceId, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
|
|
va_start (args, dwResourceId);
|
|
FormatMessage (FORMAT_MESSAGE_FROM_STRING, szErrMsg, 0, 0, (LPTSTR)szErrStr, ARRAYSIZE (szErrStr), &args);
|
|
va_end (args);
|
|
|
|
if (RetryCancel) {
|
|
return (IDRETRY == _ExclusiveMessageBox (g_hwndCurrent,szErrStr,pszTitle,MB_RETRYCANCEL));
|
|
} else {
|
|
return (IDOK == _ExclusiveMessageBox (g_hwndCurrent,szErrStr,pszTitle,MB_OKCANCEL));
|
|
}
|
|
}
|
|
|
|
PCTSTR
|
|
pGenerateNewNode (
|
|
IN PCTSTR OldNode
|
|
)
|
|
{
|
|
PTSTR newNode;
|
|
PTSTR newNodePtr;
|
|
PCTSTR result = NULL;
|
|
|
|
newNode = (PTSTR)LocalAlloc (LPTR, (_tcslen (TEXT ("%CSIDL_PERSONAL%\\")) + _tcslen (OldNode) + 1) * sizeof (TCHAR));
|
|
if (newNode) {
|
|
_tcscpy (newNode, TEXT("%CSIDL_PERSONAL%\\"));
|
|
_tcscat (newNode, OldNode);
|
|
newNodePtr = _tcschr (newNode, TEXT(':'));
|
|
while (newNodePtr) {
|
|
*newNodePtr = TEXT('_');
|
|
newNodePtr = _tcschr (newNode, TEXT(':'));
|
|
}
|
|
result = IsmExpandEnvironmentString (PLATFORM_DESTINATION, S_SYSENVVAR_GROUP, newNode, NULL);
|
|
LocalFree ((PVOID)newNode);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
BOOL
|
|
pForceRestoreObject (
|
|
IN MIG_OBJECTSTRINGHANDLE EncodedFileName,
|
|
IN OUT POBJLIST ObjList
|
|
)
|
|
{
|
|
MIG_CONTENT objectContent;
|
|
PCTSTR node = NULL;
|
|
PCTSTR leaf = NULL;
|
|
PCTSTR newNode = NULL;
|
|
MIG_OBJECTSTRINGHANDLE newFileName;
|
|
BOOL result = FALSE;
|
|
|
|
if (IsmAcquireObject (MIG_FILE_TYPE | PLATFORM_SOURCE, EncodedFileName, &objectContent)) {
|
|
// let's build the new name for this file
|
|
if (IsmCreateObjectStringsFromHandle (EncodedFileName, &node, &leaf)) {
|
|
if (node && leaf) {
|
|
newNode = pGenerateNewNode (node);
|
|
if (newNode) {
|
|
newFileName = IsmCreateObjectHandle (newNode, leaf);
|
|
if (newFileName) {
|
|
result = IsmReplacePhysicalObject (
|
|
MIG_FILE_TYPE | PLATFORM_DESTINATION,
|
|
newFileName,
|
|
&objectContent
|
|
);
|
|
if (result && ObjList) {
|
|
ObjList->AlternateName = (PTSTR)LocalAlloc (LPTR, (_tcslen (newFileName) + 1) * sizeof (TCHAR));
|
|
if (ObjList->AlternateName) {
|
|
_tcscpy (ObjList->AlternateName, newFileName);
|
|
}
|
|
}
|
|
IsmDestroyObjectHandle (newFileName);
|
|
}
|
|
IsmReleaseMemory (newNode);
|
|
}
|
|
}
|
|
if (node) {
|
|
IsmDestroyObjectString (node);
|
|
node = NULL;
|
|
}
|
|
if (leaf) {
|
|
IsmDestroyObjectString (leaf);
|
|
leaf = NULL;
|
|
}
|
|
}
|
|
IsmReleaseObject (&objectContent);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
ULONG_PTR MessageCallback (UINT uiMsg, ULONG_PTR pArg)
|
|
{
|
|
PRMEDIA_EXTRADATA extraData;
|
|
PTRANSCOPY_ERROR transCopyError;
|
|
PERRUSER_EXTRADATA errExtraData;
|
|
PROLLBACK_USER_ERROR rollbackError;
|
|
PPASSWORD_DATA passwordData;
|
|
PMIG_APPINFO appInfo;
|
|
PQUESTION_DATA questionData;
|
|
int msgBoxReturn;
|
|
TCHAR szTitle[MAX_LOADSTRING];
|
|
LoadString(g_hInstance, IDS_MIGWIZTITLE, szTitle, ARRAYSIZE(szTitle));
|
|
TCHAR szErrMsg[MAX_LOADSTRING];
|
|
TCHAR szErrStr[MAX_LOADSTRING];
|
|
POBJLIST wrnObj = NULL;
|
|
PCTSTR objectType = NULL;
|
|
PCTSTR objectName = NULL;
|
|
static DWORD dwTypeID = 0;
|
|
|
|
switch (uiMsg)
|
|
{
|
|
case MODULEMESSAGE_ASKQUESTION:
|
|
questionData = (PQUESTION_DATA) pArg;
|
|
if (questionData) {
|
|
if (MessageBox (g_hwndCurrent, questionData->Question, szTitle, questionData->MessageStyle) == questionData->WantedResult) {
|
|
return APPRESPONSE_SUCCESS;
|
|
} else {
|
|
return APPRESPONSE_FAIL;
|
|
}
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case ISMMESSAGE_APP_INFO:
|
|
case ISMMESSAGE_APP_INFO_NOW:
|
|
appInfo = (PMIG_APPINFO) pArg;
|
|
if (appInfo) {
|
|
EnterCriticalSection(&g_AppInfoCritSection);
|
|
g_AppInfoPhase = appInfo->Phase;
|
|
g_AppInfoSubPhase = appInfo->SubPhase;
|
|
g_AppInfoObjectTypeId = appInfo->ObjectTypeId;
|
|
if (appInfo->ObjectName) {
|
|
_tcsncpy (g_AppInfoObjectName, appInfo->ObjectName, 4096);
|
|
} else {
|
|
g_AppInfoObjectName [0] = 0;
|
|
}
|
|
if (appInfo->Text) {
|
|
_tcsncpy (g_AppInfoText, appInfo->Text, 4096);
|
|
} else {
|
|
g_AppInfoText [0] = 0;
|
|
}
|
|
LeaveCriticalSection(&g_AppInfoCritSection);
|
|
if (uiMsg == ISMMESSAGE_APP_INFO_NOW) {
|
|
SendMessage (g_hwndCurrent, WM_USER_STATUS, 0, 0);
|
|
}
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_OLD_STORAGE:
|
|
LoadString(g_hInstance, IDS_ENGERR_IMAGE_OLDFORMAT, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
_ExclusiveMessageBox (g_hwndCurrent, szErrMsg, szTitle, MB_OK);
|
|
return 0;
|
|
|
|
case TRANSPORTMESSAGE_IMAGE_EXISTS:
|
|
LoadString(g_hInstance, IDS_ENGERR_IMAGE_EXISTS, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDYES == _ExclusiveMessageBox (g_hwndCurrent, szErrMsg, szTitle, MB_YESNO));
|
|
return g_fLastResponse;
|
|
|
|
case TRANSPORTMESSAGE_SIZE_SAVED:
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_RMEDIA_LOAD:
|
|
case TRANSPORTMESSAGE_RMEDIA_SAVE:
|
|
extraData = (PRMEDIA_EXTRADATA) pArg;
|
|
if (!extraData) {
|
|
LoadString(g_hInstance, IDS_ENGERR_NEXT_MEDIA, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDOK == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_OKCANCEL));
|
|
} else {
|
|
switch (extraData->LastError)
|
|
{
|
|
case RMEDIA_ERR_NOERROR:
|
|
if (uiMsg == TRANSPORTMESSAGE_RMEDIA_LOAD) {
|
|
g_fLastResponse = _ExclusiveMessageBoxVaArgs (
|
|
szTitle,
|
|
FALSE,
|
|
IDS_ENGERR_INSERT_DEST_MEDIA_NUMBER,
|
|
extraData->MediaNumber
|
|
);
|
|
} else {
|
|
if (extraData->MediaNumber == 1) {
|
|
DOUBLE sizeMB = (DOUBLE) extraData->TotalImageSize / (1024 * 1024);
|
|
UINT intMB = (UINT) sizeMB;
|
|
UINT decMB = (UINT) ((sizeMB - intMB) * 100);
|
|
UINT sizeF = (UINT) (sizeMB / 1.44);
|
|
UINT sizeZ = (UINT) (sizeMB / 100);
|
|
if (sizeF < 1) {
|
|
LoadString(g_hInstance, IDS_ENGERR_INSERT_FIRST_MEDIA1, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wsprintf (szErrStr, szErrMsg, intMB, decMB);
|
|
} else if (sizeZ < 1) {
|
|
LoadString(g_hInstance, IDS_ENGERR_INSERT_FIRST_MEDIA2, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wsprintf (szErrStr, szErrMsg, intMB, decMB, 1 + sizeF);
|
|
} else {
|
|
LoadString(g_hInstance, IDS_ENGERR_INSERT_FIRST_MEDIA3, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wsprintf (szErrStr, szErrMsg, intMB, decMB, 1 + sizeF, 1 + sizeZ);
|
|
}
|
|
g_fLastResponse = (IDOK == _ExclusiveMessageBox (g_hwndCurrent,szErrStr,szTitle,MB_OKCANCEL));
|
|
} else {
|
|
UINT iDisks;
|
|
ULONGLONG ullBytesPerDisk;
|
|
ullBytesPerDisk = extraData->TotalImageWritten / (extraData->MediaNumber - 1);
|
|
if (ullBytesPerDisk) {
|
|
iDisks = (UINT)(extraData->TotalImageSize / ullBytesPerDisk) + 1;
|
|
g_fLastResponse = _ExclusiveMessageBoxVaArgs (
|
|
szTitle,
|
|
FALSE,
|
|
IDS_ENGERR_INSERT_MEDIA_NUMBER,
|
|
extraData->MediaNumber,
|
|
iDisks
|
|
);
|
|
} else {
|
|
LoadString(g_hInstance, IDS_ENGERR_NEXT_MEDIA, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDOK == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_OKCANCEL));
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case RMEDIA_ERR_WRONGMEDIA:
|
|
g_fLastResponse = _ExclusiveMessageBoxVaArgs (szTitle,
|
|
TRUE,
|
|
IDS_ENGERR_WRONG_MEDIA,
|
|
extraData->MediaNumber);
|
|
break;
|
|
case RMEDIA_ERR_USEDMEDIA:
|
|
g_fLastResponse = _ExclusiveMessageBoxVaArgs (szTitle,
|
|
FALSE,
|
|
IDS_ENGERR_USED_MEDIA,
|
|
extraData->MediaNumber);
|
|
break;
|
|
case RMEDIA_ERR_DISKFULL:
|
|
LoadString(g_hInstance, IDS_ENGERR_FULL, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDRETRY == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_RETRYCANCEL));
|
|
break;
|
|
case RMEDIA_ERR_NOTREADY:
|
|
LoadString(g_hInstance, IDS_ENGERR_NOTREADY, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDRETRY == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_RETRYCANCEL));
|
|
break;
|
|
case RMEDIA_ERR_WRITEPROTECT:
|
|
LoadString(g_hInstance, IDS_ENGERR_WRITEPROTECT, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDRETRY == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_RETRYCANCEL));
|
|
break;
|
|
case RMEDIA_ERR_CRITICAL:
|
|
g_fLastResponse = FALSE;
|
|
break;
|
|
default:
|
|
LoadString(g_hInstance, IDS_ENGERR_TOAST, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
g_fLastResponse = (IDRETRY == _ExclusiveMessageBox (g_hwndCurrent,szErrMsg,szTitle,MB_RETRYCANCEL));
|
|
}
|
|
return g_fLastResponse;
|
|
}
|
|
|
|
case TRANSPORTMESSAGE_READY_TO_CONNECT:
|
|
// this message is received only on the new machine
|
|
g_fReadFromNetwork = TRUE; // this means go ahead and read from the network immediately
|
|
PropSheet_PressButton(GetParent(g_hwndCurrent), PSBTN_NEXT);
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_MULTIPLE_DESTS:
|
|
// this is received only on the old machine
|
|
{
|
|
if (g_fReceivedMultiDest)
|
|
{
|
|
return APPRESPONSE_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
g_fReceivedMultiDest = TRUE;
|
|
ULONG_PTR uiRetVal = APPRESPONSE_FAIL;
|
|
g_fHaveNet = FALSE; // disable network unless user chooses a destination
|
|
TCHAR szDestinations[20 * MAX_PATH];
|
|
if (IsmGetEnvironmentMultiSz (
|
|
PLATFORM_DESTINATION,
|
|
NULL,
|
|
TRANSPORT_ENVVAR_HOMENET_DESTINATIONS,
|
|
szDestinations,
|
|
ARRAYSIZE(szDestinations),
|
|
NULL
|
|
))
|
|
{
|
|
memcpy(g_szMultiDests, szDestinations, sizeof(TCHAR) * ARRAYSIZE(szDestinations));
|
|
if (_ExclusiveDialogBox(g_hInstance, MAKEINTRESOURCE(IDD_DESTPICKER), g_hwndCurrent, _ChooseDestDlgProc))
|
|
{
|
|
IsmSetEnvironmentMultiSz (
|
|
PLATFORM_DESTINATION,
|
|
NULL,
|
|
TRANSPORT_ENVVAR_HOMENET_DESTINATIONS,
|
|
g_szMultiDests
|
|
);
|
|
uiRetVal = APPRESPONSE_SUCCESS;
|
|
g_fHaveNet = TRUE; // re-enable network
|
|
}
|
|
else
|
|
{
|
|
g_fUberCancel = TRUE;
|
|
Engine_Cancel();
|
|
}
|
|
}
|
|
|
|
return uiRetVal;
|
|
}
|
|
}
|
|
|
|
case ISMMESSAGE_EXECUTE_PREPROCESS:
|
|
if (!g_migwiz->GetOOBEMode()) {
|
|
AppExecute (g_migwiz->GetInstance(), g_hwndCurrent, (PCTSTR) pArg);
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case ISMMESSAGE_EXECUTE_REFRESH:
|
|
if (!g_migwiz->GetOOBEMode() && !g_fUberCancel) {
|
|
AppExecute (g_migwiz->GetInstance(), g_hwndCurrent, (PCTSTR) pArg);
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case ISMMESSAGE_EXECUTE_POSTPROCESS:
|
|
if (!g_migwiz->GetOOBEMode()) {
|
|
AppExecute (g_migwiz->GetInstance(), g_hwndCurrent, (PCTSTR) pArg);
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case ISMMESSAGE_EXECUTE_ROLLBACK:
|
|
rollbackError = (PROLLBACK_USER_ERROR) pArg;
|
|
if (rollbackError) {
|
|
LoadString(g_hInstance, IDS_CANTROLLBACK, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wsprintf (szErrStr, szErrMsg, rollbackError->UserDomain, rollbackError->UserName);
|
|
_ExclusiveMessageBox (g_hwndCurrent,szErrStr,szTitle,MB_OK);
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_SRC_COPY_ERROR:
|
|
transCopyError = (PTRANSCOPY_ERROR) pArg;
|
|
if (transCopyError) {
|
|
if (StrCmpI (transCopyError->ObjectType, TEXT("File")) == 0) {
|
|
if ((transCopyError->Error == ERROR_SHARING_VIOLATION) ||
|
|
(transCopyError->Error == ERROR_LOCK_VIOLATION) ||
|
|
(transCopyError->Error == 0x80090020) // found this on a WinME machine, when a file was locked
|
|
) {
|
|
LoadString(g_hInstance, IDS_ENGERR_COPYSOURCE, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wsprintf (szErrStr, szErrMsg, transCopyError->ObjectName);
|
|
msgBoxReturn = _ExclusiveMessageBox (g_hwndCurrent,szErrStr,szTitle,MB_ABORTRETRYIGNORE | MB_DEFBUTTON2);
|
|
if (msgBoxReturn == IDRETRY) {
|
|
return APPRESPONSE_SUCCESS;
|
|
}
|
|
if (msgBoxReturn == IDIGNORE) {
|
|
return APPRESPONSE_IGNORE;
|
|
}
|
|
return APPRESPONSE_FAIL;
|
|
}
|
|
// we don't really know what was the problem here.
|
|
// Let's just continue, at the end we will tell the
|
|
// user about this file and he will copy it manually.
|
|
return APPRESPONSE_IGNORE;
|
|
}
|
|
}
|
|
return APPRESPONSE_FAIL;
|
|
|
|
case MODULEMESSAGE_DISPLAYERROR:
|
|
errExtraData = (PERRUSER_EXTRADATA) pArg;
|
|
if (errExtraData && !g_HTMLErrArea) {
|
|
switch (errExtraData->ErrorArea) {
|
|
case ERRUSER_AREA_INIT:
|
|
g_HTMLErrArea = IDS_ERRORAREA_INIT;
|
|
break;
|
|
case ERRUSER_AREA_GATHER:
|
|
g_HTMLErrArea = IDS_ERRORAREA_GATHER;
|
|
break;
|
|
case ERRUSER_AREA_SAVE:
|
|
g_HTMLErrArea = IDS_ERRORAREA_SAVE;
|
|
break;
|
|
case ERRUSER_AREA_LOAD:
|
|
g_HTMLErrArea = IDS_ERRORAREA_LOAD;
|
|
break;
|
|
case ERRUSER_AREA_RESTORE:
|
|
g_HTMLErrArea = IDS_ERRORAREA_RESTORE;
|
|
break;
|
|
default:
|
|
g_HTMLErrArea = IDS_ERRORAREA_UNKNOWN;
|
|
}
|
|
switch (errExtraData->Error) {
|
|
case ERRUSER_ERROR_NOTRANSPORTPATH:
|
|
g_HTMLErrInstr = IDS_ERROR_NOTRANSPORTPATH;
|
|
break;
|
|
case ERRUSER_ERROR_TRANSPORTPATHBUSY:
|
|
case ERRUSER_ERROR_CANTEMPTYDIR:
|
|
case ERRUSER_ERROR_ALREADYEXISTS:
|
|
case ERRUSER_ERROR_CANTCREATEDIR:
|
|
case ERRUSER_ERROR_CANTCREATESTATUS:
|
|
case ERRUSER_ERROR_CANTWRITETODESTPATH:
|
|
g_HTMLErrInstr = IDS_ERROR_TRANSPORTNOACCESS;
|
|
break;
|
|
case ERRUSER_ERROR_CANTCREATETEMPDIR:
|
|
case ERRUSER_ERROR_CANTCREATECABFILE:
|
|
case ERRUSER_ERROR_CANTSAVEINTERNALDATA:
|
|
g_HTMLErrInstr = IDS_ERROR_TRANSPORTINTERNALERROR;
|
|
break;
|
|
case ERRUSER_ERROR_TRANSPORTINVALIDIMAGE:
|
|
case ERRUSER_ERROR_CANTOPENSTATUS:
|
|
case ERRUSER_ERROR_CANTREADIMAGE:
|
|
g_HTMLErrInstr = IDS_ERROR_TRANSPORTNOVALIDSOURCE;
|
|
break;
|
|
case ERRUSER_ERROR_CANTFINDDESTINATION:
|
|
case ERRUSER_ERROR_CANTSENDTODEST:
|
|
g_HTMLErrInstr = IDS_ERROR_HOMENETINVALIDDEST;
|
|
break;
|
|
case ERRUSER_ERROR_CANTFINDSOURCE:
|
|
case ERRUSER_ERROR_CANTRECEIVEFROMSOURCE:
|
|
case ERRUSER_ERROR_INVALIDDATARECEIVED:
|
|
g_HTMLErrInstr = IDS_ERROR_HOMENETINVALIDSRC;
|
|
break;
|
|
case ERRUSER_ERROR_NOENCRYPTION:
|
|
g_HTMLErrInstr = IDS_ERROR_HOMENETINVALIDENC;
|
|
break;
|
|
case ERRUSER_ERROR_CANTUNPACKIMAGE:
|
|
g_HTMLErrInstr = IDS_ERROR_TRANSPORTINTERNALERROR;
|
|
break;
|
|
case ERRUSER_ERROR_CANTSAVEOBJECT:
|
|
case ERRUSER_ERROR_CANTRESTOREOBJECT:
|
|
if (errExtraData->ErrorArea == ERRUSER_AREA_SAVE) {
|
|
g_HTMLErrInstr = IDS_ERROR_CANTSAVEOBJECT;
|
|
} else {
|
|
g_HTMLErrInstr = IDS_ERROR_CANTRESTOREOBJECT;
|
|
}
|
|
if (errExtraData->ObjectTypeId && errExtraData->ObjectName) {
|
|
objectType = IsmGetObjectTypeName (errExtraData->ObjectTypeId);
|
|
if (objectType) {
|
|
objectName = IsmGetNativeObjectName (errExtraData->ObjectTypeId, errExtraData->ObjectName);
|
|
if (objectName) {
|
|
if (StrCmpI (objectType, TEXT("File")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnFile;
|
|
g_HTMLWrnFile = wrnObj;
|
|
} else if (StrCmpI (objectType, TEXT("RasConnection")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnRas;
|
|
g_HTMLWrnRas = wrnObj;
|
|
} else if (StrCmpI (objectType, TEXT("MappedDrives")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnNet;
|
|
g_HTMLWrnNet = wrnObj;
|
|
} else if (StrCmpI (objectType, TEXT("Printers")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnPrn;
|
|
g_HTMLWrnPrn = wrnObj;
|
|
}
|
|
IsmReleaseMemory (objectName);
|
|
objectName = NULL;
|
|
}
|
|
objectType = NULL;
|
|
}
|
|
}
|
|
break;
|
|
case ERRUSER_WARNING_OUTLOOKRULES:
|
|
g_HTMLErrInstr = IDS_ERROR_CANTRESTOREOBJECT;
|
|
LoadString(g_hInstance, IDS_WARNING_OUTLOOKRULES, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wrnObj = _AllocateObjectList (szErrMsg);
|
|
wrnObj->Next = g_HTMLWrnGeneral;
|
|
g_HTMLWrnGeneral = wrnObj;
|
|
break;
|
|
case ERRUSER_WARNING_OERULES:
|
|
g_HTMLErrInstr = IDS_ERROR_CANTRESTOREOBJECT;
|
|
LoadString(g_hInstance, IDS_WARNING_OERULES, szErrMsg, ARRAYSIZE(szErrMsg));
|
|
wrnObj = _AllocateObjectList (szErrMsg);
|
|
wrnObj->Next = g_HTMLWrnGeneral;
|
|
g_HTMLWrnGeneral = wrnObj;
|
|
break;
|
|
case ERRUSER_ERROR_DISKSPACE:
|
|
g_HTMLErrInstr = IDS_ERROR_DISKSPACE;
|
|
break;
|
|
}
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case MODULEMESSAGE_DISPLAYWARNING:
|
|
errExtraData = (PERRUSER_EXTRADATA) pArg;
|
|
if (errExtraData) {
|
|
switch (errExtraData->Error) {
|
|
case ERRUSER_ERROR_CANTSAVEOBJECT:
|
|
case ERRUSER_ERROR_CANTRESTOREOBJECT:
|
|
if (errExtraData->ObjectTypeId && errExtraData->ObjectName) {
|
|
objectType = IsmGetObjectTypeName (errExtraData->ObjectTypeId);
|
|
if (objectType) {
|
|
objectName = IsmGetNativeObjectName (errExtraData->ObjectTypeId, errExtraData->ObjectName);
|
|
if (objectName) {
|
|
if (StrCmpI (objectType, TEXT("File")) == 0) {
|
|
// If we are restoring this file, we are going to try
|
|
// to write it to a default location where the user
|
|
// can find it later
|
|
if (errExtraData->Error == ERRUSER_ERROR_CANTRESTOREOBJECT) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
if (pForceRestoreObject (errExtraData->ObjectName, wrnObj)) {
|
|
wrnObj->Next = g_HTMLWrnAltFile;
|
|
g_HTMLWrnAltFile = wrnObj;
|
|
} else {
|
|
wrnObj->Next = g_HTMLWrnFile;
|
|
g_HTMLWrnFile = wrnObj;
|
|
}
|
|
} else {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnFile;
|
|
g_HTMLWrnFile = wrnObj;
|
|
}
|
|
} else if (StrCmpI (objectType, TEXT("RasConnection")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnRas;
|
|
g_HTMLWrnRas = wrnObj;
|
|
} else if (StrCmpI (objectType, TEXT("MappedDrives")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnNet;
|
|
g_HTMLWrnNet = wrnObj;
|
|
} else if (StrCmpI (objectType, TEXT("Printers")) == 0) {
|
|
wrnObj = _AllocateObjectList (objectName);
|
|
wrnObj->Next = g_HTMLWrnPrn;
|
|
g_HTMLWrnPrn = wrnObj;
|
|
}
|
|
IsmReleaseMemory (objectName);
|
|
objectName = NULL;
|
|
}
|
|
objectType = NULL;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_NET_DISPLAY_PASSWORD:
|
|
passwordData = (PPASSWORD_DATA) pArg;
|
|
if (passwordData) {
|
|
DialogBoxParam (
|
|
g_hInstance,
|
|
MAKEINTRESOURCE(IDD_DISPLAY_PASSWORD),
|
|
g_hwndCurrent,
|
|
_DisplayPasswordDlgProc,
|
|
(LPARAM)passwordData
|
|
);
|
|
}
|
|
return APPRESPONSE_SUCCESS;
|
|
|
|
case TRANSPORTMESSAGE_NET_GATHER_PASSWORD:
|
|
passwordData = (PPASSWORD_DATA) pArg;
|
|
if (passwordData) {
|
|
if (DialogBoxParam (
|
|
g_hInstance,
|
|
MAKEINTRESOURCE(IDD_GATHER_PASSWORD),
|
|
g_hwndCurrent,
|
|
_GatherPasswordDlgProc,
|
|
(LPARAM)passwordData
|
|
)) {
|
|
return APPRESPONSE_SUCCESS;
|
|
}
|
|
}
|
|
return APPRESPONSE_FAIL;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
HRESULT MigrationWizard::_InitEngine(BOOL fSource, BOOL* pfNetworkDetected)
|
|
{
|
|
HRESULT hr;
|
|
|
|
TCHAR szAppPath[MAX_PATH] = TEXT("");
|
|
TCHAR* pszAppPathOffset;
|
|
|
|
GetModuleFileName (NULL, szAppPath, ARRAYSIZE(szAppPath));
|
|
pszAppPathOffset = _tcsrchr (szAppPath, TEXT('\\'));
|
|
if (pszAppPathOffset) {
|
|
pszAppPathOffset ++;
|
|
} else {
|
|
pszAppPathOffset = szAppPath;
|
|
}
|
|
_tcsncpy (pszAppPathOffset, TEXT("migism.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
|
|
|
|
hr = Engine_Initialize(szAppPath, fSource, TRUE, _pszUsername, MessageCallback, pfNetworkDetected);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_fInit = TRUE;
|
|
|
|
_tcsncpy (pszAppPathOffset, TEXT("migwiz.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_tcsncpy (pszAppPathOffset, TEXT("usmtdef.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_tcsncpy (pszAppPathOffset, TEXT("migapp.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_tcsncpy (pszAppPathOffset, TEXT("migsys.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_tcsncpy (pszAppPathOffset, TEXT("miguser.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
_tcsncpy (pszAppPathOffset, TEXT("sysfiles.inf"), ARRAYSIZE(szAppPath) - (pszAppPathOffset - szAppPath));
|
|
hr = Engine_AppendScript(fSource, szAppPath);
|
|
}
|
|
|
|
if (fSource)
|
|
{
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = Engine_Parse();
|
|
}
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
HRESULT MigrationWizard::SelectComponentSet(UINT uSelectionGroup)
|
|
{
|
|
if (_fOOBEMode)
|
|
{
|
|
Engine_SelectComponentSet(MIGINF_SELECT_OOBE);
|
|
}
|
|
else
|
|
{
|
|
Engine_SelectComponentSet(uSelectionGroup);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|