Leaked source code of windows server 2003
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.
 
 
 
 
 
 

2196 lines
62 KiB

//
// maindlg.cpp: main dialog box
// gathers connection info and hosts tabs
//
// Copyright Microsoft Corportation 2000
// (nadima)
//
#include "stdafx.h"
#define TRC_GROUP TRC_GROUP_UI
#define TRC_FILE "maindlg.cpp"
#include <atrcapi.h>
#include "maindlg.h"
#include "discodlg.h"
#include "validatedlg.h"
#include "aboutdlg.h"
#include "sh.h"
#include "commctrl.h"
#include "browsedlg.h"
#include "propgeneral.h"
#include "proplocalres.h"
#include "propdisplay.h"
#include "proprun.h"
#include "propperf.h"
//
// Background color to fill padding area after branding img
//
#define IMAGE_BG_COL RGB(0x29,0x47,0xDA)
// Low color
#define IMAGE_BG_COL_16 RGB(0,0,0xFF)
//
// Controls which need to be moved when dialog
// is resized
//
UINT moveableControls[] = {IDOK,
IDCANCEL,
ID_BUTTON_LOGON_HELP,
ID_BUTTON_OPTIONS};
UINT numMoveableControls = sizeof(moveableControls)/sizeof(UINT);
//
// Controls that are only visible/enabled on less
//
UINT lessUI[] = { UI_IDC_COMPUTER_NAME_STATIC,
IDC_COMBO_SERVERS
};
UINT numLessUI = sizeof(lessUI)/sizeof(UINT);
//
// Controls that are only visibile/enabled on more
//
UINT moreUI[] = {IDC_TABS};
UINT numMoreUI = sizeof(moreUI)/sizeof(UINT);
//
// Controls that need to be disabled/enabled
// during connection
//
UINT connectingDisableControls[] = {IDOK,
ID_BUTTON_LOGON_HELP,
ID_BUTTON_OPTIONS,
IDC_TABS,
IDC_COMBO_SERVERS,
IDC_COMBO_MAIN_OPTIMIZE,
UI_IDC_COMPUTER_NAME_STATIC,
UI_IDC_MAIN_OPTIMIZE_STATIC};
const UINT numConnectingDisableControls = sizeof(connectingDisableControls) /
sizeof(UINT);
BOOL g_fPropPageStringMapInitialized = FALSE;
PERFOPTIMIZESTRINGMAP g_PerfOptimizeStringTable[] =
{
{UI_IDS_OPTIMIZE_28K, TEXT("")},
{UI_IDS_OPTIMIZE_56K, TEXT("")},
{UI_IDS_OPTIMIZE_BROADBAND, TEXT("")},
{UI_IDS_OPTIMIZE_LAN, TEXT("")},
{UI_IDS_OPTIMIZE_MAIN_CUSTOM, TEXT("")},
{UI_IDS_OPTIMIZE_CUSTOM, TEXT("")}
};
#define NUM_PERFSTRINGS sizeof(g_PerfOptimizeStringTable) / \
sizeof(PERFOPTIMIZESTRINGMAP)
CMainDlg* CMainDlg::_pMainDlgInstance = NULL;
//
// UNIWRAP WARNING ~*~*~*~*~*~*~*~*~*~*~*~*~*~~*~*~*~*~*~*~*~*~**~*~*~
// TabControl messages need to be wrapped in the SendMessageThunk
// in uniwrap so the tab control works on 9x with an ANSI comctl32.dll.
//
// If you add anything to the tab control code, make sure it is
// handled by the wrapper.
//
//
CMainDlg::CMainDlg( HWND hwndOwner, HINSTANCE hInst, CSH* pSh,
CContainerWnd* pContainerWnd,
CTscSettings* pTscSettings,
BOOL fStartExpanded,
INT nStartTab) :
CDlgBase( hwndOwner, hInst, UI_IDD_TS_LOGON),
_pSh(pSh),
_pContainerWnd(pContainerWnd),
_pTscSettings(pTscSettings),
_fStartExpanded(fStartExpanded),
_nStartTab(nStartTab)
{
DC_BEGIN_FN("CMainDlg");
TRC_ASSERT((NULL == CMainDlg::_pMainDlgInstance),
(TB,_T("Clobbering existing dlg instance pointer\n")));
TRC_ASSERT((_pSh),
(TB,_T("CMainDlg was passed null _pSh\n")));
TRC_ASSERT(pContainerWnd,
(TB, _T("Null container wnd pointer\n")));
TRC_ASSERT(_pTscSettings,
(TB, _T("NULL _pTscSettings pointer\n")));
CMainDlg::_pMainDlgInstance = this;
_fShowExpanded = FALSE;
_pGeneralPg = NULL;
_pLocalResPg = NULL;
_pPropDisplayPg = NULL;
_pRunPg = NULL;
_pPerfPg = NULL;
_nBrandImageHeight = 0;
_nBrandImageWidth = 0;
_lastValidBpp = 0;
_hBrandPal = NULL;
_hBrandImg = NULL;
_hwndRestoreFocus = NULL;
#ifndef OS_WINCE
_pProgBand = NULL;
#endif
_connectionState = stateNotConnected;
#ifdef OS_WINCE
_fVgaDisplay = (GetSystemMetrics(SM_CYSCREEN) < 480);
//use a small dialog template if we are running in a smaller screen
if (_fVgaDisplay)
{
_dlgResId = UI_IDD_TS_LOGON_VGA;
}
#endif
InitializePerfStrings();
DC_END_FN();
}
CMainDlg::~CMainDlg()
{
CMainDlg::_pMainDlgInstance = NULL;
delete _pGeneralPg;
delete _pLocalResPg;
delete _pPropDisplayPg;
delete _pRunPg;
delete _pPerfPg;
#ifndef OS_WINCE
if (_pProgBand) {
delete _pProgBand;
}
#endif
}
HWND CMainDlg::StartModeless()
{
DC_BEGIN_FN("StartModeless");
#ifdef OS_WINCE
INITCOMMONCONTROLSEX cex;
cex.dwSize = sizeof(INITCOMMONCONTROLSEX);
cex.dwICC = ICC_TAB_CLASSES;
if(!InitCommonControlsEx( &cex ))
{
TRC_ABORT((TB,_T("InitCommonControlsEx failed 0x%x"),
GetLastError()));
}
#endif
_hwndDlg = CreateDialog(_hInstance, MAKEINTRESOURCE(_dlgResId),
_hwndOwner, StaticDialogBoxProc);
TRC_ASSERT(_hwndDlg, (TB,_T("CreateDialog failed")));
DC_END_FN();
return _hwndDlg;
}
INT_PTR CALLBACK CMainDlg::StaticDialogBoxProc (HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
//
// Delegate to appropriate instance (only works for single instance dialogs)
//
DC_BEGIN_FN("StaticDialogBoxProc");
DCINT retVal = 0;
TRC_ASSERT(_pMainDlgInstance, (TB, _T("Logon dialog has NULL static instance ptr\n")));
if(_pMainDlgInstance)
{
retVal = _pMainDlgInstance->DialogBoxProc( hwndDlg, uMsg, wParam, lParam);
}
DC_END_FN();
return retVal;
}
//
// Name: DialogBoxProc
//
// Purpose: Handles Main dialog
//
// Returns: TRUE if message dealt with
// FALSE otherwise
//
// Params: See window documentation
//
//
INT_PTR CALLBACK CMainDlg::DialogBoxProc (HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
INT_PTR rc = FALSE;
#ifndef OS_WINCE
DCUINT intRC ;
#endif
DC_BEGIN_FN("DialogBoxProc");
switch (uMsg)
{
case WM_INITDIALOG:
{
_hwndDlg = hwndDlg;
SetDialogAppIcon(hwndDlg);
if(!_pSh || !_pContainerWnd)
{
return FALSE;
}
CenterWindow(NULL, 2, 4);
SetForegroundWindow(hwndDlg);
//turn off maximize box
LONG style = GetWindowLong(hwndDlg, GWL_STYLE);
style &= ~(WS_MAXIMIZEBOX);
SetWindowLong( hwndDlg, GWL_STYLE, style);
//
// Bind this dialog to the container window
// there is logic where these two windows need to interact
// e.g during a connect:
// if error occurs the error dialog is brought up modal wrt
// to the connect dialog
// also when connect completes it is the container window
// that dismisses this dialog
//
_pContainerWnd->SetConnectDialogHandle( hwndDlg);
_lastValidBpp = CSH::SH_GetScreenBpp();
#ifndef OS_WINCE
if(!InitializeBmps())
{
TRC_ERR((TB,_T("InitializeBmps failed")));
}
_pProgBand = new CProgressBand(hwndDlg,
_hInstance,
_nBrandImageHeight,
UI_IDB_PROGRESS_BAND8,
UI_IDB_PROGRESS_BAND4,
_hBrandPal);
if (_pProgBand) {
if (!_pProgBand->Initialize()) {
TRC_ERR((TB,_T("Progress band failed to init")));
delete _pProgBand;
_pProgBand = NULL;
}
}
SetupDialogSysMenu();
#endif //OS_WINCE
//
// Setup the server combo box
//
HWND hwndSrvCombo = GetDlgItem(hwndDlg, IDC_COMBO_SERVERS);
CSH::InitServerAutoCmplCombo( _pTscSettings, hwndSrvCombo);
SetWindowText(
hwndSrvCombo,
_pTscSettings->GetFlatConnectString()
);
SetFocus(GetDlgItem(hwndDlg, IDC_COMBO_SERVERS));
SetForegroundWindow(hwndDlg);
//
// Load the button text for the Options button
//
if (!LoadString( _hInstance,
UI_IDS_OPTIONS_MORE,
_szOptionsMore,
OPTIONS_STRING_MAX_LEN ))
{
// Some problem with the resources.
TRC_SYSTEM_ERROR("LoadString");
TRC_ERR((TB, _T("Failed to load string ID:%u"),
UI_IDS_OPTIONS_MORE));
//
// splat something in to keep running
//
DC_TSTRCPY(_szOptionsMore, TEXT(""));
}
if (!LoadString( _hInstance,
UI_IDS_CLOSE_TEXT,
_szCloseText,
SIZECHAR(_szCloseText)))
{
// Some problem with the resources.
TRC_ERR((TB, _T("Failed to load string ID:%u : err:%d"),
UI_IDS_CLOSE_TEXT, GetLastError()));
DC_TSTRCPY(_szCloseText, TEXT(""));
}
if (!LoadString( _hInstance,
UI_IDS_CANCEL_TEXT,
_szCancelText,
SIZECHAR(_szCancelText)))
{
// Some problem with the resources.
TRC_ERR((TB, _T("Failed to load string ID:%u : err:%d"),
UI_IDS_CANCEL_TEXT, GetLastError()));
DC_TSTRCPY(_szCancelText, TEXT(""));
}
if (!LoadString( _hInstance,
UI_IDS_OPTIONS_LESS,
_szOptionsLess,
OPTIONS_STRING_MAX_LEN ))
{
// Some problem with the resources.
TRC_SYSTEM_ERROR("LoadString");
TRC_ERR((TB, _T("Failed to load string ID:%u"),
UI_IDS_OPTIONS_LESS));
//
// splat something in to keep running
//
DC_TSTRCPY(_szOptionsLess, TEXT(""));
}
SetWindowText(GetDlgItem(_hwndDlg,ID_BUTTON_OPTIONS),
_fShowExpanded ? _szOptionsLess : _szOptionsMore);
//
// Make sure the 'more' UI is disabled
//
EnableControls(moreUI, numMoreUI, FALSE);
InitTabs();
if(_fStartExpanded)
{
//go expanded
ToggleExpandedState();
int foo = TabCtrl_SetCurSel(GetDlgItem(hwndDlg, IDC_TABS),
_nStartTab);
//SetCurSel does not send a TCN_SELCHANGE
OnTabSelChange();
}
#ifdef OS_WINCE
if ((GetFileAttributes(PEGHELP_EXE) == -1)||
(GetFileAttributes(TSC_HELP_FILE) == -1))
{
LONG lRetVal = 0;
lRetVal = GetWindowLong(_hwndDlg,
GWL_STYLE);
SetWindowLong(_hwndDlg,
GWL_EXSTYLE,
WS_EX_WINDOWEDGE);
if (lRetVal != 0)
{
SetWindowLong(_hwndDlg,
GWL_STYLE,
lRetVal);
}
rc = SetWindowPos(_hwndDlg,NULL,0,0,0,0,
SWP_NOACTIVATE|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
}
#endif
rc = TRUE;
}
break;
#ifdef OS_WINCE
case WM_CLOSE:
{
if(stateConnecting == _connectionState)
{
//Cancel the connection
TRC_NRM((TB, _T("User cancel connect from maindlg")));
_pContainerWnd->Disconnect();
}
else
{
DlgToSettings();
EndDialog(hwndDlg, IDCANCEL);
PostMessage(_pContainerWnd->GetWndHandle(), WM_CLOSE, 0, 0);
}
}
break;
#endif
case UI_SHOW_DISC_ERR_DLG:
{
//
// If this assert fired something went wrong in the states
// because we should have left the connecting state as the
// first step of receiving an OnDisconnected notification
// with WM_TSC_DISCONNECTED.
//
TRC_ASSERT(_connectionState != stateConnecting,
(TB,_T("In connecting state when received Err Dlg popup")));
SetConnectionState( stateNotConnected );
CDisconnectedDlg disconDlg(hwndDlg, _hInstance, _pContainerWnd);
disconDlg.SetDisconnectReason( wParam);
disconDlg.SetExtendedDiscReason(
(ExtendedDisconnectReasonCode) lParam );
disconDlg.DoModal();
}
break;
case WM_TSC_DISCONNECTED: //intentional fallthru
case WM_TSC_CONNECTED:
{
//
// Either we connected or got disconnected
// while connecting. In either case the connection
// has ended so leave the connecting state.
//
if (stateNotConnected != _connectionState)
{
//
// Only end connecting if we're not already disconnected
//
OnEndConnection((WM_TSC_CONNECTED == uMsg));
}
}
break;
//
// On return to connection UI
// (e.g after a disconnection)
//
case WM_TSC_RETURNTOCONUI:
{
//
// Reset the server combo to force it to repaint
// this is a minor hack to fix the ComboBoxEx
// which doesn't want to repaint itself on return
// to the dialog.
//
HWND hwndSrvCombo = GetDlgItem(hwndDlg, IDC_COMBO_SERVERS);
SetWindowText( hwndSrvCombo,
_pTscSettings->GetFlatConnectString());
//
// Notify the active property page
//
if(_fShowExpanded && _tabDlgInfo.hwndCurPropPage)
{
SendMessage(_tabDlgInfo.hwndCurPropPage,
WM_TSC_RETURNTOCONUI,
0,
0);
}
//
// Give the default button style back to the connect
// button and remove it from the cancel button.
// While connecting we disable the connect (IDOK) button
// so it is possible that the style goes to the Close/Cancel
// button which confuses the user since the IDOK handler
// is always for the connect button
//
SendDlgItemMessage(hwndDlg, IDCANCEL, BM_SETSTYLE,
BS_PUSHBUTTON, MAKELPARAM(TRUE,0));
SendDlgItemMessage(hwndDlg, IDOK, BM_SETSTYLE,
BS_DEFPUSHBUTTON, MAKELPARAM(TRUE,0));
}
break;
#ifndef OS_WINCE
case WM_ERASEBKGND:
{
HDC hDC = (HDC)wParam;
HPALETTE oldPalette = NULL;
if (_hBrandPal) {
oldPalette = SelectPalette(hDC, _hBrandPal, FALSE);
RealizePalette(hDC);
}
rc = PaintBrandImage(hwndDlg,
(HDC)wParam,
COLOR_BTNFACE );
if (_pProgBand) {
_pProgBand->OnEraseParentBackground((HDC)wParam);
}
if ( oldPalette ) {
SelectPalette(hDC, oldPalette, TRUE);
}
}
break;
case WM_TIMER:
{
if (_pProgBand) {
_pProgBand->OnTimer((INT)wParam);
}
}
break;
#endif // OS_WINCE
case WM_COMMAND:
{
switch(DC_GET_WM_COMMAND_ID(wParam))
{
case IDOK:
{
//
// Update dialog with properties from active prop page
//
if(_fShowExpanded && _tabDlgInfo.hwndCurPropPage)
{
SendMessage(_tabDlgInfo.hwndCurPropPage,
WM_SAVEPROPSHEET, 0, 0);
}
if(!_fShowExpanded)
{
//We're on the minimal tab
//copy dlg settings tscSettings
DlgToSettings();
}
TCHAR szServer[TSC_MAX_ADDRESS_LENGTH];
_tcsncpy(szServer, _pTscSettings->GetFlatConnectString(),
SIZECHAR(szServer));
_pSh->SH_CanonicalizeServerName(szServer);
BOOL bValidate =
CRdpConnectionString::ValidateServerPart(szServer);
if(!bValidate)
{
//
// context sensitive help in validatedlg
// needs in handle to main window
//
CValidateDlg validateDlg(hwndDlg, _hInstance,
_pContainerWnd->GetWndHandle(),
_pSh);
validateDlg.DoModal();
//
// Clear and set the focus on the server edit well
//
HWND hwndSrvItem = NULL;
if(_fShowExpanded)
{
hwndSrvItem = GetDlgItem(_tabDlgInfo.hwndCurPropPage,
IDC_GENERAL_COMBO_SERVERS);
}
else
{
hwndSrvItem = GetDlgItem(hwndDlg, IDC_COMBO_SERVERS);
}
if(hwndSrvItem)
{
SetWindowText(hwndSrvItem, _T(""));
TRC_DBG((TB, _T("Set focus to edit box")));
SetFocus(hwndSrvItem);
}
break;
}
else
{
//
// It's all good
//
_pTscSettings->SetConnectString(szServer);
//
// We have to kick off the connection
// while the dialog is still active
// in case it fails, we want the error message
// to be parented off the connection dialog.
//
// Code in the parent window will dismiss this
// dialog when the connection (which is asynchronous)
// completes.
//
OnStartConnection();
if(!_pContainerWnd->StartConnection())
{
TRC_ERR((TB,_T("StartConnection failed")));
//Async connection start failed so end
OnEndConnection(FALSE);
break;
}
}
}
break;
case IDCANCEL:
{
if(stateConnecting == _connectionState)
{
//Cancel the connection
TRC_NRM((TB, _T("User cancel connect from maindlg")));
_pContainerWnd->Disconnect();
}
else
{
DlgToSettings();
EndDialog(hwndDlg, IDCANCEL);
PostMessage(_pContainerWnd->GetWndHandle(), WM_CLOSE, 0, 0);
}
}
break;
case ID_BUTTON_LOGON_HELP:
{
TRC_NRM((TB, _T("Display the appropriate help page")));
if(_pContainerWnd->GetWndHandle())
{
#ifndef OS_WINCE
_pSh->SH_DisplayClientHelp(
_pContainerWnd->GetWndHandle(),
HH_DISPLAY_TOPIC);
#endif // OS_WINCE
}
}
break;
case ID_BUTTON_OPTIONS:
{
//
// Need to do the switch to/from the expanded dialog
//
ToggleExpandedState();
}
break;
case IDC_NEXTTAB:
case IDC_PREVTAB:
{
//
// Only allow toggle of UI tabs while not connected
// since in the connecting state the UI elements other
// than the cancel button are meant to be disabled
//
if(_fShowExpanded && (_connectionState == stateNotConnected))
{
int iSel = TabCtrl_GetCurSel( GetDlgItem( _hwndDlg, IDC_TABS));
iSel += (DC_GET_WM_COMMAND_ID(wParam) == IDC_NEXTTAB) ? 1 : -1;
if(iSel >= NUM_TABS)
{
iSel = 0;
}
else if(iSel < 0)
{
iSel = NUM_TABS - 1;
}
TabCtrl_SetCurSel( GetDlgItem( _hwndDlg, IDC_TABS), iSel);
//SetCurSel does not send a TCN_SELCHANGE
OnTabSelChange();
}
}
break;
case IDC_COMBO_SERVERS:
{
//
// Bring up the brwse for servers dlg
// if the user chose the last item in the combo
//
if(HIWORD(wParam) == CBN_SELCHANGE)
{
CSH::HandleServerComboChange(
(HWND)lParam,
hwndDlg,
_hInstance,
(LPTSTR)_pTscSettings->GetFlatConnectString()
);
}
}
break;
}
}
break; //WM_COMMAND
//
// tab notification
//
case WM_NOTIFY:
{
LPNMHDR pnmh = (LPNMHDR) lParam;
if(pnmh)
{
switch( pnmh->code)
{
case TCN_SELCHANGE:
{
OnTabSelChange();
}
break;
}
}
}
break;
case WM_SYSCOMMAND:
{
if(UI_IDM_ABOUT == DC_GET_WM_COMMAND_ID(wParam))
{
// Show the about box dialog
CAboutDlg aboutDialog( hwndDlg, _hInstance,
_pSh->GetCipherStrength(),
_pSh->GetControlVersionString());
aboutDialog.DoModal();
}
}
break;
case WM_UPDATEFROMSETTINGS:
{
SettingsToDlg();
//
// Update the server MRU list
//
HWND hwndSrvCombo = GetDlgItem(hwndDlg, IDC_COMBO_SERVERS);
CSH::InitServerAutoCmplCombo( _pTscSettings, hwndSrvCombo);
SetWindowText(
hwndSrvCombo,
_pTscSettings->GetFlatConnectString()
);
if(_fShowExpanded && _tabDlgInfo.hwndCurPropPage)
{
SendMessage(_tabDlgInfo.hwndCurPropPage, WM_INITDIALOG, 0, 0);
}
}
break;
case WM_SETTINGCHANGE: //fall thru
case WM_SYSCOLORCHANGE: //fall thru
#ifndef OS_WINCE
case WM_DISPLAYCHANGE: //fall thru
#endif
{
UINT screenBpp = CSH::SH_GetScreenBpp();
if(_lastValidBpp != screenBpp)
{
//Screen color depth changed
TRC_NRM((TB,_T("Detected color depth change from:%d to %d"),
_lastValidBpp, screenBpp));
#ifndef OS_WINCE
//
// Reload the bitmaps
//
TRC_NRM((TB,_T("Reloading images")));
if (_pProgBand) {
if (!_pProgBand->ReLoadBmps()) {
TRC_ERR((TB,_T("ReLoadBitmaps failed")));
}
}
if(InitializeBmps()) {
//trigger a repaint
InvalidateRect( _hwndDlg, NULL, TRUE);
}
else {
TRC_ERR((TB,_T("InitializeBmps failed")));
}
#endif
}
PropagateMsgToChildren(hwndDlg, uMsg, wParam, lParam);
}
break;
#ifndef OS_WINCE
case WM_QUERYNEWPALETTE:
{
rc = BrandingQueryNewPalette(hwndDlg);
InvalidateRect(hwndDlg, NULL, TRUE);
UpdateWindow(hwndDlg);
}
break;
case WM_PALETTECHANGED:
{
rc = BrandingPaletteChanged(hwndDlg, (HWND)wParam);
InvalidateRect(hwndDlg, NULL, TRUE);
UpdateWindow(hwndDlg);
}
break;
#endif
case WM_HELP:
{
_pSh->SH_DisplayClientHelp(
hwndDlg,
HH_DISPLAY_TOPIC);
}
break;
case WM_DESTROY:
{
if (_hBrandPal)
{
DeleteObject(_hBrandPal);
_hBrandPal = NULL;
}
if (_hBrandImg)
{
DeleteObject(_hBrandImg);
_hBrandImg = NULL;
}
}
break;
default:
{
rc = CDlgBase::DialogBoxProc(hwndDlg,
uMsg,
wParam,
lParam);
}
break;
}
DC_END_FN();
return(rc);
} /* UILogonDialogBox */
//
// save from UI->tscSettings
//
void CMainDlg::DlgToSettings()
{
TCHAR szServer[SH_MAX_ADDRESS_LENGTH];
int optLevel = 0;
DC_BEGIN_FN("DlgToSettings");
TRC_ASSERT(_pTscSettings, (TB,_T("_pTscSettings is null")));
TRC_ASSERT(_hwndDlg, (TB,_T("_hwndDlg is null")));
//
// Get the server
//
GetDlgItemText( _hwndDlg, IDC_COMBO_SERVERS,
szServer, SIZECHAR(szServer));
_pTscSettings->SetConnectString(szServer);
DC_END_FN();
}
//
// save from UI->tscSettings
//
void CMainDlg::SettingsToDlg()
{
DC_BEGIN_FN("SettingsToDlg");
TRC_ASSERT(_pTscSettings, (TB,_T("_pTscSettings is null")));
TRC_ASSERT(_hwndDlg, (TB,_T("_hwndDlg is null")));
SetDlgItemText(_hwndDlg, IDC_COMBO_SERVERS,
(LPCTSTR) _pTscSettings->GetFlatConnectString());
DC_END_FN();
}
//
// Toggles the expanded state of the dialog
//
void CMainDlg::ToggleExpandedState()
{
DC_BEGIN_FN("ToggleExpandedState");
WINDOWPLACEMENT wndPlc;
wndPlc.length = sizeof(WINDOWPLACEMENT);
_fShowExpanded = !_fShowExpanded;
#ifndef OS_WINCE
//
// Expand/contract the dlg height
//
GetWindowPlacement( _hwndDlg, &wndPlc);
int cx = wndPlc.rcNormalPosition.right - wndPlc.rcNormalPosition.left;
int cy = wndPlc.rcNormalPosition.bottom - wndPlc.rcNormalPosition.top;
#else
RECT wndRect;
GetWindowRect(_hwndDlg, &wndRect);
int cx = wndRect.right - wndRect.left;
int cy = wndRect.bottom - wndRect.top;
#endif
#ifndef OS_WINCE
int dlgExpDlu = LOGON_DLG_EXPAND_AMOUNT;
#else
int dlgExpDlu = (_fVgaDisplay) ? LOGON_DLG_EXPAND_AMOUNT_VGA : LOGON_DLG_EXPAND_AMOUNT;
#endif
RECT rc;
rc.left = 0;
rc.right = 100; //don't care about horiz, dummy vals
rc.top = 0;
rc.bottom = dlgExpDlu;
if(!MapDialogRect(_hwndDlg, &rc))
{
TRC_ASSERT(NULL,(TB,_T("MapDialogRect failed")));
}
int dlgExpandAmountPels = rc.bottom - rc.top;
//
// Compute the dialog vertical expand amount in pixels
// given a dlu based expand size
//
cy += _fShowExpanded ? dlgExpandAmountPels : -dlgExpandAmountPels;
SetWindowPos( _hwndDlg, NULL, 0, 0, cx, cy,
SWP_NOMOVE | SWP_NOZORDER);
//
// Reposition the controls that need to be moved
//
RepositionControls( 0, _fShowExpanded ? dlgExpandAmountPels :
-dlgExpandAmountPels,
moveableControls, numMoveableControls);
if(_fShowExpanded)
{
//we're going expanded save to settings so more
//tab can initiliaze from most recent values.
//must happen before tab sel change (prop pg init)
DlgToSettings();
}
//
// Kill/activate prop page on tab dlg
//
OnTabSelChange();
if(!_fShowExpanded)
{
//going to less mode, init dialog with settings
SettingsToDlg();
}
//
// Options button text
//
SetWindowText(GetDlgItem(_hwndDlg,ID_BUTTON_OPTIONS),
_fShowExpanded ? _szOptionsLess : _szOptionsMore);
//
// Disable+Hide uneeded UI for this mode
//
EnableControls(lessUI, numLessUI, !_fShowExpanded);
EnableControls(moreUI, numMoreUI, _fShowExpanded);
SetFocus(GetDlgItem(_hwndDlg,ID_BUTTON_OPTIONS));
DC_END_FN();
}
//
// Initialize the tabs on the main dialog
//
BOOL CMainDlg::InitTabs()
{
TCITEM tie;
#ifndef OS_WINCE
INITCOMMONCONTROLSEX cex;
RECT rcTabDims;
#endif
POINT tabDims;
int ret = -1;
DC_BEGIN_FN("InitTabs");
if(!_hwndDlg)
{
return FALSE;
}
HWND hwndTab = GetDlgItem( _hwndDlg, IDC_TABS);
if(!hwndTab)
{
return FALSE;
}
#ifndef OS_WINCE
cex.dwSize = sizeof(INITCOMMONCONTROLSEX);
cex.dwICC = ICC_TAB_CLASSES;
if(!InitCommonControlsEx( &cex ))
{
TRC_ABORT((TB,_T("InitCommonControlsEx failed 0x%x"),
GetLastError()));
}
#endif
_pGeneralPg = new CPropGeneral(_hInstance, _pTscSettings, _pSh);
if(!_pGeneralPg)
{
return FALSE;
}
_pLocalResPg = new CPropLocalRes(_hInstance, _pTscSettings, _pSh);
if(!_pLocalResPg)
{
return FALSE;
}
_pPropDisplayPg = new CPropDisplay(_hInstance, _pTscSettings, _pSh);
if(!_pPropDisplayPg)
{
return FALSE;
}
_pRunPg = new CPropRun(_hInstance, _pTscSettings, _pSh);
if(!_pRunPg)
{
return FALSE;
}
_pPerfPg = new CPropPerf(_hInstance, _pTscSettings, _pSh);
if(!_pPerfPg)
{
return FALSE;
}
tie.mask = TCIF_TEXT | TCIF_IMAGE;
tie.iImage = -1;
TCHAR szTabName[MAX_PATH];
//general tab
if (!LoadString( _hInstance,
UI_IDS_GENERAL_TAB_NAME,
szTabName,
SIZECHAR(szTabName) ))
{
return FALSE;
}
tie.pszText = szTabName;
ret = TabCtrl_InsertItem( hwndTab, 0, &tie);
TRC_ASSERT(ret != -1,
(TB,_T("TabCtrl_InsertItem failed %d"),
GetLastError()));
//display tab
if (!LoadString( _hInstance,
UI_IDS_DISPLAY_TAB_NAME,
szTabName,
SIZECHAR(szTabName)))
{
return FALSE;
}
tie.pszText = szTabName;
ret = TabCtrl_InsertItem( hwndTab, 1, &tie);
TRC_ASSERT(ret != -1,
(TB,_T("TabCtrl_InsertItem failed %d"),
GetLastError()));
//local resources tab
if (!LoadString( _hInstance,
UI_IDS_LOCAL_RESOURCES_TAB_NAME,
szTabName,
SIZECHAR(szTabName)))
{
return FALSE;
}
tie.pszText = szTabName;
ret = TabCtrl_InsertItem( hwndTab, 2, &tie);
TRC_ASSERT(ret != -1,
(TB,_T("TabCtrl_InsertItem failed %d"),
GetLastError()));
//run tab
if (!LoadString( _hInstance,
UI_IDS_RUN_TAB_NAME,
szTabName,
SIZECHAR(szTabName)))
{
return FALSE;
}
tie.pszText = szTabName;
ret = TabCtrl_InsertItem( hwndTab, 3, &tie);
TRC_ASSERT(ret != -1,
(TB,_T("TabCtrl_InsertItem failed %d"),
GetLastError()));
//advanced tab
if (!LoadString( _hInstance,
UI_IDS_PERF_TAB_NAME,
szTabName,
SIZECHAR(szTabName)))
{
return FALSE;
}
tie.pszText = szTabName;
ret = TabCtrl_InsertItem( hwndTab, 4, &tie);
TRC_ASSERT(ret != -1,
(TB,_T("TabCtrl_InsertItem failed %d"),
GetLastError()));
//
// Determine bounding rect for child dialogs
//
#ifndef OS_WINCE
RECT winRect;
#endif
GetWindowRect( hwndTab ,&_rcTab);
TabCtrl_AdjustRect( hwndTab, FALSE, &_rcTab);
MapWindowPoints( NULL, _hwndDlg, (LPPOINT)&_rcTab, 2);
tabDims.x = _rcTab.right - _rcTab.left;
tabDims.y = _rcTab.bottom - _rcTab.top;
_tabDlgInfo.pdlgTmpl[0] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_GENERAL));
_tabDlgInfo.pDlgProc[0] = CPropGeneral::StaticPropPgGeneralDialogProc;
_tabDlgInfo.pdlgTmpl[1] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_DISPLAY));
_tabDlgInfo.pDlgProc[1] = CPropDisplay::StaticPropPgDisplayDialogProc;
_tabDlgInfo.pdlgTmpl[2] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_LOCALRESOURCES));
_tabDlgInfo.pDlgProc[2] = CPropLocalRes::StaticPropPgLocalResDialogProc;
_tabDlgInfo.pdlgTmpl[3] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_RUN));
_tabDlgInfo.pDlgProc[3] = CPropRun::StaticPropPgRunDialogProc;
_tabDlgInfo.pdlgTmpl[4] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_PERF));
_tabDlgInfo.pDlgProc[4] = CPropPerf::StaticPropPgPerfDialogProc;
#ifdef OS_WINCE
if (_fVgaDisplay)
{
_tabDlgInfo.pdlgTmpl[0] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_GENERAL_VGA));
_tabDlgInfo.pdlgTmpl[1] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_DISPLAY_VGA));
_tabDlgInfo.pdlgTmpl[2] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_LOCALRESOURCES_VGA));
_tabDlgInfo.pdlgTmpl[3] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_RUN_VGA));
_tabDlgInfo.pdlgTmpl[4] = DoLockDlgRes(MAKEINTRESOURCE(UI_IDD_PROPPAGE_PERF_VGA));
}
#endif
_tabDlgInfo.hwndCurPropPage = NULL;
_pGeneralPg->SetTabDisplayArea(_rcTab);
_pPropDisplayPg->SetTabDisplayArea(_rcTab);
_pLocalResPg->SetTabDisplayArea(_rcTab);
_pRunPg->SetTabDisplayArea(_rcTab);
_pPerfPg->SetTabDisplayArea(_rcTab);
//
// Trigger first tab selection
//
OnTabSelChange();
DC_END_FN();
return TRUE;
}
//
// Tab selection has changed
//
BOOL CMainDlg::OnTabSelChange()
{
DC_BEGIN_FN("OnTabSelChange");
int iSel = TabCtrl_GetCurSel( GetDlgItem( _hwndDlg, IDC_TABS));
//
// Destroy current child dialog if any
//
TRC_ASSERT( iSel >=0 && iSel < NUM_TABS,
(TB,_T("Tab selection out of range %d"), iSel));
if(iSel < 0 || iSel > NUM_TABS)
{
return FALSE;
}
if(_tabDlgInfo.hwndCurPropPage)
{
DestroyWindow(_tabDlgInfo.hwndCurPropPage);
}
//
// Only bring in a new tab if we are in expanded mode
//
if(_fShowExpanded)
{
_tabDlgInfo.hwndCurPropPage =
CreateDialogIndirect( _hInstance, _tabDlgInfo.pdlgTmpl[iSel],
_hwndDlg, _tabDlgInfo.pDlgProc[iSel]);
ShowWindow(_tabDlgInfo.hwndCurPropPage, SW_SHOW);
#ifdef OS_WINCE
SetFocus (GetDlgItem (_hwndDlg, IDOK));
#endif
}
DC_END_FN();
return TRUE;
}
#ifndef OS_WINCE
//
// Add an 'About' entry to the dialog's system menu
//
void CMainDlg::SetupDialogSysMenu()
{
DC_BEGIN_FN("SetupDialogSysMenu");
HANDLE hSystemMenu = GetSystemMenu(_hwndDlg, FALSE);
DCTCHAR menuStr[SH_SHORT_STRING_MAX_LENGTH];
if(hSystemMenu)
{
//
// Disable sizing and maximizing
//
EnableMenuItem((HMENU)hSystemMenu, SC_MAXIMIZE,
MF_GRAYED | MF_BYCOMMAND);
EnableMenuItem((HMENU)hSystemMenu, SC_SIZE,
MF_GRAYED | MF_BYCOMMAND);
//load the string for the about help sub menu
if (LoadString(_hInstance,
UI_MENU_ABOUT,
menuStr,
SH_SHORT_STRING_MAX_LENGTH) != 0)
{
AppendMenu((HMENU)hSystemMenu, MF_UNCHECKED|MF_STRING, UI_IDM_ABOUT,
menuStr);
}
else
{
//failed to load the sub menu string
TRC_ERR((TB, _T("Failed to load About Help Sub Menu string ID:%u"),
UI_MENU_ABOUT));
}
}
DC_END_FN();
}
#endif // OS_WINCE
//
// Load the image returning the given HBITMAP, having done this we can
// then get the size from it.
//
// In:
// hInstance,resid - object to be loaded.
// pSize - filled with size information about the object
//
// Out:
// HBITMAP - NULL if nothing loaded
//
HBITMAP CMainDlg::LoadBitmapGetSize(HINSTANCE hInstance,UINT resid,SIZE* pSize)
{
HBITMAP hResult = NULL;
DIBSECTION ds = {0};
//
// Load the image from the resource then lets get the DIBSECTION header
// from the bitmap object we can then read the size from it and
// return that to the caller.
//
#ifndef OS_WINCE
hResult = (HBITMAP)LoadImage(hInstance, MAKEINTRESOURCE(resid),
IMAGE_BITMAP, 0, 0, LR_CREATEDIBSECTION);
#else
hResult = (HBITMAP)LoadImage(hInstance, MAKEINTRESOURCE(resid),
IMAGE_BITMAP, 0, 0, 0);
#endif
if ( hResult )
{
GetObject(hResult, sizeof(ds), &ds);
pSize->cx = ds.dsBmih.biWidth;
pSize->cy = ds.dsBmih.biHeight;
//
// pSize->cy -ve then make +ve, -ve indicates bits are vertically
// flipped (bottom left, top left).
//
if ( pSize->cy < 0 )
pSize->cy -= 0;
}
return hResult;
}
#ifndef OS_WINCE
BOOL CMainDlg::PaintBrandImage(HWND hwnd,
HDC hDC,
INT bgColor)
{
DC_BEGIN_FN("PaintBrandImage");
HBRUSH hBrushBlue;
HDC hdcBitmap;
HBITMAP oldBitmap;
RECT rc = { 0 };
INT cxRect, cxBand;
HBITMAP* phbmBrand;
hdcBitmap = CreateCompatibleDC(hDC);
if (!hdcBitmap)
{
return FALSE;
}
GetClientRect(hwnd, &rc);
HBRUSH hbrBg;
//Repaint the rest of the background
//First the portion under the band
rc.top = _nBrandImageHeight;
if (_pProgBand) {
rc.top += _pProgBand->GetBandHeight();
}
FillRect(hDC, &rc, (HBRUSH)IntToPtr(1+bgColor));
//
// Now paint the brand image
//
if (_hBrandImg)
{
SelectObject(hdcBitmap, _hBrandImg);
BitBlt(hDC, 0, 0, _nBrandImageWidth,
_nBrandImageHeight, hdcBitmap,
0,0,SRCCOPY);
}
DeleteDC(hdcBitmap);
DC_END_FN();
return TRUE;
}
#endif
BOOL CMainDlg::OnStartConnection()
{
DC_BEGIN_FN("OnStartConnection");
TRC_ASSERT(stateNotConnected == _connectionState,
(TB,_T("Start connecting while already connecting. State %d"),
_connectionState));
SetConnectionState( stateConnecting );
#ifndef OS_WINCE
//Kick off the progress band animation timer
if (_pProgBand) {
_pProgBand->StartSpinning();
}
#endif
//
// Change the cancel dialog button text to "Cancel"
// to abort the connection
//
SetDlgItemText( _hwndDlg, IDCANCEL, _szCancelText);
_hwndRestoreFocus = SetFocus(GetDlgItem( _hwndDlg, IDCANCEL));
CSH::EnableControls( _hwndDlg,
connectingDisableControls,
numConnectingDisableControls,
FALSE );
//
// Inform the current property page
// to disable all it's controls
//
if(_fShowExpanded && _tabDlgInfo.hwndCurPropPage)
{
SendMessage(_tabDlgInfo.hwndCurPropPage,
WM_TSC_ENABLECONTROLS,
FALSE, //disable controls
0);
}
DC_END_FN();
return TRUE;
}
//
// Event that fires when the process of connecting ends
// fConnected - flag that is TRUE if we are now connected
// FALSE if we are now disconnected (e.g if
// if the connection failed.
//
BOOL CMainDlg::OnEndConnection(BOOL fConnected)
{
DC_BEGIN_FN("OnEndConnection");
//
// If we're already disconnected then do nothing
// e.g EndConnecting can be called once to indicate
// successful connection and then again on disconnection
//
if( stateNotConnected != _connectionState)
{
if (fConnected)
{
SetConnectionState( stateConnected );
}
else
{
SetConnectionState( stateNotConnected );
}
#ifndef OS_WINCE
//
// End the animation
//
if (_pProgBand) {
_pProgBand->StopSpinning();
}
#endif
//
// Change the cancel dialog button text to "Close"
// because we have connected at least once
//
SetDlgItemText( _hwndDlg, IDCANCEL, _szCloseText);
#ifndef OS_WINCE
// Reset band offset
if (_pProgBand) {
_pProgBand->ResetBandOffset();
}
#endif
CSH::EnableControls( _hwndDlg,
connectingDisableControls,
numConnectingDisableControls,
TRUE );
//
// Inform the current property page
// to renable all controls it needs enabled
//
if(_fShowExpanded && _tabDlgInfo.hwndCurPropPage)
{
SendMessage(_tabDlgInfo.hwndCurPropPage,
WM_TSC_ENABLECONTROLS,
TRUE, //enable controls
0);
}
//
// Make sure to correctly disable or enable
// less UI items to prevent mnemomincs (e.g ALT-C)
// leaking thru to the non-expanded dialog
//
CSH::EnableControls(_hwndDlg, lessUI, numLessUI,
!_fShowExpanded);
//
// Trigger a repaint to reposition the bar
//
InvalidateRect( _hwndDlg, NULL, TRUE);
//
// If we just went disconnected (fConnected is false)
// then restore the focus to the control that
// had it before the connection
//
if (!fConnected && _hwndRestoreFocus)
{
SetFocus(_hwndRestoreFocus);
}
}
DC_END_FN();
return TRUE;
}
VOID CMainDlg::SetConnectionState(mainDlgConnectionState newState)
{
DC_BEGIN_FN("SetConnectionState");
TRC_NRM((TB,_T("Prev state = %d. New State = %d"),
_connectionState, newState ));
_connectionState = newState;
DC_END_FN();
}
#ifndef OS_WINCE
BOOL CMainDlg::PaintBrandingText(HBITMAP hbmBrandImage)
{
HDC hdcBitmap;
HBITMAP hbmOld;
RECT rc;
COLORREF oldCol;
INT oldMode;
RECT textRc;
INT textHeight = 0;
TCHAR szBrandLine1[MAX_PATH];
TCHAR szBrandLine2[MAX_PATH];
TCHAR szLineDelta[20];
HFONT hOldFont = NULL;
HFONT hFontBrandLine1 = NULL;
HFONT hFontBrandLine2 = NULL;
BOOL bRet = FALSE;
INT rightEdge = 0;
INT nTextLineDelta = 0;
UINT dtTextAlign = DT_LEFT;
//
// These values determined based on the branding
// bitmap, they are constant and don't change with
// font sizes. But if the branding bitmap is updated
// the values may need to be tweaked
//
static const int TextLine1Top = 8;
static const int TextLine1Left = 80;
static const int TextLineDistFromRightEdge = 20;
static const int TextLineDelta = 5;
DC_BEGIN_FN("PaintBrandingText");
if(!LoadString( _hInstance, UI_IDS_BRANDING_LINE1,
szBrandLine1, SIZECHAR(szBrandLine1) ))
{
TRC_ERR((TB,_T("LoadString for UI_IDS_BRANDING_LINE1 failed 0x%x"),
GetLastError()));
return FALSE;
}
if(!LoadString( _hInstance, UI_IDS_BRANDING_LINE2,
szBrandLine2, SIZECHAR(szBrandLine2)))
{
TRC_ERR((TB,_T("LoadString for UI_IDS_BRANDING_LINE2 failed 0x%x"),
GetLastError()));
return FALSE;
}
//
// Figure out if this is Bidi, if so flip text alignment
//
if (GetWindowLongPtr(_hwndDlg, GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
{
TRC_NRM((TB,_T("RTL layout detected, flip text alignment")));
dtTextAlign = DT_RIGHT;
}
else
{
dtTextAlign = DT_LEFT;
}
hFontBrandLine1 = LoadFontFromResourceInfo( UI_IDS_BRANDING_LN1FONT,
UI_IDS_BRANDING_LN1SIZE,
FALSE );
if(!hFontBrandLine1)
{
TRC_ERR((TB,_T("LoadFontFromResourceInfo for brandln1 failed")));
DC_QUIT;
}
hFontBrandLine2 = LoadFontFromResourceInfo( UI_IDS_BRANDING_LN2FONT,
UI_IDS_BRANDING_LN2SIZE,
TRUE );
if(!hFontBrandLine2)
{
TRC_ERR((TB,_T("LoadFontFromResourceInfo for brandln1 failed")));
DC_QUIT;
}
if (LoadString( _hInstance, UI_IDS_LINESPACING_DELTA,
szLineDelta, SIZECHAR(szLineDelta)))
{
nTextLineDelta = _ttol(szLineDelta);
}
else
{
TRC_ERR((TB,_T("Failed to load text line delta using default")));
nTextLineDelta = TextLineDelta;
}
hdcBitmap = CreateCompatibleDC(NULL);
if(hdcBitmap)
{
hbmOld = (HBITMAP)SelectObject(hdcBitmap, hbmBrandImage);
hOldFont = (HFONT)SelectObject( hdcBitmap, hFontBrandLine1);
// Set text transparency and color
//White text
SetTextColor(hdcBitmap, RGB(255,255,255));
SetBkMode(hdcBitmap, TRANSPARENT);
SetMapMode(hdcBitmap, MM_TEXT);
GetClientRect( _hwndDlg, &rc );
rightEdge = min(_nBrandImageWidth, rc.right);
textRc.right = rightEdge - TextLineDistFromRightEdge;
textRc.top = TextLine1Top;
textRc.bottom = 40;
textRc.left = TextLine1Left;
//
// Draw first branding line
//
textHeight = DrawText(hdcBitmap,
szBrandLine1,
_tcslen(szBrandLine1),
&textRc, //rect
dtTextAlign);
if(!textHeight)
{
TRC_ERR((TB,_T("DrawText for brand line1 failed 0x%x"),
GetLastError()));
}
textRc.top += textHeight - nTextLineDelta;
textRc.bottom += textHeight - nTextLineDelta;
SelectObject( hdcBitmap, hFontBrandLine2);
//
// Draw second branding line
//
textHeight = DrawText(hdcBitmap,
szBrandLine2,
_tcslen(szBrandLine2),
&textRc, //rect
dtTextAlign);
if(!textHeight)
{
TRC_ERR((TB,_T("DrawText for brand line1 failed 0x%x"),
GetLastError()));
}
SelectObject( hdcBitmap, hOldFont );
SelectObject(hdcBitmap, hbmOld);
DeleteDC(hdcBitmap);
bRet = TRUE;
}
else
{
DC_QUIT;
}
DC_EXIT_POINT:
DC_END_FN();
if(hFontBrandLine1)
{
DeleteObject( hFontBrandLine1 );
}
if(hFontBrandLine2)
{
DeleteObject( hFontBrandLine2 );
}
return bRet;
}
#endif
void CMainDlg::SetFontFaceFromResource(PLOGFONT plf, UINT idFaceName)
{
DC_BEGIN_FN("SetFontFaceFromResource");
// Read the face name and point size from the resource file
if (LoadString(_hInstance, idFaceName, plf->lfFaceName, LF_FACESIZE) == 0)
{
_tcscpy(plf->lfFaceName, TEXT("Tahoma"));
TRC_ERR((TB,_T("Could not read welcome font face from resource")));
}
DC_END_FN();
}
//
// Note this is pixel size and not font size
//
void CMainDlg::SetFontSizeFromResource(PLOGFONT plf, UINT idSizeName)
{
DC_BEGIN_FN("SetFontFaceFromResource");
TCHAR szPixelSize[10];
LONG nSize;
if (LoadString(_hInstance, idSizeName, szPixelSize, SIZECHAR(szPixelSize)) != 0)
{
nSize = _ttol(szPixelSize);
}
else
{
// Make it really obvious something is wrong
nSize = 40;
}
plf->lfHeight = -nSize;
DC_END_FN();
}
#ifndef OS_WINCE
HFONT CMainDlg::LoadFontFromResourceInfo(UINT idFace, UINT idSize, BOOL fBold)
{
LOGFONT lf = {0};
CHARSETINFO csInfo;
HFONT hFont;
DC_BEGIN_FN("LoadFontFromResourceInfo");
lf.lfWidth = 0;
lf.lfWeight = fBold ? FW_HEAVY : FW_NORMAL;
lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
lf.lfQuality = DEFAULT_QUALITY;
lf.lfPitchAndFamily = DEFAULT_PITCH;
// Set charset
if (TranslateCharsetInfo((LPDWORD)UIntToPtr(GetACP()), &csInfo,
TCI_SRCCODEPAGE) == 0)
{
TRC_ASSERT(0,(TB,_T("TranslateCharsetInfo failed")));
csInfo.ciCharset = 0;
}
lf.lfCharSet = (UCHAR)csInfo.ciCharset;
SetFontFaceFromResource(&lf, idFace);
SetFontSizeFromResource(&lf, idSize);
hFont = CreateFontIndirect(&lf);
TRC_ASSERT(hFont, (TB,_T("CreateFontIndirect failed")));
DC_END_FN();
return hFont;
}
#endif
//
// Propagates a message to all child windows
// used so common controls get notifications
// e.g of color changes
//
VOID CMainDlg::PropagateMsgToChildren(HWND hwndDlg,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
HWND hwndChild;
DC_BEGIN_FN("PropagateMsgToChildren");
for( hwndChild = GetWindow(hwndDlg, GW_CHILD);
hwndChild != NULL;
hwndChild = GetWindow(hwndChild, GW_HWNDNEXT) )
{
#ifdef DC_DEBUG
/* GetClassName doesn't have a uniwrap wrapper yet...
TCHAR szTmp[256];
GetClassName(hwndChild, szTmp, 256);
TRC_DBG((TB,
_T("PropagateMessage: ( 0x%08lX cls:%s, 0x%08X, 0x%08lX, 0x%08lX )\n"),
hwndChild, uMsg, wParam, lParam ));
*/
#endif
SendMessage(hwndChild, uMsg, wParam, lParam);
}
DC_END_FN();
}
#ifndef OS_WINCE
//
// Initializes the images (branding and band bitmap)
// taking into account the current color depth.
//
// This function can be recalled if there is a color
// depth change
//
//
BOOL CMainDlg::InitializeBmps()
{
HBITMAP hbmBrandImage = NULL;
UINT screenBpp;
UINT imgResID;
HBITMAP hbmFromRsrc = NULL;
INT nBmpWidth = 0;
INT nBmpHeight = 0;
BOOL fDeepImgs = FALSE;
RECT rc;
INT nDlgWidth;
DC_BEGIN_FN("InitializeBmps");
//
// _hwndDlg should be set early in WM_INITDIALOG
//
TRC_ASSERT(_hwndDlg,
(TB,_T("_hwndDlg is null")));
screenBpp = CSH::SH_GetScreenBpp();
if (screenBpp <= 8)
{
_fUse16ColorBitmaps = TRUE;
imgResID = UI_IDB_BRANDIMAGE_16;
}
else
{
_fUse16ColorBitmaps = FALSE;
imgResID = UI_IDB_BRANDIMAGE;
}
GetClientRect( _hwndDlg, &rc );
nDlgWidth = rc.right - rc.left;
if (!nDlgWidth)
{
//
// We've seen cases in FUS where the client area is returned
// as 0. Be robust to that and just bail out of initilizing
// the bmp with a fail code
//
TRC_ERR((TB,_T("Got 0 client width")));
return FALSE;
}
if (screenBpp >= 8)
{
fDeepImgs = TRUE;
}
TRC_NRM((TB,_T("Use16 color bmp :%d. Img res id:%d"),
_fUse16ColorBitmaps,imgResID));
hbmFromRsrc = (HBITMAP)LoadImage(_hInstance,
MAKEINTRESOURCE(imgResID),IMAGE_BITMAP,
0, 0, LR_CREATEDIBSECTION);
if (hbmFromRsrc)
{
//
// Figure out the dimensions of the resrc bmp
//
DIBSECTION ds = {0};
if (GetObject(hbmFromRsrc, sizeof(ds), &ds))
{
nBmpHeight = ds.dsBm.bmHeight;
if(nBmpHeight < 0)
{
nBmpHeight -= 0;
}
nBmpWidth = ds.dsBm.bmWidth;
}
//
// Create a new brand bitmap that spans
// the width of the dialog. This is necessary
// so that we can just set it up once e.g
// drawing branding text etc. The bitmap has to match
// the dialog width because on localized builds the dialog
// can be much wider than the resource version of the bitmap
// and the text can span a wider area.
//
HDC hDC = GetWindowDC(_hwndDlg);
if (hDC)
{
hbmBrandImage = CreateCompatibleBitmap(hDC,
nDlgWidth,
nBmpHeight);
HDC hMemDCSrc = CreateCompatibleDC(hDC);
HDC hMemDCDest = CreateCompatibleDC(hDC);
if (hMemDCSrc && hMemDCDest)
{
RECT rcFill;
RGBQUAD rgb[256];
HBITMAP hbmDestOld = NULL;
LPLOGPALETTE pLogPalette = NULL;
HPALETTE hScreenPalOld = NULL;
HPALETTE hMemPalOld = NULL;
UINT nCol = 0;
//
// Get brand img palette
//
_hBrandPal = CUT::UT_GetPaletteForBitmap(hDC, hbmFromRsrc);
if (_hBrandPal) {
hScreenPalOld = SelectPalette(hDC, _hBrandPal, FALSE);
hMemPalOld = SelectPalette(hMemDCDest, _hBrandPal, FALSE);
RealizePalette(hDC);
}
HBITMAP hbmSrcOld = (HBITMAP)SelectObject(
hMemDCSrc, hbmFromRsrc);
hbmDestOld = (HBITMAP)SelectObject(
hMemDCDest, hbmBrandImage);
rcFill.left = 0;
rcFill.top = 0;
rcFill.bottom = nBmpHeight;
rcFill.right = nDlgWidth;
HBRUSH hSolidBr = CreateSolidBrush(
_fUse16ColorBitmaps ? IMAGE_BG_COL_16 : IMAGE_BG_COL);
if (hSolidBr)
{
FillRect(hMemDCDest,
&rcFill,
hSolidBr);
DeleteObject( hSolidBr );
}
BitBlt(hMemDCDest, 0, 0, nDlgWidth, nBmpHeight,
hMemDCSrc, 0, 0, SRCCOPY);
if (hbmDestOld)
{
SelectObject(hMemDCDest, hbmDestOld);
}
if (hbmSrcOld)
{
SelectObject(hMemDCSrc, hbmSrcOld);
}
if (hScreenPalOld)
{
SelectPalette(hDC, hScreenPalOld, TRUE);
}
if (hMemPalOld)
{
SelectPalette(hDC, hMemPalOld, TRUE);
}
DeleteDC(hMemDCSrc);
DeleteDC(hMemDCDest);
}
ReleaseDC(_hwndDlg, hDC);
}
else
{
TRC_ERR((TB,_T("GetDC failed 0x%x"),
GetLastError()));
}
DeleteObject( hbmFromRsrc );
_nBrandImageWidth = nDlgWidth;
_nBrandImageHeight = nBmpHeight;
}
if(!hbmBrandImage)
{
TRC_ERR((TB,_T("Error setting up brand bmp")));
return FALSE;
}
if(hbmBrandImage)
{
PaintBrandingText( hbmBrandImage );
}
//
// Delete any old brand img and keep track of this one
//
if (_hBrandImg)
{
DeleteObject(_hBrandImg);
}
_hBrandImg = hbmBrandImage;
TRC_ASSERT(_nBrandImageHeight,
(TB,_T("_nBrandImageHeight is 0!")));
_lastValidBpp = screenBpp;
DC_END_FN();
return TRUE;
}
//
// BrandingQueryNewPalette / BrandingPaletteChanged
// code 'borrowed' from winlogon
// Handle palette change messages from the system so that we can work correctly
// on <= 8 bit per pixel devices.
//
// In:
// -
// Out:
// -
//
BOOL CMainDlg::BrandingQueryNewPalette(HWND hDlg)
{
HDC hDC;
HPALETTE oldPalette;
DC_BEGIN_FN("BrandingQueryNewPalette");
if ( !_hBrandPal )
return FALSE;
hDC = GetDC(hDlg);
if ( !hDC )
return FALSE;
oldPalette = SelectPalette(hDC, _hBrandPal, FALSE);
RealizePalette(hDC);
UpdateColors(hDC);
//
// Update the window
//
UpdateWindow(hDlg);
if ( oldPalette )
SelectPalette(hDC, oldPalette, FALSE);
ReleaseDC(hDlg, hDC);
DC_END_FN();
return TRUE;
}
BOOL CMainDlg::BrandingPaletteChanged(HWND hDlg, HWND hWndPalChg)
{
HDC hDC;
HPALETTE oldPalette;
DC_BEGIN_FN("BrandingPaletteChanged");
if ( !_hBrandPal )
{
return FALSE;
}
if ( hDlg != hWndPalChg )
{
hDC = GetDC(hDlg);
if ( !hDC )
return FALSE;
oldPalette = SelectPalette(hDC, _hBrandPal, FALSE);
RealizePalette(hDC);
UpdateColors(hDC);
if ( oldPalette )
SelectPalette(hDC, oldPalette, FALSE);
ReleaseDC(hDlg, hDC);
}
DC_END_FN();
return FALSE;
}
#endif
//
// Load the perf strings into a global table
// that will also be used by the perf property page
//
BOOL CMainDlg::InitializePerfStrings()
{
DC_BEGIN_FN("InitializePerfStrings");
if (!g_fPropPageStringMapInitialized)
{
//
// Load color strings
//
for(int i = 0; i< NUM_PERFSTRINGS; i++)
{
if (!LoadString( _hInstance,
g_PerfOptimizeStringTable[i].resID,
g_PerfOptimizeStringTable[i].szString,
PERF_OPTIMIZE_STRING_LEN ))
{
TRC_ERR((TB, _T("Failed to load color string %d"),
g_PerfOptimizeStringTable[i].resID));
return FALSE;
}
}
g_fPropPageStringMapInitialized = TRUE;
TRC_NRM((TB,_T("Successfully loaded perf strings")));
return TRUE;
}
else
{
TRC_NRM((TB,_T("Strings were already loaded")));
return TRUE;
}
DC_END_FN();
}