Microsoft/Windows2000
Microsoft/Windows2000
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
45f4a58588
Windows2000/private/windbg64/dbgwiz/pagedefs.cpp

1764 lines
56 KiB
C++
Raw Normal View History

First commit
2001-01-01 00:00:00 +01:00
#include "precomp.hxx"
#pragma hdrstop
BOOL PAGE_DEF::m_bDisplayingMoreInfo = FALSE;
COMPORT_INFO SELECT_PORT_BAUD_PAGE_DEF::m_rgComPortInfo[100] = {0};
DWORD SELECT_PORT_BAUD_PAGE_DEF::m_dwNumComPortsFound = 0;
DWORD SELECT_PORT_BAUD_PAGE_DEF::m_dwSelectedCommPort = 0;
PAGE_DEF::
PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
BOOL bMoreInfoPage
)
{
// If running IE 3, then replace the dlg with the hacked version
if (g_bRunning_IE_3) {
switch (nDlgRsrcId) {
case IDD_ADV_COPY_SYMS:
nDlgRsrcId = IDD_H_ADV_COPY_SYMS;
break;
case IDD_BROWSE_PATH:
nDlgRsrcId = IDD_H_BROWSE_PATH;
break;
case IDD_FOUR_OPT:
nDlgRsrcId = IDD_H_FOUR_OPT;
break;
case IDD_SELECT_PORT:
nDlgRsrcId = IDD_H_SELECT_PORT;
break;
case IDD_SELECT_PORT_BAUD:
nDlgRsrcId = IDD_H_SELECT_PORT_BAUD;
break;
case IDD_SELECT_PORT_BAUD_PIPE:
nDlgRsrcId = IDD_H_SELECT_PORT_BAUD_PIPE;
break;
case IDD_SELECT_PORT_BAUD_PIPE_COMPNAME:
nDlgRsrcId = IDD_H_SELECT_PORT_BAUD_PIPE_COMPNAME;
break;
case IDD_STD_COPY_SYMS:
nDlgRsrcId = IDD_H_STD_COPY_SYMS;
break;
case IDD_SUMMARY:
nDlgRsrcId = IDD_H_SUMMARY;
break;
case IDD_TEXT_ONLY:
nDlgRsrcId = IDD_H_TEXT_ONLY;
break;
case IDD_THREE_OPT:
nDlgRsrcId = IDD_H_THREE_OPT;
break;
case IDD_TWO_OPT:
nDlgRsrcId = IDD_H_TWO_OPT;
break;
case IDD_TWO_OPT_BROWSE_PATH:
nDlgRsrcId = IDD_H_TWO_OPT_BROWSE_PATH;
break;
case IDD_WELCOME:
nDlgRsrcId = IDD_H_WELCOME;
break;
}
}
m_hDlg = NULL;
m_nPageId = nPageId;
m_nDlgRsrcId = nDlgRsrcId;
m_hpsp = NULL;
m_nMoreInfo_PageId = nMoreInfo_PageId;
m_nHeaderTitleStrId = nHeaderTitleStrId;
m_nHeaderSubTitleStrId = nHeaderSubTitleStrId;
m_bMoreInfoPage = bMoreInfoPage;
}
PAGEID
PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
if (!bCalcNextPage) {
Assert(!"Should not happen");
return NULL_PAGEID;
} else {
switch (m_nPageId) {
default:
Assert(!"Should not happen");
return NULL_PAGEID;
case OS_SYM_LOC_SYMCPY_PAGEID:
case SP_SYM_LOC_SYMCPY_PAGEID:
// Here we have to figure out where we are and where to go.
// Can we be certain if the we know the service pack
// number with any certainty.
// We cannot be certain if we are trying to install symbols
// for the target machine and did not use a cfg file, so we must ask the user.
if (!g_CfgData.AreWeUsingACfgFile() &&
(enumREMOTE_USERMODE == g_CfgData.m_DebugMode
|| enumKERNELMODE == g_CfgData.m_DebugMode
|| enumDUMP == g_CfgData.m_DebugMode) ) {
if (OS_SYM_LOC_SYMCPY_PAGEID == m_nPageId) {
return SP_SYM_LOC_SYMCPY_PAGEID;
} else if (SP_SYM_LOC_SYMCPY_PAGEID == m_nPageId) {
return HOTFIX_SYM_LOC_SYMCPY_PAGEID;
}
Assert(!"Should not have happened.");
return NULL_PAGEID;
} else {
// The information we have is correct.
// Do we need to copy Service Pack symbols
if (OS_SYM_LOC_SYMCPY_PAGEID == m_nPageId
&& g_CfgData.m_dwServicePack) {
return SP_SYM_LOC_SYMCPY_PAGEID;
}
// Do we need to copy any HotFix symbols
if (g_CfgData.m_pszHotFixes && *g_CfgData.m_pszHotFixes) {
return HOTFIX_SYM_LOC_SYMCPY_PAGEID;
}
// Anything else to copy??
return ASK_ADDITIONAL_SYM_LOC_SYMCPY_PAGEID;
}
break;
}
}
}
void
PAGE_DEF::
CreatePropPage()
{
PROPSHEETPAGE psp = {0};
psp.hInstance = g_hInst;
psp.pfnDlgProc = (DLGPROC) WizardStub_DlgProc;
psp.pszTemplate = MAKEINTRESOURCE( m_nDlgRsrcId );
if (g_bRunning_IE_3) {
psp.dwSize = sizeof(IE_3_PROP_PAGE);
psp.dwFlags = PSP_DEFAULT;
} else {
psp.dwSize = sizeof(PROPSHEETPAGE);
psp.dwFlags = PSP_DEFAULT;
#if (_WIN32_IE >= 0x0400)
psp.dwFlags |= PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
psp.pszHeaderTitle = MAKEINTRESOURCE( m_nHeaderTitleStrId );
psp.pszHeaderSubTitle = MAKEINTRESOURCE( m_nHeaderSubTitleStrId );
#endif
}
m_hpsp = CreatePropertySheetPage(&psp);
Assert(m_hpsp);
}
int
PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
BOOL bStatus = TRUE;
switch (uMsg) {
case WM_NCDESTROY:
m_hDlg = NULL;
break;
case WM_INITDIALOG:
// Fall thru
case UM_DLG_PAGE_SETACTIVE:
if (NULL_PAGEID == m_nMoreInfo_PageId) {
HWND hwndMoreInfoBut = GetDlgItem(hDlg, IDC_BUT_MORE_INFO);
Assert(hwndMoreInfoBut);
ShowWindow(hwndMoreInfoBut, SW_HIDE);
}
{
PAGEID pageidNext = GetNextPage();
LPARAM l = 0;
if (!g_stack.IsEmpty()) {
l |= PSWIZB_BACK;
}
if (NULL_PAGEID != pageidNext || (m_bDisplayingMoreInfo && NULL_PAGEID == pageidNext) ) {
l |= PSWIZB_NEXT;
}
if (THE_END_PAGEID == pageidNext) {
l |= PSWIZB_FINISH;
}
PostMessage(GetParent(hDlg), PSM_SETWIZBUTTONS, 0, l);
}
// Special code to handle the case where we are displaying 'More Info'
if (m_bMoreInfoPage && !m_bDisplayingMoreInfo) {
// If this is a 'More Info' page, but we are no longer displaying more
// info, then all of the more info pages must be removed. We accept the activation
// But we immediately hit the back button.
PostMessage(GetParent(hDlg), PSM_PRESSBUTTON, PSBTN_BACK, 0);
}
break;
case WM_COMMAND:
{
WORD wNotifyCode = HIWORD(wParam); // notification code
WORD wID = LOWORD(wParam); // item, control, or accelerator identifier
HWND hwndCtl = (HWND) lParam; // handle of control
if (hwndCtl) {
switch (wID) {
case IDC_BUT_MORE_INFO:
// This is from the 'More Info" button
Assert(FALSE == m_bDisplayingMoreInfo); // More info screen can't have more info
m_bDisplayingMoreInfo = TRUE;
PostMessage(GetParent(hDlg), PSM_PRESSBUTTON, PSBTN_NEXT, 0);
break;
case IDC_BUT_BROWSE:
{
PSTR pszInitDir = NULL;
PSTR pszFileMask = NULL;
char szTmpPath[_MAX_PATH] = {0};
switch (m_nPageId) {
case USER_EXE_PROCESS_CHOICE_PAGEID:
pszFileMask = WKSP_DynaLoadString(g_hInst, IDS_FILE_MASK_EXE);
pszInitDir = NT4SafeStrDup("");
BrowseForFile(hDlg, pszInitDir, pszFileMask, IDC_EDIT_PATH);
break;
case CRASHDUMP_PAGEID:
pszFileMask = WKSP_DynaLoadString(g_hInst, IDS_FILE_MASK_DMP);
Assert(GetWindowsDirectory(szTmpPath, sizeof(szTmpPath)));
pszInitDir = NT4SafeStrDup(szTmpPath);
BrowseForFile(hDlg, pszInitDir, pszFileMask, IDC_EDIT_PATH);
break;
case OS_SYM_LOC_SYMCPY_PAGEID:
case SP_SYM_LOC_SYMCPY_PAGEID:
case HOTFIX_SYM_LOC_SYMCPY_PAGEID:
case ADDITIONAL_SYM_LOC_SYMCPY_PAGEID:
case GET_DEST_DIR_SYMCPY_PAGEID:
BrowseForDir(hDlg, IDC_EDIT_PATH);
break;
default:
pszInitDir = NT4SafeStrDup("a:\\");
pszFileMask = WKSP_DynaLoadString(g_hInst, IDS_FILE_MASK_INF);
if (SAVE_INI_FILE_PAGEID == m_nPageId) {
char sz[_MAX_PATH];
GetDlgItemText(hDlg, IDC_EDIT_PATH, sz, sizeof(sz));
SaveFileDlg(hDlg, sz, sizeof(sz), pszInitDir, pszFileMask, IDC_EDIT_PATH);
} else {
BrowseForFile(hDlg, pszInitDir, pszFileMask, IDC_EDIT_PATH);
}
}
if (pszInitDir) {
free(pszInitDir);
}
if (pszFileMask) {
free(pszFileMask);
}
}
break;
}
}
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_QUERYCANCEL:
{
PSTR pszWarning = WKSP_DynaLoadString(g_hInst, IDS_GEN_WARNING_HDR);
BOOL bPreventCancel = IDNO == WKSP_CustMsgBox(
MB_ICONHAND | MB_TASKMODAL | MB_YESNO,
pszWarning, IDS_CONFIRM_CANCEL);
free(pszWarning);
if (!bPreventCancel) {
CleanupAfterWizard(hDlg);
}
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, bPreventCancel);
}
break;
case PSN_WIZNEXT:
{
// Really get the next page
PAGEID pageidNext = GetNextPage(TRUE);
// Special code to handle the case where we are displaying 'More Info'
if (m_bMoreInfoPage) {
Assert(m_bDisplayingMoreInfo);
if (NULL_PAGEID == pageidNext) {
// End of 'More Info' pages.
m_bDisplayingMoreInfo = FALSE;
// Do not go forward
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
// Go back
PostMessage(GetParent(hDlg), PSM_PRESSBUTTON, PSBTN_BACK, 0);
}
} else {
if (NULL_PAGEID == pageidNext) {
// Invalid page, stay here
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
} else if (GOTO_PREV_PAGEID == pageidNext) {
// Do not go forward
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
// Go back
PostMessage(GetParent(hDlg), PSM_PRESSBUTTON, PSBTN_BACK, 0);
} else {
extern PAGEID g_nNewPageIdx;
Assert(NULL_PAGEID == g_nNewPageIdx);
if (!m_bDisplayingMoreInfo) {
g_nNewPageIdx = pageidNext;
} else {
Assert(m_nMoreInfo_PageId);
g_nNewPageIdx = m_nMoreInfo_PageId;
}
g_stack.PushEntry(m_nPageId);
Assert(FIRST_PAGEID <= g_nNewPageIdx);
Assert(g_nNewPageIdx < MAX_NUM_PAGEID);
Assert(g_nNewPageIdx == g_rgpPageDefs[g_nNewPageIdx]->m_nPageId);
Assert(g_rgpPageDefs[g_nNewPageIdx]->m_hpsp);
// Let the prop sheet switch to the next page
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, 0);
SendMessage(GetParent(hDlg), PSM_ADDPAGE, 0, (LPARAM) g_rgpPageDefs[g_nNewPageIdx]->m_hpsp);
}
}
}
break;
case PSN_WIZBACK:
{
if (g_stack.IsEmpty()) {
// We are at the first page, can't go anywhere
Assert(!"Ignorable Error: Back button should have been disabled");
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
} else {
// Go ahead and move back
PAGEID nIdx = g_stack.PopEntry();
Assert(g_rgpPageDefs[nIdx]->m_hDlg);
PostMessage(g_rgpPageDefs[nIdx]->m_hDlg, UM_DLG_PAGE_SETACTIVE, 0, 0);
if (!g_rgpPageDefs[nIdx]->m_bMoreInfoPage) {
m_bDisplayingMoreInfo = FALSE;
}
PostMessage(GetParent(hDlg), PSM_REMOVEPAGE, -1, (LPARAM) m_hpsp);
// The prop sheet destroys that page, we need to create a new one
CreatePropPage();
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, 0);
}
}
break;
default:
bStatus = FALSE;
break;
}
}
break;
default:
bStatus = FALSE;
break;
}
return bStatus;
}
int
WELCOME_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
// We don't want the text only functionality
return PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
WELCOME_PAGE_DEF::
WELCOME_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId,
BOOL bMoreInfoPage
)
: TEXT_ONLY_PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId, bMoreInfoPage)
{
}
PAGEID
TEXT_ONLY_PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
if (m_bDisplayingMoreInfo && NULL_PAGEID != m_nMoreInfo_PageId) {
return m_nMoreInfo_PageId;
} else {
return m_nNextPageId;
}
}
TEXT_ONLY_PAGE_DEF::
TEXT_ONLY_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId,
BOOL bMoreInfoPage
)
: PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId, bMoreInfoPage)
{
m_nNextPageId = nNextPageId;
m_nMainTextStrId = nTextStrId;
}
int
TEXT_ONLY_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
int nRes = 0;
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_INITDIALOG:
case UM_DLG_PAGE_SETACTIVE:
{
HWND hwndEdit = GetDlgItem(hDlg, IDC_STXT_MAIN);
Assert(hwndEdit);
if (WM_INITDIALOG == uMsg) {
PSTR pszMainText = WKSP_DynaLoadString(g_hInst, m_nMainTextStrId);
Assert(pszMainText);
Assert(SetDlgItemText(hDlg, IDC_STXT_MAIN, pszMainText));
free(pszMainText);
}
// Remove any text selections
PostMessage(hwndEdit, EM_SETSEL, -1, 0);
}
break;
}
return PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
int
DISPLAY_SUMMARY_INFO_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_INITDIALOG:
{
DWORD dwServicePack = 0;
PSTR pszArchitecture = NULL;
PSTR pszDebugFree = NULL;
PSTR pszServerOrWorkstation = NULL; // wrkstation or server
PSTR pszHotFixes = NULL;
PSTR pszConnection = NULL;
PSTR pszMainText = NULL;
Assert(enumREMOTE_USERMODE == g_CfgData.m_DebugMode
|| enumKERNELMODE == g_CfgData.m_DebugMode);
// Get architecture
if (PROCESSOR_ARCHITECTURE_MIPS == g_CfgData.m_si.wProcessorArchitecture) {
pszArchitecture = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_MIPS);
} else if (PROCESSOR_ARCHITECTURE_INTEL == g_CfgData.m_si.wProcessorArchitecture) {
pszArchitecture = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_INTEL);
} else if (PROCESSOR_ARCHITECTURE_ALPHA == g_CfgData.m_si.wProcessorArchitecture) {
pszArchitecture = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_ALPHA);
} else if (PROCESSOR_ARCHITECTURE_PPC == g_CfgData.m_si.wProcessorArchitecture) {
pszArchitecture = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_PPC);
} else {
pszArchitecture = WKSP_DynaLoadString(g_hInst, IDS_UNKNOWN);
}
Assert(pszArchitecture);
// Get service pack
sscanf(g_CfgData.m_osi.szCSDVersion, "Service Pack %lu", &dwServicePack);
// Figure out if it's a workstation, server, enterprise server
{
HKEY hkey = NULL;
char sz[_MAX_PATH] = {0};
DWORD dwType;
DWORD dwSize = sizeof(sz);
Assert(ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE, "SYSTEM\\CurrentControlSet\\Control\\ProductOptions", 0, KEY_READ, &hkey));
Assert(ERROR_SUCCESS == RegQueryValueEx(hkey, "ProductType", NULL, &dwType, (PUCHAR) sz, &dwSize));
if (!_stricmp(sz, "WinNT")) {
pszServerOrWorkstation = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_WORKSTATION);
} else if (!_stricmp(sz, "ServerNT")) {
// Its a server, but is the enterprise version.
dwSize = sizeof(sz);
if (ERROR_SUCCESS == RegQueryValueEx(hkey, "ProductSuite", NULL, &dwType, (PUCHAR) sz, &dwSize)) {
Assert(REG_MULTI_SZ == dwType);
if (!_stricmp(sz, "Enterprise")) {
pszServerOrWorkstation = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_ENTERPRISE);
} else {
pszServerOrWorkstation = WKSP_DynaLoadString(g_hInst, IDS_UNKNOWN);
}
} else {
pszServerOrWorkstation = WKSP_DynaLoadString(g_hInst, IDS_OS_DESC_SERVER);
}
} else {
pszServerOrWorkstation = WKSP_DynaLoadString(g_hInst, IDS_UNKNOWN);
}
Assert(ERROR_SUCCESS == RegCloseKey(hkey));
}
// Get HotFixes
if (g_CfgData.m_pszHotFixes) {
pszHotFixes = NT4SafeStrDup(g_CfgData.m_pszHotFixes);
} else {
pszHotFixes = WKSP_DynaLoadString(g_hInst, IDS_NONE);
}
// Get OS description
PSTR pszOs;
{
char szServicePack[20] = {0};
if (dwServicePack) {
_ultoa(dwServicePack, szServicePack, 10);
} else {
PSTR pszNone = WKSP_DynaLoadString(g_hInst, IDS_NONE);
strcpy(szServicePack, pszNone);
free(pszNone);
}
pszOs = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_OS_SUMMARY,
g_CfgData.m_osi.dwMajorVersion, g_CfgData.m_osi.dwMinorVersion, g_CfgData.m_osi.dwBuildNumber,
pszArchitecture, pszServerOrWorkstation, g_CfgData.m_pszFreeCheckedBuild,
szServicePack, pszHotFixes);
}
// Build connection string
if (enumKERNELMODE == g_CfgData.m_DebugMode) {
Assert(g_CfgData.m_bSerial);
PSTR pszSerial = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_SERIAL_CONNECTION, BaudRateBitFlagToText(g_CfgData.m_dwBaudRate));
pszConnection = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_KERNEL_SUMMARY, pszSerial);
free(pszSerial);
} else {
if (g_CfgData.m_bSerial) {
PSTR pszSerial = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_SERIAL_CONNECTION, BaudRateBitFlagToText(g_CfgData.m_dwBaudRate));
pszSerial = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_REMOTE_USER_SUMMARY, pszSerial);
free(pszSerial);
} else {
Assert(g_CfgData.m_pszCompName);
Assert(g_CfgData.m_pszPipeName);
PSTR pszNetwork = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_NETWORK_CONNECTION, g_CfgData.m_pszCompName, g_CfgData.m_pszPipeName);
pszConnection = WKSP_DynaLoadStringWithArgs(g_hInst, IDS_REMOTE_USER_SUMMARY, pszNetwork);
free(pszNetwork);
}
}
// Get Main text
pszMainText = WKSP_DynaLoadStringWithArgs(g_hInst, m_nMainTextStrId, pszConnection, pszOs);
Assert(pszMainText);
// Display the text
Assert(SetDlgItemText(hDlg, IDC_EDIT_MAIN, pszMainText));
free(pszOs);
free(pszArchitecture);
free(pszDebugFree);
free(pszServerOrWorkstation);
free(pszHotFixes);
free(pszConnection);
free(pszMainText);
}
// Fall thru
case UM_DLG_PAGE_SETACTIVE:
// Make so that the text is not currently selected
{
HWND hwnd = GetDlgItem(hDlg, IDC_EDIT_MAIN);
Assert(hwnd);
PostMessage(hwnd, EM_SETSEL, (WPARAM) (int) -1, 0);
}
// Skip over TEXT_ONLY, because it will try to reload the main
// text
return PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
return TEXT_ONLY_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
DISPLAY_SUMMARY_INFO_PAGE_DEF::
DISPLAY_SUMMARY_INFO_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId,
BOOL bMoreInfoPage
)
: TEXT_ONLY_PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId, bMoreInfoPage)
{
}
PAGEID
SELECT_PORT_BAUD_PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
switch (m_nPageId) {
case KERNEL_SELECT_PORT_BAUD_PAGEID:
if (g_CfgData.m_bRunningOnHost) {
m_nNextPageId = SYMBOL_FILE_COPY_PAGEID;
} else {
m_nNextPageId = SAVE_INI_FILE_PAGEID;
}
break;
}
return TEXT_ONLY_PAGE_DEF::GetNextPage(bCalcNextPage);
}
SELECT_PORT_BAUD_PAGE_DEF::
SELECT_PORT_BAUD_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId,
BOOL bMoreInfoPage
)
: TEXT_ONLY_PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId, bMoreInfoPage)
{
static BOOL bInitStaticData = TRUE;
if (bInitStaticData) {
bInitStaticData = FALSE;
EnumComPorts(m_rgComPortInfo, sizeof(m_rgComPortInfo) / sizeof(COMPORT_INFO), m_dwNumComPortsFound);
}
m_dwSelectedCommPort = 0;
}
int
SELECT_PORT_BAUD_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
HWND hwndPort = GetDlgItem(hDlg, IDC_COMBO_COMM_PORT);
PSTR pszSeparator = " ";
switch (uMsg) {
case WM_INITDIALOG:
{
g_CfgData.m_bSerial = TRUE;
BOOL bIncludeBaud = m_nDlgRsrcId != IDD_SELECT_PORT;
#define ADD_STR_TO_CMBO(bit) \
if (m_rgComPortInfo[dw].dwSettableBaud & bit) { \
strcpy(sz, m_rgComPortInfo[dw].szSymName); \
if (bIncludeBaud) { \
strcat(sz, pszSeparator); \
strcat(sz, BaudRateBitFlagToText(bit)); \
} \
\
LRESULT lRes = SendMessage(hwndPort, CB_ADDSTRING, 0, (LPARAM) sz); \
Assert(CB_ERRSPACE != lRes && CB_ERR != lRes); \
SendMessage(hwndPort, CB_SETITEMDATA, lRes, MAKELPARAM(dw, bit)); \
}
char sz[256];
DWORD dw;
for (dw=0; dw<m_dwNumComPortsFound; dw++) {
if (!bIncludeBaud) {
LRESULT lRes = SendMessage(hwndPort, CB_ADDSTRING,
0, (LPARAM) m_rgComPortInfo[dw].szSymName);
Assert(CB_ERRSPACE != lRes && CB_ERR != lRes);
SendMessage(hwndPort, CB_SETITEMDATA, lRes, MAKELPARAM(dw, 0));
} else {
ADD_STR_TO_CMBO(BAUD_9600);
ADD_STR_TO_CMBO(BAUD_14400);
ADD_STR_TO_CMBO(BAUD_19200);
ADD_STR_TO_CMBO(BAUD_38400);
}
}
#undef ADD_STR_TO_CMBO
// Select the previously selected item or just select the
// first one.
if (0 == m_dwSelectedCommPort) {
// Just grab the first one
SendMessage(hwndPort, CB_SETCURSEL, 0, 0);
} else {
dw = LOWORD(m_dwSelectedCommPort);
strcpy(sz, m_rgComPortInfo[dw].szSymName);
if (bIncludeBaud) {
strcat(sz, pszSeparator);
strcat(sz, BaudRateBitFlagToText(HIWORD(m_dwSelectedCommPort)));
}
LRESULT lCurSel = SendMessage(hwndPort, CB_FINDSTRINGEXACT, -1, (LPARAM) sz);
Assert(CB_ERR != lCurSel);
SendMessage(hwndPort, CB_SETCURSEL, lCurSel, 0);
}
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_WIZNEXT:
case PSN_WIZBACK:
{
LRESULT lCurSel = SendMessage(hwndPort, CB_GETCURSEL, 0, 0);
Assert(CB_ERR != lCurSel);
m_dwSelectedCommPort = (ULONG)SendMessage(hwndPort, CB_GETITEMDATA, lCurSel, 0);
Assert(CB_ERR != m_dwSelectedCommPort);
g_CfgData.m_dwBaudRate = HIWORD(m_dwSelectedCommPort);
if (g_CfgData.m_pszCommPortName) {
free(g_CfgData.m_pszCommPortName);
}
g_CfgData.m_pszCommPortName = NT4SafeStrDup(m_rgComPortInfo[LOWORD(m_dwSelectedCommPort)].szSymName);
}
break;
}
}
break;
}
return TEXT_ONLY_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
void
SELECT_PORT_BAUD_PIPE_COMPNAME_PAGE_DEF::
GrayDlgItems()
{
Assert(m_hDlg);
m_bSerial = IsDlgButtonChecked(m_hDlg, IDC_RADIO_SERIAL) == BST_CHECKED;
EnableWindow(GetDlgItem(m_hDlg, IDC_EDIT_MACHINE_NAME), !m_bSerial);
EnableWindow(GetDlgItem(m_hDlg, IDC_STXT_MACHINE_NAME), !m_bSerial);
EnableWindow(GetDlgItem(m_hDlg, IDC_EDIT_PIPE_NAME), !m_bSerial);
EnableWindow(GetDlgItem(m_hDlg, IDC_STXT_PIPE_NAME), !m_bSerial);
EnableWindow(GetDlgItem(m_hDlg, IDC_STXT_COMM_PORT), m_bSerial);
EnableWindow(GetDlgItem(m_hDlg, IDC_COMBO_COMM_PORT), m_bSerial);
}
SELECT_PORT_BAUD_PIPE_COMPNAME_PAGE_DEF::
SELECT_PORT_BAUD_PIPE_COMPNAME_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId,
BOOL bMoreInfoPage
)
: SELECT_PORT_BAUD_PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId, bMoreInfoPage)
{
char sz[MAX_COMPUTERNAME_LENGTH + 1] = {0};
DWORD dwSize = sizeof(sz);
Assert(GetComputerName(sz, &dwSize));
m_bSerial = FALSE;
m_pszCompName = NT4SafeStrDup(sz);
m_pszPipeName = NT4SafeStrDup("windbg");
}
int
SELECT_PORT_BAUD_PIPE_COMPNAME_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
// These may be present
HWND hwndCompNameEdit = GetDlgItem(hDlg, IDC_EDIT_MACHINE_NAME);
HWND hwndCompNameStxt = GetDlgItem(hDlg, IDC_STXT_MACHINE_NAME);
// these should always be present
HWND hwndPipeEdit = GetDlgItem(hDlg, IDC_EDIT_PIPE_NAME);
HWND hwndPipeStxt = GetDlgItem(hDlg, IDC_STXT_PIPE_NAME);
switch (uMsg) {
case WM_COMMAND:
{
WORD wNotifyCode = HIWORD(wParam); // notification code
WORD wID = LOWORD(wParam); // item, control, or accelerator identifier
HWND hwndCtl = (HWND) lParam; // handle of control
if (hwndCtl) {
switch (wNotifyCode) {
case BN_CLICKED:
GrayDlgItems();
break;
}
}
}
break;
case WM_INITDIALOG:
{
Assert(CheckDlgButton(hDlg, IDC_RADIO_NETWORK, !m_bSerial ? BST_CHECKED : BST_UNCHECKED));
Assert(CheckDlgButton(hDlg, IDC_RADIO_SERIAL, m_bSerial ? BST_CHECKED : BST_UNCHECKED));
if (hwndCompNameEdit) {
SendMessage(hwndCompNameEdit, EM_LIMITTEXT, MAX_COMPUTERNAME_LENGTH, 0);
if (m_pszCompName) {
SetWindowText(hwndCompNameEdit, m_pszCompName);
}
}
// See docs (CreateNamedPipe) for max pipe name len
SendMessage(hwndPipeEdit, EM_LIMITTEXT, 256 - strlen("\\\\.\\pipe\\"), 0);
if (m_pszPipeName) {
SetWindowText(hwndPipeEdit, m_pszPipeName);
}
GrayDlgItems();
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_WIZNEXT:
case PSN_WIZBACK:
{
char sz[1024] = {0};
// Get the comp name if present
if (hwndCompNameEdit) {
GetWindowText(hwndCompNameEdit, sz, sizeof(sz));
if (m_pszCompName) {
free(m_pszCompName);
}
m_pszCompName = NT4SafeStrDup(sz);
}
// Get the pipe name
GetWindowText(hwndPipeEdit, sz, sizeof(sz));
if (m_pszPipeName) {
free(m_pszPipeName);
}
m_pszPipeName = NT4SafeStrDup(sz);
if (!m_bDisplayingMoreInfo &&!m_bSerial && PSN_WIZNEXT == pnmh->code) {
if (!*m_pszPipeName) {
// Stay here
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
WKSP_MsgBox(NULL, IDS_ERROR_NEED_PIPE_NAME);
return TRUE;
}
if (hwndCompNameEdit && !*m_pszCompName) {
// Stay here
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
WKSP_MsgBox(NULL, IDS_ERROR_NEED_COMP_NAME);
return TRUE;
}
}
// Copy the data out to the global data
g_CfgData.m_bSerial = m_bSerial;
// Copy serial data
// Copy Net data
if (g_CfgData.m_pszCompName) {
free(g_CfgData.m_pszCompName);
}
g_CfgData.m_pszCompName = NT4SafeStrDup(m_pszCompName);
if (g_CfgData.m_pszPipeName) {
free(g_CfgData.m_pszPipeName);
}
g_CfgData.m_pszPipeName = NT4SafeStrDup(m_pszPipeName);
}
break;
}
}
break;
}
return SELECT_PORT_BAUD_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
HELP_TEXT_ONLY_PAGE_DEF::
HELP_TEXT_ONLY_PAGE_DEF(
PAGEID nPageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId
)
: TEXT_ONLY_PAGE_DEF(nPageId, IDD_TEXT_ONLY, NULL_PAGEID,
nHeaderTitleStrId, nHeaderSubTitleStrId, nTextStrId, nNextPageId, TRUE)
{
}
BROWSE_PATH_PAGE_DEF::
BROWSE_PATH_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId
)
: TEXT_ONLY_PAGE_DEF(nPageId, nDlgRsrcId,
nMoreInfo_PageId, nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId)
{
m_pszPath = NULL;
}
PAGEID
BROWSE_PATH_PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
if (!bCalcNextPage) {
return m_nNextPageId;
} else {
switch (m_nPageId) {
default:
return m_nNextPageId;
case GET_DEST_DIR_SYMCPY_PAGEID:
{
// Make sure that the user is not trying to perform a
// recursive copy.
PSTR pszSrc;
BOOL bRecursive = FALSE;
char szDest[_MAX_PATH] = {0};
GetDlgItemText(m_hDlg, IDC_EDIT_PATH, szDest, sizeof(szDest));
if (!bRecursive && g_CfgData.m_bCopyOS_SymPath) {
pszSrc = g_CfgData.m_pszOS_SymPath;
if (!_strnicmp(szDest, pszSrc, strlen(pszSrc) ) ) {
// Recursive copy
bRecursive = TRUE;
}
}
if (!bRecursive && g_CfgData.m_bCopySP_SymPath) {
pszSrc = g_CfgData.m_pszSP_SymPath;
if (!_strnicmp(szDest, pszSrc, strlen(pszSrc) ) ) {
// Recursive copy
bRecursive = TRUE;
}
}
if (!bRecursive && g_CfgData.m_bCopyHotFix_SymPath) {
pszSrc = g_CfgData.m_pszHotFix_SymPath;
if (!_strnicmp(szDest, pszSrc, strlen(pszSrc) ) ) {
// Recursive copy
bRecursive = TRUE;
}
}
if (!bRecursive && g_CfgData.m_bCopyAdditional_SymPath) {
TListEntry<PSTR> * pSymPathEntry = g_CfgData.m_list_pszAdditional_SymPath.FirstEntry();
for (; pSymPathEntry != g_CfgData.m_list_pszAdditional_SymPath.Stop();
pSymPathEntry = pSymPathEntry->Flink) {
pszSrc = pSymPathEntry->m_tData;
if (!_strnicmp(szDest, pszSrc, strlen(pszSrc) ) ) {
// Recursive copy
bRecursive = TRUE;
}
}
}
if (!bRecursive) {
// None of the copies are recursive
return m_nNextPageId;
} else {
// User is trying to recursively copy symbol files
WKSP_MsgBox(NULL, IDS_ERROR_SYM_COPY_IS_RECURSIVE,
szDest, pszSrc);
return NULL_PAGEID;
}
}
break;
case TARGET_CONFIG_FILE_LOCATION_PAGEID:
{
// Load ini file. Decide where to go from there
TARGET_CFG_INFO TargInfo;
if (TargInfo.Read(m_pszPath)) {
g_CfgData.UseCfgFile();
if (enumREMOTE_USERMODE == g_CfgData.m_DebugMode) {
if (g_CfgData.m_bSerial) {
return SELECT_PORT_PAGEID;
} else {
return SYMBOL_FILE_COPY_PAGEID;
}
} else if (enumKERNELMODE == g_CfgData.m_DebugMode) {
return SELECT_PORT_PAGEID;
} else {
Assert(!"Bad file not caught.");
g_CfgData.DoNotUseCfgFile();
return NULL_PAGEID;
}
} else {
g_CfgData.DoNotUseCfgFile();
return NULL_PAGEID;
}
}
break;
}
}
}
int
BROWSE_PATH_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_INITDIALOG:
{
if (!m_pszPath) {
if (TARGET_CONFIG_FILE_LOCATION_PAGEID == m_nPageId) {
m_pszPath = NT4SafeStrDup("a:\\dbgwiz.inf");
} else if (m_nPageId == OS_SYM_LOC_SYMCPY_PAGEID) {
m_pszPath = NT4SafeStrDup(g_CfgData.m_pszOS_SymPath);
} else if (m_nPageId == ADDITIONAL_SYM_LOC_SYMCPY_PAGEID) {
m_pszPath = NT4SafeStrDup("a:\\");
} else if (m_nPageId == CRASHDUMP_PAGEID) {
m_pszPath = NT4SafeStrDup(g_CfgData.m_pszDumpFileName);
}
}
HWND hwndPath = GetDlgItem(hDlg, IDC_EDIT_PATH);
Assert(hwndPath);
PostMessage(hwndPath, EM_LIMITTEXT, _MAX_PATH -1, 0);
if (m_pszPath) {
SetDlgItemText(hDlg, IDC_EDIT_PATH, m_pszPath);
}
}
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_WIZNEXT:
case PSN_WIZBACK:
{
char sz[_MAX_PATH] = {0};
GetDlgItemText(hDlg, IDC_EDIT_PATH, sz, sizeof(sz));
if (m_pszPath) {
free(m_pszPath);
}
m_pszPath = NT4SafeStrDup(sz);
if (!m_bDisplayingMoreInfo && !*sz && PSN_WIZNEXT == pnmh->code) {
// Stay here
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
WKSP_MsgBox(NULL, IDS_ERROR_NEED_PATH);
return TRUE;
}
}
break;
}
}
break;
}
BOOL bRet = TEXT_ONLY_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
// We update this data if we are moving to the next page
// AND we have data to update
if (WM_NOTIFY == uMsg && PSN_WIZNEXT == ((LPNMHDR)lParam)->code
&& m_pszPath) {
if (-1 == GetWindowLongPtr(hDlg, DWLP_MSGRESULT)) {
if (ADDITIONAL_SYM_LOC_SYMCPY_PAGEID == m_nPageId) {
UINT uSize;
DWORD dwSerial;
UINT uDriveType;
PSTR pszTmp = NULL;
g_CfgData.m_bCopyAdditional_SymPath = TRUE;
g_CfgData.m_list_pszAdditional_SymPath.InsertTail(m_pszPath);
// Get Disk info
GetDiskInfo(m_pszPath, pszTmp, dwSerial, uDriveType);
g_CfgData.m_list_pszAdditional_VolumeLabel_SymPath.InsertTail(pszTmp);
g_CfgData.m_list_dwAdditional_SerialNum_SymPath.InsertTail(dwSerial);
g_CfgData.m_list_uAdditional_DriveType_SymPath.InsertTail(uDriveType);
}
} else {
// Conditional jumps, and the setting of flags
switch(m_nPageId) {
case CRASHDUMP_PAGEID:
if (g_CfgData.m_pszDumpFileName) {
free(g_CfgData.m_pszDumpFileName);
}
g_CfgData.m_pszDumpFileName = NT4SafeStrDup(m_pszPath);
break;
case SHORTCUT_NAME_PAGEID:
// Cleanup old stuff
DeleteLinkOnDesktop(hDlg, g_CfgData.m_pszDeskTopShortcut_FullPath);
if (g_CfgData.m_pszShortCutName) {
free(g_CfgData.m_pszShortCutName);
}
g_CfgData.m_pszShortCutName = NT4SafeStrDup(m_pszPath);
g_CfgData.m_pszDeskTopShortcut_FullPath = CreateLinkOnDesktop(hDlg, m_pszPath, TRUE);
break;
case GET_DEST_DIR_SYMCPY_PAGEID:
if (g_CfgData.m_pszDestinationPath) {
free(g_CfgData.m_pszDestinationPath);
}
g_CfgData.m_pszDestinationPath = NT4SafeStrDup(m_pszPath);
break;
}
}
}
return bRet;
}
PAGEID
DESKTOP_SHORTCUT_PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
if (g_CfgData.m_bDisplaySummaryInfo && !g_CfgData.m_bRunningOnHost) {
return DISPLAY_SUMMARY_INFO_PAGEID;
} else {
return FINISH_PAGEID;
}
}
DESKTOP_SHORTCUT_PAGE_DEF::
DESKTOP_SHORTCUT_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId
)
: BROWSE_PATH_PAGE_DEF(nPageId, nDlgRsrcId,
nMoreInfo_PageId, nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId)
{
}
int
DESKTOP_SHORTCUT_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_INITDIALOG:
ShowWindow(GetDlgItem(hDlg, IDC_BUT_BROWSE), SW_HIDE);
break;
}
return BROWSE_PATH_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
COPY_SYMS_PAGE_DEF::
COPY_SYMS_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
int nTextStrId,
PAGEID nNextPageId
)
: TEXT_ONLY_PAGE_DEF(nPageId, nDlgRsrcId,
nMoreInfo_PageId, nHeaderTitleStrId, nHeaderSubTitleStrId,
nTextStrId, nNextPageId)
{
ZeroMemory(m_rgpszMsgs, sizeof(m_rgpszMsgs));
}
COPY_SYMS_PAGE_DEF::
~COPY_SYMS_PAGE_DEF()
{
for (int i=0; i<nMAX_NUM_MSGS; i++) {
if (m_rgpszMsgs[i]) {
free(m_rgpszMsgs[i]);
m_rgpszMsgs[i] = NULL;
}
}
}
BOOL
COPY_SYMS_PAGE_DEF::
Copy(
HWND hwnd,
PSTR pszDest,
PSTR pszSrc,
PSTR pszVolumeName,
DWORD dwSerialNumber,
UINT uDriveType
)
{
BOOL bSuccess = FALSE;
PSTR pszVol_Tmp = NULL;
DWORD dwSerial_Tmp = 0;
UINT uDriveType_Tmp = 0;
COPY_SYMBOLS_DATA_STRUCT CopySyms;
BOOL bWrongDisk = FALSE;
do {
GetDiskInfo(pszSrc, pszVol_Tmp, dwSerial_Tmp, uDriveType_Tmp);
bWrongDisk = dwSerial_Tmp != dwSerialNumber || uDriveType_Tmp != uDriveType
|| NULL == pszVolumeName || NULL == pszVol_Tmp
|| strcmp(pszVolumeName, pszVol_Tmp);
if (bWrongDisk) {
if (IDCANCEL == WKSP_CustMsgBox(
MB_RETRYCANCEL | MB_ICONSTOP | MB_TASKMODAL,
NULL, IDS_ERROR_INCORRECT_PATH, pszVolumeName)) {
goto CLEANUP;
}
}
} while (bWrongDisk);
if (DRIVE_FIXED == uDriveType) {
if (!AreAnyOfTheFilesCompressed(TRUE, pszSrc)) {
// None of the files are compressed and were are referring to
// a fixed disk.
PSTR pszInfo = WKSP_DynaLoadString(g_hInst, IDS_INFORMATIONAL);
WKSP_MsgBox(pszInfo, IDS_WARN_NON_REMOVABLE_MEDIA_ADD_PATH, pszSrc);
free(pszInfo);
g_SymPaths.InsertTail(NT4SafeStrDup(pszSrc));
goto CLEANUP;
}
} else if (DRIVE_REMOTE == uDriveType) {
if (!AreAnyOfTheFilesCompressed(TRUE, pszSrc)) {
// None of the files are compressed
PSTR pszInfo = WKSP_DynaLoadString(g_hInst, IDS_INFORMATIONAL);
if (IDYES == WKSP_CustMsgBox(MB_YESNO | MB_ICONINFORMATION | MB_TASKMODAL,
pszInfo, IDS_WARN_WILL_NETWORK_CONNECTION_BE_AVAILABLE, pszSrc)) {
WKSP_MsgBox(pszInfo, IDS_WARN_FILES_LINKED_INSTEAD_OF_COPIED);
free(pszInfo);
g_SymPaths.InsertTail(NT4SafeStrDup(pszSrc));
goto CLEANUP;
}
free(pszInfo);
}
}
// Copy the files
strcpy(CopySyms.m_szSrcPath, pszSrc);
strcpy(CopySyms.m_szDestPath, pszDest);
bSuccess = (IDOK == DialogBoxParam(g_hInst,
MAKEINTRESOURCE(IDD_COPYING), hwnd,
Copying_DlgProc, (LPARAM) &CopySyms));
if (bSuccess) {
g_SymPaths.InsertTail(NT4SafeStrDup(pszDest));
}
CLEANUP:
if (pszVol_Tmp) {
free(pszVol_Tmp);
}
return bSuccess;
}
int
COPY_SYMS_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_INITDIALOG:
PostMessage(hDlg, UM_START_STD_MODE_COPYING, 0, 0);
break;
case UM_START_STD_MODE_COPYING:
{
BOOL bContinueCopying = TRUE;
int nIdx;
int nCurrentlyCopying;
char sz[1024 * 5];
ZeroMemory(m_rgpszMsgs, sizeof(m_rgpszMsgs));
if (g_CfgData.m_bCopyOS_SymPath) {
m_rgpszMsgs[0] = WKSP_DynaLoadString(g_hInst, IDS_COPYING_OS);
}
if (g_CfgData.m_bCopySP_SymPath) {
m_rgpszMsgs[1] = WKSP_DynaLoadString(g_hInst, IDS_COPYING_SP);
}
if (g_CfgData.m_bCopyHotFix_SymPath) {
m_rgpszMsgs[2] = WKSP_DynaLoadString(g_hInst, IDS_COPYING_HOTFIXES);
}
if (g_CfgData.m_bCopyAdditional_SymPath) {
m_rgpszMsgs[3] = WKSP_DynaLoadString(g_hInst, IDS_COPYING_ADDITIONAL_SYMBOLS);
}
for (nCurrentlyCopying = 0; bContinueCopying && nCurrentlyCopying<nMAX_NUM_MSGS;
nCurrentlyCopying++) {
if (!m_rgpszMsgs[nCurrentlyCopying]) {
continue;
}
*sz = NULL;
for (nIdx=0; nIdx<nMAX_NUM_MSGS; nIdx++) {
if (m_rgpszMsgs[nIdx]) {
if (nCurrentlyCopying == nIdx) {
strcat(sz, "\r\n Copying -> ");
} else {
strcat(sz, "\r\n ");
}
strcat(sz, m_rgpszMsgs[nIdx]);
}
}
SetDlgItemText(hDlg, IDC_STATIC_COPY_STATUS, sz);
// If the drive is removable we copy the symbols
// If it a network, we ask if it will be available during
// the debug session.
// If it is a hard disk simply link to it.
// Prompt the user to insert the correct CD
PSTR pszVolumeName = NULL;
DWORD dwSerial = 0;
UINT uDriveType = 0;
switch(nCurrentlyCopying) {
case 0:
// OS syms
bContinueCopying = Copy(hDlg,
g_CfgData.m_pszDestinationPath,
g_CfgData.m_pszOS_SymPath,
g_CfgData.m_pszOS_VolumeLabel_SymPath,
g_CfgData.m_dwOS_SerialNum_SymPath,
g_CfgData.m_uOS_DriveType_SymPath);
break;
case 1:
// SP syms
bContinueCopying = Copy(hDlg,
g_CfgData.m_pszDestinationPath,
g_CfgData.m_pszSP_SymPath,
g_CfgData.m_pszSP_VolumeLabel_SymPath,
g_CfgData.m_dwSP_SerialNum_SymPath,
g_CfgData.m_uSP_DriveType_SymPath);
break;
case 2:
// Hotfix syms
bContinueCopying = Copy(hDlg,
g_CfgData.m_pszDestinationPath,
g_CfgData.m_pszHotFix_SymPath,
g_CfgData.m_pszHotFix_VolumeLabel_SymPath,
g_CfgData.m_dwHotFix_SerialNum_SymPath,
g_CfgData.m_uHotFix_DriveType_SymPath);
break;
case 3:
// Additional syms
{
Assert(g_CfgData.m_list_pszAdditional_SymPath.Size()
== g_CfgData.m_list_pszAdditional_VolumeLabel_SymPath.Size());
Assert(g_CfgData.m_list_dwAdditional_SerialNum_SymPath.Size()
== g_CfgData.m_list_pszAdditional_VolumeLabel_SymPath.Size());
Assert(g_CfgData.m_list_dwAdditional_SerialNum_SymPath.Size()
== g_CfgData.m_list_uAdditional_DriveType_SymPath.Size());
TListEntry<PSTR> * pSymPathEntry = g_CfgData.m_list_pszAdditional_SymPath.FirstEntry();
TListEntry<PSTR> * pVolLblEntry = g_CfgData.m_list_pszAdditional_VolumeLabel_SymPath.FirstEntry();
TListEntry<DWORD> * pSerialNumEntry = g_CfgData.m_list_dwAdditional_SerialNum_SymPath.FirstEntry();
TListEntry<UINT> * pDriveTypeEntry = g_CfgData.m_list_uAdditional_DriveType_SymPath.FirstEntry();
for (; bContinueCopying && pSymPathEntry != g_CfgData.m_list_pszAdditional_SymPath.Stop();
pSymPathEntry = pSymPathEntry->Flink,
pVolLblEntry = pVolLblEntry->Flink,
pSerialNumEntry = pSerialNumEntry->Flink,
pDriveTypeEntry = pDriveTypeEntry->Flink) {
bContinueCopying = Copy(hDlg,
g_CfgData.m_pszDestinationPath,
pSymPathEntry->m_tData,
pVolLblEntry->m_tData,
pSerialNumEntry->m_tData,
pDriveTypeEntry->m_tData);
}
}
break;
}
}
for (nIdx=0; nIdx<nMAX_NUM_MSGS; nIdx++) {
if (m_rgpszMsgs[nIdx]) {
free(m_rgpszMsgs[nIdx]);
m_rgpszMsgs[nIdx] = NULL;
}
}
}
return TRUE;
}
return TEXT_ONLY_PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
void
ADV_COPY_SYMS_PAGE_DEF::
GrayDlgItems()
{
Assert(m_hDlg);
m_bCopySymbols = IsDlgButtonChecked(m_hDlg, IDC_RADIO_COPY_SYMBOLS) == BST_CHECKED;
EnableWindow(GetDlgItem(m_hDlg, IDC_STXT_DEST), m_bCopySymbols);
EnableWindow(GetDlgItem(m_hDlg, IDC_EDIT_DEST), m_bCopySymbols);
EnableWindow(GetDlgItem(m_hDlg, IDC_BUT_BROWSE_DEST), m_bCopySymbols);
}
int
ADV_COPY_SYMS_PAGE_DEF::
DlgProc(
IN HWND hDlg,
IN UINT uMsg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
Assert(m_hDlg == hDlg);
switch (uMsg) {
case WM_COMMAND:
{
WORD wNotifyCode = HIWORD(wParam); // notification code
WORD wID = LOWORD(wParam); // item, control, or accelerator identifier
HWND hwndCtl = (HWND) lParam; // handle of control
if (hwndCtl && BN_CLICKED == wNotifyCode) {
// A radio button or the copy button was clicked
GrayDlgItems();
switch (wID) {
case IDC_BUT_BROWSE_SRC:
BrowseForDir(hDlg, IDC_EDIT_SRC);
break;
case IDC_BUT_BROWSE_DEST:
BrowseForDir(hDlg, IDC_EDIT_DEST);
break;
case IDC_BUT_COPY:
{
// The copy button was clicked.
char szSrc[_MAX_PATH] = {0};
char szDest[_MAX_PATH] = {0};
GetDlgItemText(hDlg, IDC_EDIT_SRC, szSrc, sizeof(szSrc));
GetDlgItemText(hDlg, IDC_EDIT_DEST, szDest, sizeof(szDest));
if (!*szSrc) {
WKSP_MsgBox(NULL, IDS_ERROR_NEED_SRC_PATH);
break;
}
if (m_bCopySymbols && !*szDest) {
WKSP_MsgBox(NULL, IDS_ERROR_NEED_DEST_PATH);
break;
}
if (m_bCopySymbols) {
COPY_SYMBOLS_DATA_STRUCT CopySyms;
strcpy(CopySyms.m_szSrcPath, szSrc);
strcpy(CopySyms.m_szDestPath, szDest);
if (IDOK == DialogBoxParam(g_hInst,
MAKEINTRESOURCE(IDD_COPYING), hDlg,
Copying_DlgProc, (LPARAM) &CopySyms)) {
g_SymPaths.InsertTail(NT4SafeStrDup(szDest));
}
} else {
g_SymPaths.InsertTail(NT4SafeStrDup(szSrc));
}
}
break;
}
}
}
break;
case WM_INITDIALOG:
CheckDlgButton(hDlg, IDC_RADIO_LINK_SYMBOLS, m_bCopySymbols ? BST_UNCHECKED : BST_CHECKED);
CheckDlgButton(hDlg, IDC_RADIO_COPY_SYMBOLS, m_bCopySymbols ? BST_CHECKED : BST_UNCHECKED);
SetDlgItemText(hDlg, IDC_EDIT_SRC, g_CfgData.m_pszOS_SymPath);
SendDlgItemMessage(hDlg, IDC_EDIT_SRC, EM_LIMITTEXT, _MAX_PATH -1, 0);
SendDlgItemMessage(hDlg, IDC_EDIT_DEST, EM_LIMITTEXT, _MAX_PATH -1, 0);
break;
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR)lParam;
switch( pnmh->code ) {
case PSN_WIZNEXT:
if (!m_bDisplayingMoreInfo && 0 == g_SymPaths.Size()) {
// Proceed without any symbols
PSTR pszWarn = WKSP_DynaLoadString(g_hInst, IDS_WARN_ADV_NO_SYMBOLS_SPECIFIED);
if (IDNO == WKSP_CustMsgBox(MB_ICONINFORMATION | MB_TASKMODAL | MB_YESNO,
pszWarn, IDS_WARN_ADV_NO_SYMBOLS_SPECIFIED)) {
SetWindowLongPtr(hDlg, DWLP_MSGRESULT, -1);
return TRUE;
}
free(pszWarn);
}
case PSN_WIZBACK:
GrayDlgItems();
break;
}
}
break;
}
return PAGE_DEF::DlgProc(hDlg, uMsg, wParam, lParam);
}
PAGEID
ADV_COPY_SYMS_PAGE_DEF::
GetNextPage(
BOOL bCalcNextPage
)
{
return m_nNextPageId;
}
ADV_COPY_SYMS_PAGE_DEF::
ADV_COPY_SYMS_PAGE_DEF(
PAGEID nPageId,
int nDlgRsrcId,
PAGEID nMoreInfo_PageId,
int nHeaderTitleStrId,
int nHeaderSubTitleStrId,
PAGEID nNextPageId
)
: PAGE_DEF(nPageId, nDlgRsrcId, nMoreInfo_PageId,
nHeaderTitleStrId, nHeaderSubTitleStrId, FALSE)
{
m_nNextPageId = nNextPageId;
m_bCopySymbols = FALSE;
}
Reference in New Issue Copy Permalink