windows-nt/Source/XPSP1/NT/base/remoteboot/rbinstal/dialogs.cpp

1493 lines
44 KiB
C++
Raw Normal View History

2020-09-26 03:20:57 -05:00
/****************************************************************************
Copyright (c) Microsoft Corporation 1997
All rights reserved
***************************************************************************/
#include "pch.h"
#include <windowsx.h>
#include <prsht.h>
#include <shlobj.h>
#include <setupapi.h>
#include <pshpack2.h>
#include <poppack.h>
#include <commctrl.h> // includes the common control header
#include "setup.h"
DEFINE_MODULE("Dialogs");
#define WIZPAGE_FULL_PAGE_WATERMARK 0x00000001
#define WIZPAGE_SEPARATOR_CREATED 0x00000002
#define SMALL_BUFFER_SIZE 256
#define BITMAP_WIDTH 16
#define BITMAP_HEIGHT 16
#define LG_BITMAP_WIDTH 32
#define LG_BITMAP_HEIGHT 32
//
// Stuff used for watermarking
//
CONST BITMAPINFOHEADER *g_pbihWatermark;
PVOID g_pWatermarkBitmapBits;
HPALETTE g_hWatermarkPalette;
INT g_uWatermarkPaletteColorCount;
WNDPROC g_OldWizardProc;
//
// Enum for SetDialogFont().
//
typedef enum {
DlgFontTitle,
DlgFontBold
} MyDlgFont;
VOID
SetDialogFont(
IN HWND hdlg,
IN UINT ControlId,
IN MyDlgFont WhichFont
)
{
static HFONT BigBoldFont = NULL;
static HFONT BoldFont = NULL;
static HFONT NormalFont = NULL;
HFONT Font;
LOGFONT LogFont;
TCHAR FontSizeString[24];
int FontSize;
HDC hdc;
DWORD dw;
switch(WhichFont) {
case DlgFontTitle:
if(!BigBoldFont) {
if ( Font =
(HFONT) SendDlgItemMessage( hdlg, ControlId, WM_GETFONT, 0, 0) )
{
if ( GetObject( Font, sizeof(LOGFONT), &LogFont) )
{
dw = LoadString( g_hinstance,
IDS_LARGEFONTNAME,
LogFont.lfFaceName,
LF_FACESIZE);
Assert( dw );
LogFont.lfWeight = 700;
FontSize = 15;
if ( hdc = GetDC(hdlg) )
{
LogFont.lfHeight =
0 - (GetDeviceCaps(hdc,LOGPIXELSY) * FontSize / 72);
BigBoldFont = CreateFontIndirect(&LogFont);
ReleaseDC(hdlg,hdc);
}
}
}
}
Font = BigBoldFont;
break;
case DlgFontBold:
if ( !BoldFont )
{
if ( Font =
(HFONT) SendDlgItemMessage( hdlg, ControlId, WM_GETFONT, 0, 0 ))
{
if ( GetObject( Font, sizeof(LOGFONT), &LogFont ) )
{
LogFont.lfWeight = FW_BOLD;
if ( hdc = GetDC( hdlg ) )
{
BoldFont = CreateFontIndirect( &LogFont );
ReleaseDC( hdlg, hdc );
}
}
}
}
Font = BoldFont;
break;
default:
//
// Nothing to do here.
//
Font = NULL;
break;
}
if( Font )
{
SendDlgItemMessage( hdlg, ControlId, WM_SETFONT, (WPARAM) Font, 0 );
}
}
//
// Paints the watermark.
//
BOOL
PaintWatermark(
IN HWND hdlg,
IN HDC DialogDC,
IN UINT XOffset,
IN UINT YOffset,
IN UINT YHeight )
{
HPALETTE OldPalette;
RECT rect;
int Height;
int Width;
OldPalette = SelectPalette( DialogDC, g_hWatermarkPalette, TRUE );
Width = g_pbihWatermark->biWidth - ( 2 * XOffset );
Height = ( YHeight ? YHeight : g_pbihWatermark->biHeight ) - YOffset;
SetDIBitsToDevice(
DialogDC,
0,
0,
Width,
Height,
XOffset,
YHeight ? ( g_pbihWatermark->biHeight - YHeight ) : YHeight,
0, g_pbihWatermark->biHeight,
g_pWatermarkBitmapBits,
(BITMAPINFO *) g_pbihWatermark,
DIB_RGB_COLORS );
GetClientRect( hdlg, &rect );
if ( Height && Height < rect.bottom )
{
ExcludeClipRect( DialogDC, 0, 0, Width + 2 * XOffset, Height );
return FALSE;
}
return TRUE;
}
//
// Paints the watermark background within an HWND
//
BOOL
PaintBackgroundWithWatermark(
HWND hDlg,
HWND hwnd,
HDC hDC )
{
RECT rc1, rc2;
RECT rcDivider;
HWND hwndDivider = GetDlgItem( hDlg, IDC_DIVIDER );
GetClientRect( GetParent( hDlg ), &rc1 );
MapWindowPoints( GetParent( hDlg ), NULL, (POINT *) &rc1, 2 );
GetClientRect( hwnd, &rc2 );
MapWindowPoints( hwnd, NULL, (POINT *) &rc2, 2 );
if ( hwndDivider )
{
GetClientRect( hwndDivider, &rcDivider );
MapWindowPoints( hwndDivider, GetParent( hDlg ),
(POINT *) &rcDivider, 2 );
}
else
{
rcDivider.top = 0;
}
return PaintWatermark( hwnd, hDC, rc2.left-rc1.left,
rc2.top-rc1.top, rcDivider.top );
}
//
// Check to see if the directory exists. If not, ask the user if we
// should create it.
//
BOOL
CheckDirectory( HWND hDlg, LPTSTR pszPath, BOOL fAllowCreate )
{
BOOL fReturn = FALSE;
WIN32_FILE_ATTRIBUTE_DATA fad;
DWORD dwAttrib = GetFileAttributes( pszPath );
if ( dwAttrib == 0xFFFFffff )
{
if ( ERROR_FILE_NOT_FOUND == GetLastError( ) )
{
if ( fAllowCreate &&
IDYES == MessageBoxFromStrings( hDlg, IDS_CREATEDIRCAPTION, IDS_CREATEDIRTEXT, MB_YESNO ) )
{
g_Options.fCreateDirectory = TRUE;
fReturn = TRUE;
goto Cleanup;
}
else if ( !fAllowCreate )
{
MessageBoxFromStrings( hDlg, IDS_DIRDOESNOTEXISTCAPTION, IDS_DIRDOESNOTEXISTTEXT, MB_OK );
}
}
goto Cleanup;
}
fReturn = TRUE;
Cleanup:
SetWindowLong( hDlg, DWL_MSGRESULT, (fReturn ? 0 : -1 ) );
return fReturn;
}
//
// Adjusts and draws a bitmap transparently in the RECT prc.
//
void DrawBitmap(
HANDLE hBitmap,
LPDRAWITEMSTRUCT lpdis,
LPRECT prc )
{
BITMAP bm;
HDC hDCBitmap;
int dy;
GetObject( hBitmap, sizeof(bm), &bm );
hDCBitmap = CreateCompatibleDC( NULL );
SelectObject( hDCBitmap, hBitmap );
// center the image
dy = 2 + prc->bottom - bm.bmHeight;
StretchBlt( lpdis->hDC, prc->left, prc->top + dy, prc->right, prc->bottom,
hDCBitmap, 0, 0, bm.bmWidth, bm.bmHeight, SRCAND );
DeleteDC( hDCBitmap );
}
//
// Draws a bitmap transparently in reponse to a WM_DRAWITEM
//
void
DrawBitmap(
HANDLE hBitmap,
LPDRAWITEMSTRUCT lpdis )
{
HDC hDCBitmap;
hDCBitmap = CreateCompatibleDC( NULL );
SelectObject( hDCBitmap, hBitmap );
BitBlt( lpdis->hDC, 0, 0, lpdis->rcItem.right, lpdis->rcItem.bottom,
hDCBitmap, 0, 0, SRCAND );
DeleteDC( hDCBitmap );
}
//
// Verifies that the user wanted to cancel setup.
//
BOOL
VerifyCancel( HWND hParent )
{
TCHAR szText[ SMALL_BUFFER_SIZE ];
TCHAR szCaption[ SMALL_BUFFER_SIZE ];
dw = LoadString( g_hinstance, IDS_CANCELCAPTION, szCaption,
ARRAYSIZE( szCaption ));
Assert( dw );
dw = LoadString( g_hinstance, IDS_CANCELTEXT, szText,
ARRAYSIZE( szText ));
Assert( dw );
g_Options.fAbort =
( IDYES == MessageBoxFromStrings( hParent,
IDS_CANCELCAPTION,
IDS_CANCELTEXT,
MB_YESNO ) );
SetWindowLong( hParent, DWL_MSGRESULT, ( g_Options.fAbort ? 0 : - 1 ) );
return !g_Options.fAbort;
}
//
// Base dialog proc - all unhandled calls are passed here. If they are not
// handled here, then the default dialog proc will handle them.
//
BOOL CALLBACK
BaseDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
switch ( uMsg )
{
case WM_INITDIALOG:
SetDialogFont( hDlg, IDC_S_TITLE1, DlgFontTitle );
//SetDialogFont( hDlg, IDC_S_TITLE2, DlgFontTitle );
//SetDialogFont( hDlg, IDC_S_TITLE3, DlgFontTitle );
SetDialogFont( hDlg, IDC_S_BOLD1, DlgFontBold );
SetDialogFont( hDlg, IDC_S_BOLD2, DlgFontBold );
SetDialogFont( hDlg, IDC_S_BOLD3, DlgFontBold );
break;
case WM_DRAWITEM:
if ( LOWORD( wParam ) >= IDC_I_BUTTON1 &&
LOWORD( wParam ) <= IDC_I_BUTTON7 )
DrawBitmap( g_hGraphic, (LPDRAWITEMSTRUCT) lParam );
break;
case WM_PALETTECHANGED:
if ((HWND)wParam != hDlg)
{
InvalidateRect(hDlg, NULL, NULL);
UpdateWindow(hDlg);
}
break;
case WM_ERASEBKGND:
return PaintBackgroundWithWatermark( hDlg, hDlg, (HDC) wParam );
case WM_CTLCOLORSTATIC:
if ( LOWORD( wParam ) == IDC_DIVIDER )
{
return FALSE;
}
else
{
// erase background
PaintBackgroundWithWatermark( hDlg, (HWND) lParam, (HDC) wParam );
// setup transparent mode
SetBkMode( (HDC) wParam, TRANSPARENT );
SetBkColor( (HDC) wParam, GetSysColor( COLOR_3DFACE ) );
return( (BOOL) GetStockObject( HOLLOW_BRUSH ) );
}
break;
default:
return FALSE;
}
return TRUE;
}
//
// "Welcome's" (the first page's) dialog proc.
//
BOOL CALLBACK
WelcomeDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
static BOOL fFirstTime = FALSE;
switch ( uMsg )
{
case WM_INITDIALOG:
CenterDialog( GetParent( hDlg ) );
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZNEXT:
case PSN_WIZBACK:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_NEXT );
ClearMessageQueue( );
// eliminate flicker
if ( !fFirstTime )
{
fFirstTime = TRUE;
}
else
{
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, NULL );
}
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
//
// Remote Boot Directory dialog proc.
//
BOOL CALLBACK
RemoteBootDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
DWORD dw;
switch ( uMsg )
{
case WM_INITDIALOG:
Edit_SetText( GetDlgItem( hDlg, IDC_E_RBPATH), g_Options.szRemoteBootPath );
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_WIZBACK:
case PSN_KILLACTIVE:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_WIZNEXT:
Edit_GetText( GetDlgItem( hDlg, IDC_E_RBPATH ), g_Options.szRemoteBootPath, ARRAYSIZE( g_Options.szRemoteBootPath ));
g_Options.fCreateDirectory = FALSE;
CheckDirectory( hDlg, g_Options.szRemoteBootPath, TRUE );
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
if ( g_Options.fError || g_Options.fKnowRBDirectory )
{
SetWindowLong( hDlg, DWL_MSGRESULT, -1 ); // do not show this page
}
else
{
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_RBPATH) );
PropSheet_SetWizButtons( GetParent( hDlg ),
dwLen ? PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
ClearMessageQueue( );
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
}
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
case WM_COMMAND:
switch( LOWORD( wParam))
{
case IDC_E_RBPATH:
{
if ( HIWORD(wParam) == EN_CHANGE )
{
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_RBPATH) );
PropSheet_SetWizButtons( GetParent( hDlg ),
dwLen ? PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
}
}
break;
case IDC_B_BROWSE:
{
TCHAR szTitle[ SMALL_BUFFER_SIZE ];
BROWSEINFO bs;
ZeroMemory( &bs, sizeof(bs) );
bs.hwndOwner = hDlg;
dw = LoadString( g_hinstance, IDS_BROWSECAPTION_RBDIR, szTitle, ARRAYSIZE( szTitle ) );
Assert( dw );
bs.lpszTitle = (LPTSTR) &szTitle;
bs.ulFlags = BIF_RETURNONLYFSDIRS | BIF_RETURNFSANCESTORS;
LPITEMIDLIST pidl = SHBrowseForFolder( &bs );
SHGetPathFromIDList( pidl, g_Options.szRemoteBootPath );
Edit_SetText( GetDlgItem( hDlg, IDC_E_RBPATH ), g_Options.szRemoteBootPath );
}
break;
default:
break;
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
//
// OS Name dialog proc.
//
BOOL CALLBACK
OSDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
switch ( uMsg )
{
case WM_INITDIALOG:
Edit_SetText( GetDlgItem( hDlg, IDC_E_OSNAME ), g_Options.szName );
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZBACK:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_WIZNEXT:
Edit_GetText( GetDlgItem( hDlg, IDC_E_OSNAME ), g_Options.szName, ARRAYSIZE( g_Options.szName ) );
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
{
if ( g_Options.fError )
{
SetWindowLong( hDlg, DWL_MSGRESULT, -1 ); // do not show this page
}
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_OSNAME) );
PropSheet_SetWizButtons( GetParent( hDlg ),
dwLen ? PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
ClearMessageQueue( );
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
}
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
case WM_COMMAND:
switch( LOWORD( wParam))
{
case IDC_E_OSNAME:
{
if ( HIWORD(wParam) == EN_CHANGE )
{
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_OSNAME ) );
PropSheet_SetWizButtons( GetParent( hDlg ),
dwLen ? PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
}
}
break;
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
//
// Remote Boot Directory dialog proc.
//
BOOL CALLBACK
SourceDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
DWORD dw;
switch ( uMsg )
{
case WM_INITDIALOG:
Edit_SetText( GetDlgItem( hDlg, IDC_E_SOURCEPATH ), g_Options.szSourcePath );
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZBACK:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_WIZNEXT:
{
DWORD dwLen;
Edit_GetText( GetDlgItem( hDlg, IDC_E_SOURCEPATH ), g_Options.szSourcePath, ARRAYSIZE( g_Options.szSourcePath ) );
dwLen = lstrlen( g_Options.szSourcePath ) - 1;
if ( g_Options.szSourcePath[ dwLen ] == TEXT('\\') )
{
g_Options.szSourcePath[ dwLen ] = 0;
}
if ( CheckDirectory( hDlg, g_Options.szSourcePath, FALSE ) )
{
HANDLE hFile;
hFile = OpenLayoutInf( );
if ( hFile == INVALID_HANDLE_VALUE )
{
MessageBoxFromStrings( hDlg, IDS_INVALIDSOURCECAPTION, IDS_INVALIDSOURCETEXT, MB_OK );
SetWindowLong( hDlg, DWL_MSGRESULT, -1 );
}
else
{
SetupCloseInfFile( hFile );
}
}
g_Options.fIntel =
( ( 0x0003 & Button_GetState( GetDlgItem( hDlg, IDC_C_INTEL ) ) ) ==
BST_CHECKED );
g_Options.fAlpha =
( ( 0x0003 & Button_GetState( GetDlgItem( hDlg, IDC_C_ALPHA ) ) ) ==
BST_CHECKED );
}
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
{
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_SOURCEPATH) );
PropSheet_SetWizButtons( GetParent( hDlg ),
dwLen ? PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
ClearMessageQueue( );
}
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
case WM_COMMAND:
switch( LOWORD( wParam))
{
case IDC_E_SOURCEPATH:
if ( HIWORD(wParam) != EN_CHANGE )
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
// fall thru...
case IDC_C_INTEL:
case IDC_C_ALPHA:
{
g_Options.fIntel =
( ( 0x0003 & Button_GetState( GetDlgItem( hDlg, IDC_C_INTEL ) ) ) ==
BST_CHECKED );
g_Options.fAlpha =
( ( 0x0003 & Button_GetState( GetDlgItem( hDlg, IDC_C_ALPHA ) ) ) ==
BST_CHECKED );
DWORD dwLen = Edit_GetTextLength( GetDlgItem( hDlg, IDC_E_SOURCEPATH ) );
PropSheet_SetWizButtons( GetParent( hDlg ),
( dwLen && ( g_Options.fIntel || g_Options.fAlpha )) ?
PSWIZB_BACK | PSWIZB_NEXT : PSWIZB_BACK );
}
break;
case IDC_B_BROWSE:
{
TCHAR szTitle[ SMALL_BUFFER_SIZE ];
BROWSEINFO bs;
ZeroMemory( &bs, sizeof(bs) );
bs.hwndOwner = hDlg;
dw = LoadString( g_hinstance, IDS_BROWSECAPTION_SOURCEDIR, szTitle, ARRAYSIZE( szTitle ) );
Assert( dw );
bs.lpszTitle = (LPTSTR) &szTitle;
bs.ulFlags = BIF_RETURNONLYFSDIRS | BIF_RETURNFSANCESTORS;
LPITEMIDLIST pidl = SHBrowseForFolder( &bs );
SHGetPathFromIDList( pidl, g_Options.szSourcePath );
Edit_SetText( GetDlgItem( hDlg, IDC_E_SOURCEPATH ), g_Options.szSourcePath );
}
break;
default:
break;
}
break;
case WM_CTLCOLORSTATIC:
if ( (HWND) lParam != GetDlgItem( hDlg, IDC_C_INTEL ) &&
(HWND) lParam != GetDlgItem( hDlg, IDC_C_ALPHA) )
{
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return FALSE;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
//
// Information dialog proc.
//
BOOL CALLBACK
InfoDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
DWORD dw;
switch ( uMsg )
{
case WM_INITDIALOG:
{
TCHAR szText[ SMALL_BUFFER_SIZE ] = { 0 };
DWORD dwLen = 0;
if ( g_Options.fIntel )
{
dw = LoadString( g_hinstance, IDS_INTEL, szText, ARRAYSIZE( szText ) );
Assert( dw );
if ( g_Options.fAlpha )
{
dwLen = lstrlen( szText );
szText[ dwLen++ ] = TEXT(' ');
dw = LoadString( g_hinstance, IDS_AND, &szText[ dwLen ], ARRAYSIZE( szText ) - dwLen );
Assert( dw );
dwLen = lstrlen( szText );
szText[ dwLen++ ] = TEXT(' ');
}
}
if ( g_Options.fAlpha )
{
dw = LoadString( g_hinstance, IDS_ALPHA, &szText[ dwLen ], ARRAYSIZE( szText ) - dwLen );
Assert( dw );
}
SetDlgItemInt( hDlg, IDC_S_CLIENTS, 70, FALSE );
SetDlgItemText( hDlg, IDC_S_SOURCEPATH, g_Options.szSourcePath );
SetDlgItemText( hDlg, IDC_S_PLATFORM, szText );
SetDlgItemText( hDlg, IDC_S_REMOTEBOOT, g_Options.szRemoteBootPath );
}
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZNEXT:
case PSN_WIZBACK:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
if ( g_Options.fError )
{
SetWindowLong( hDlg, DWL_MSGRESULT, -1 ); // do not show this page
}
PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_NEXT | PSWIZB_BACK);
ClearMessageQueue( );
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
enum { STATE_NOTSTARTED, STATE_STARTED, STATE_DONE, STATE_ERROR };
typedef HRESULT (*PFNOPERATION)( HWND hDlg );
typedef struct {
HANDLE hChecked;
HANDLE hError;
HANDLE hArrow;
HANDLE hFontNormal;
HANDLE hFontBold;
int dwWidth;
int dwHeight;
} SETUPDLGDATA, *LPSETUPDLGDATA;
typedef struct {
UINT uState;
UINT rsrcId;
PFNOPERATION pfn;
TCHAR szText[ SMALL_BUFFER_SIZE ];
} LBITEMDATA, *LPLBITEMDATA;
LBITEMDATA items[] = {
{ STATE_NOTSTARTED, IDS_CREATINGDIRECTORYTREE, CreateDirectories, TEXT("") },
{ STATE_NOTSTARTED, IDS_COPYINGFILES, CopyFiles, TEXT("") },
{ STATE_NOTSTARTED, IDS_UPDATINGREGISTRY, ModifyRegistry, TEXT("") },
{ STATE_NOTSTARTED, IDS_STARTING_SERVICES, StartRemoteBootServices, TEXT("") },
{ STATE_NOTSTARTED, IDS_CREATINGSHARES, CreateRemoteBootShare, TEXT("") }
};
//
// Setup dialog proc.
//
BOOL CALLBACK
SetupDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
static BOOL bDoneFirstPass;
LPSETUPDLGDATA psdd = (LPSETUPDLGDATA) GetWindowLong( hDlg, GWL_USERDATA );
DWORD dw;
switch ( uMsg )
{
case WM_INITDIALOG:
{
BITMAP bm;
// grab the bitmaps
psdd =
(LPSETUPDLGDATA) TraceAlloc( GMEM_FIXED, sizeof(SETUPDLGDATA) );
psdd->hChecked = LoadImage( g_hinstance,
MAKEINTRESOURCE( IDB_CHECK ),
IMAGE_BITMAP,
0, 0,
LR_DEFAULTSIZE | LR_LOADTRANSPARENT );
DebugMemoryAddHandle( psdd->hChecked );
GetObject( psdd->hChecked, sizeof(bm), &bm );
psdd->dwWidth = bm.bmWidth;
psdd->hError = LoadImage( g_hinstance,
MAKEINTRESOURCE( IDB_X ),
IMAGE_BITMAP,
0, 0,
LR_DEFAULTSIZE | LR_LOADTRANSPARENT );
DebugMemoryAddHandle( psdd->hError );
GetObject( psdd->hError, sizeof(bm), &bm );
psdd->dwWidth = ( psdd->dwWidth > bm.bmWidth ? psdd->dwWidth : bm.bmWidth );
psdd->hArrow = LoadImage( g_hinstance,
MAKEINTRESOURCE( IDB_ARROW ),
IMAGE_BITMAP,
0, 0,
LR_DEFAULTSIZE | LR_LOADTRANSPARENT );
DebugMemoryAddHandle( psdd->hArrow );
GetObject( psdd->hArrow, sizeof(bm), &bm );
psdd->dwWidth = ( psdd->dwWidth > bm.bmWidth ?
psdd->dwWidth :
bm.bmWidth );
HWND hwnd = GetDlgItem( hDlg, IDC_L_SETUP );
HFONT hFontOld = (HFONT) SendMessage( hwnd, WM_GETFONT, 0, 0);
if(hFontOld != NULL)
{
LOGFONT lf;
if ( GetObject( hFontOld, sizeof(LOGFONT), (LPSTR) &lf ) )
{
dw = LoadString( g_hinstance,
IDS_LARGEFONTNAME,
lf.lfFaceName,
LF_FACESIZE );
Assert( dw );
lf.lfWidth = 0;
lf.lfWeight = 400;
lf.lfHeight -= 4;
psdd->hFontNormal = CreateFontIndirect(&lf);
DebugMemoryAddHandle( psdd->hFontNormal );
lf.lfWeight = 700;
psdd->hFontBold = CreateFontIndirect(&lf);
DebugMemoryAddHandle( psdd->hFontBold );
}
}
HDC hDC = GetDC( NULL );
HANDLE hOldFont = SelectObject( hDC, psdd->hFontBold );
TEXTMETRIC tm;
GetTextMetrics( hDC, &tm );
psdd->dwHeight = tm.tmHeight + 2;
SelectObject( hDC, hOldFont );
ReleaseDC( NULL, hDC );
ListBox_SetItemHeight( hwnd, -1, psdd->dwHeight );
SetWindowLong( hDlg, GWL_USERDATA, (LONG) psdd );
for( int i = 0; i < ARRAYSIZE(items); i++ )
{
dw = LoadString( g_hinstance,
items[ i ].rsrcId,
items[ i ].szText,
ARRAYSIZE( items[ i ].szText ) );
Assert( dw );
ListBox_AddString( hwnd, &items[ i ] );
}
bDoneFirstPass = FALSE;
}
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
case WM_DESTROY:
{
Assert( psdd );
DeleteObject( psdd->hChecked );
DebugMemoryDelete( psdd->hChecked );
DeleteObject( psdd->hError );
DebugMemoryDelete( psdd->hError );
DeleteObject( psdd->hArrow );
DebugMemoryDelete( psdd->hArrow );
DeleteObject( psdd->hFontNormal );
DebugMemoryDelete( psdd->hFontNormal );
DeleteObject( psdd->hFontBold );
DebugMemoryDelete( psdd->hFontBold );
TraceFree( psdd );
SetWindowLong( hDlg, GWL_USERDATA, NULL );
}
break;
case WM_NOTIFY:
{
NMHDR FAR *lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZNEXT:
case PSN_WIZBACK:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_QUERYCANCEL:
return VerifyCancel( hDlg );
break;
case PSN_SETACTIVE:
if ( g_Options.fError )
{
SetWindowLong( hDlg, DWL_MSGRESULT, -1 ); // do not show this page
}
PropSheet_SetWizButtons( GetParent( hDlg ), 0 );
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
ClearMessageQueue( );
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
//AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
}
break;
case WM_STARTSETUP:
{
HWND hwnd = GetDlgItem( hDlg, IDC_L_SETUP );
RECT rc;
GetClientRect( hwnd, &rc );
for( int i = 0; i < ARRAYSIZE( items ) && !g_Options.fError; i++ )
{
items[ i ].uState = STATE_STARTED;
InvalidateRect( hwnd, &rc, TRUE );
items[ i ].uState = items[ i ].pfn( hDlg ) ?
STATE_ERROR : // not S_OK
STATE_DONE; // S_OK
InvalidateRect( hwnd, &rc, TRUE );
}
PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_FINISH );
}
break;
case WM_CTLCOLORLISTBOX:
// cheat by changing the message
return BaseDlgProc( hDlg, WM_CTLCOLORSTATIC, wParam, lParam );
case WM_CTLCOLORSTATIC:
if ( (HWND) lParam != GetDlgItem( hDlg, IDC_S_OPERATION ) &&
(HWND) lParam != GetDlgItem( hDlg, IDC_G_OPERATION ) )
{
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return FALSE;
case WM_MEASUREITEM:
{
LPMEASUREITEMSTRUCT lpmis = (LPMEASUREITEMSTRUCT) lParam;
RECT rc;
HWND hwnd = GetDlgItem( hDlg, IDC_L_SETUP );
GetClientRect( hwnd, &rc );
lpmis->itemWidth = rc.right - rc.left;
lpmis->itemHeight = 15;
}
break;
case WM_DRAWITEM:
{
Assert( psdd );
LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) lParam;
LPLBITEMDATA plbid = (LPLBITEMDATA) lpdis->itemData;
RECT rc = lpdis->rcItem;
HANDLE hOldFont = INVALID_HANDLE_VALUE;
rc.right = rc.bottom = psdd->dwWidth;
switch ( plbid->uState )
{
case STATE_NOTSTARTED:
hOldFont = SelectObject( lpdis->hDC, psdd->hFontNormal );
break;
case STATE_STARTED:
DrawBitmap( psdd->hArrow, lpdis, &rc );
hOldFont = SelectObject( lpdis->hDC, psdd->hFontBold );
break;
case STATE_DONE:
DrawBitmap( psdd->hChecked, lpdis, &rc );
hOldFont = SelectObject( lpdis->hDC, psdd->hFontNormal );
break;
case STATE_ERROR:
DrawBitmap( psdd->hError, lpdis, &rc );
hOldFont = SelectObject( lpdis->hDC, psdd->hFontNormal );
break;
}
rc = lpdis->rcItem;
rc.left += psdd->dwHeight;
DrawText( lpdis->hDC, plbid->szText, -1, &rc, DT_LEFT | DT_VCENTER );
if ( hOldFont != INVALID_HANDLE_VALUE )
{
SelectObject( lpdis->hDC, hOldFont );
}
if ( !bDoneFirstPass && lpdis->itemID == ARRAYSIZE( items ) - 1 )
{
// delay the message until we have painted at least once.
bDoneFirstPass = TRUE;
PostMessage( hDlg, WM_STARTSETUP, 0, 0 );
}
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
//
// Finish dialog proc
//
BOOL CALLBACK
FinishDlgProc(
HWND hDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam )
{
NMHDR FAR *lpnmhdr;
DWORD dw;
switch ( uMsg )
{
case WM_NOTIFY:
lpnmhdr = (NMHDR FAR *) lParam;
switch ( lpnmhdr->code )
{
case PSN_SETACTIVE:
PostMessage( GetParent(hDlg), WMX_FORCEDREPAINT, 0, (LPARAM) GetDlgItem( hDlg, IDC_DIVIDER ) );
PropSheet_SetWizButtons( GetParent( hDlg ), PSWIZB_FINISH );
ClearMessageQueue( );
if ( g_Options.fError )
{
TCHAR szText[ SMALL_BUFFER_SIZE ];
//dw = LoadString( g_hinstance, IDS_ERROR, szText, ARRAYSIZE( szText ) );
//Assert( dw );
//dw = SetWindowText( GetDlgItem( hDlg, IDC_S_FINISH ), szText );
//Assert( dw );
dw = LoadString( g_hinstance, IDS_CLOSE, szText, ARRAYSIZE( szText ) );
Assert( dw );
PropSheet_SetFinishText( GetParent( hDlg ), szText );
}
// fall thru
// ignore these
case PSN_KILLACTIVE:
case PSN_WIZFINISH:
case PSN_RESET:
SetWindowLong( hDlg, DWL_MSGRESULT, FALSE );
break;
case PSN_HELP:
//
// TODO: Add help
//
break;
default:
AssertMsg( FALSE, "Unhandled PSN message" );
return FALSE;
}
break;
default:
return BaseDlgProc( hDlg, uMsg, wParam, lParam );
}
return TRUE;
}
VOID
AdjustWatermarkBitmap(
IN HWND hdlg,
IN HDC hdc
)
{
static BOOL Adjusted = FALSE;
RECT rect;
RECT rect2;
HWND Separator;
PVOID Bits;
HBITMAP hDib;
HBITMAP hOldBitmap;
BITMAPINFO *BitmapInfo;
HDC MemDC;
int i;
BOOL b;
if(Adjusted) {
return;
}
//
// Determine whether the bitmap needs to be stretched.
// If the width is within 10 pixels and the height is within 5
// then we don't worry about stretching.
//
// Note that 0x3026 is the identifier of the bottom divider in
// the template. This is kind of slimy but it works.
//
Separator = GetDlgItem(hdlg,0x3026);
if(!Separator) {
goto c0;
}
GetClientRect(Separator,&rect2);
MapWindowPoints(Separator,hdlg,(LPPOINT)&rect2,2);
GetClientRect(hdlg,&rect);
b = TRUE;
i = rect.right - g_pbihWatermark->biWidth;
if((i < -10) || (i > 10)) {
b = FALSE;
}
i = rect2.top - g_pbihWatermark->biHeight;
if((i < -5) || (i > 5)) {
b = FALSE;
}
if(b) {
goto c0;
}
//
// Create a copy of the existing bitmap's header structure.
// We then modify the width and height and leave everything else alone.
//
BitmapInfo =
(LPBITMAPINFO) TraceAlloc(
GMEM_FIXED,
g_pbihWatermark->biSize +
(g_uWatermarkPaletteColorCount * sizeof(RGBQUAD)) );
if(!BitmapInfo) {
goto c0;
}
CopyMemory(
BitmapInfo,
g_pbihWatermark,
g_pbihWatermark->biSize + (g_uWatermarkPaletteColorCount * sizeof(RGBQUAD))
);
BitmapInfo->bmiHeader.biWidth = rect.right + 1;
BitmapInfo->bmiHeader.biHeight = rect2.top;
hDib = CreateDIBSection(NULL,BitmapInfo,DIB_RGB_COLORS,&Bits,NULL,0);
if(!hDib) {
goto c1;
}
//
// Create a "template" memory DC and select the DIB we created
// into it. Passing NULL to CreateCompatibleDC creates a DC into which
// any format bitmap can be selected. We don't want to use the dialog's
// DC because if the pixel depth of the watermark bitmap differs from
// the screen, we wouldn't be able to select the dib into the mem dc.
//
MemDC = CreateCompatibleDC(NULL);
if(!MemDC) {
goto c2;
}
hOldBitmap = (HBITMAP) SelectObject(MemDC,hDib);
if(!hOldBitmap) {
goto c3;
}
//
// Do the stretch operation from the source bitmap onto
// the dib.
//
SetStretchBltMode(MemDC,COLORONCOLOR);
i = StretchDIBits(
MemDC,
0,0,
rect.right+1,
rect2.top,
0,0,
g_pbihWatermark->biWidth,
g_pbihWatermark->biHeight,
g_pWatermarkBitmapBits,
(BITMAPINFO *)g_pbihWatermark,
DIB_RGB_COLORS,
SRCCOPY
);
if(i == GDI_ERROR) {
goto c4;
}
//
// Got everything we need, set up pointers to use new bitmap data.
//
g_pWatermarkBitmapBits = Bits;
g_pbihWatermark = (BITMAPINFOHEADER *)BitmapInfo;
b = TRUE;
c4:
SelectObject(MemDC,hOldBitmap);
c3:
DeleteDC(MemDC);
c2:
if(!b) {
DeleteObject(hDib);
}
c1:
if(!b) {
TraceFree(BitmapInfo);
}
DebugMemoryDelete(BitmapInfo); // don't track, we'll leak it on purpose.
c0:
Adjusted = TRUE;
return;
}
//
// Subclass WndProc for the wizard window.
//
// We do this so we can draw the watermark background.
//
BOOL
WizardDlgProc(
IN HWND hdlg,
IN UINT msg,
IN WPARAM wParam,
IN LPARAM lParam
)
{
BOOL b;
static int iHeight = 0;
switch(msg) {
case WM_PALETTECHANGED:
//
// If this is our window we need to avoid selecting and realizing
// because doing so would cause an infinite loop between WM_QUERYNEWPALETTE
// and WM_PALETTECHANGED.
//
if((HWND)wParam == hdlg) {
return(FALSE);
}
//
// FALL THROUGH
//
case WM_QUERYNEWPALETTE:
{
HDC hdc;
HPALETTE pal;
hdc = GetDC( hdlg );
pal = SelectPalette( hdc, g_hWatermarkPalette, (msg == WM_PALETTECHANGED) );
RealizePalette( hdc );
InvalidateRect( hdlg, NULL, TRUE );
if( pal )
{
SelectPalette( hdc, pal, TRUE );
}
ReleaseDC( hdlg, hdc );
}
return(TRUE);
case WM_ERASEBKGND:
{
HWND CurrentPage;
AdjustWatermarkBitmap( hdlg, (HDC)wParam);
b = PaintWatermark( hdlg, (HDC)wParam, 0, 0, iHeight );
}
break;
case WMX_FORCEDREPAINT:
{
HWND hwndDivider = (HWND) lParam;
// Find where the divider is on this page
if ( hwndDivider )
{
RECT rcDivider;
GetClientRect( hwndDivider, &rcDivider );
MapWindowPoints( hwndDivider, hdlg, (POINT *)&rcDivider, 2 );
iHeight = rcDivider.top;
}
else
{
iHeight = 0;
}
InvalidateRect( hdlg, NULL, TRUE );
b = TRUE;
}
break;
default:
{
b = CallWindowProc( g_OldWizardProc, hdlg, msg, wParam, lParam );
}
break;
}
return(b);
}