2197 lines
62 KiB
C++
2197 lines
62 KiB
C++
//
|
|
// 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();
|
|
}
|
|
|