1068 lines
32 KiB
C++
1068 lines
32 KiB
C++
// configdlg.cpp : implements TSConfigDlg dialog.
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "resource.h"
|
|
#include "configdlg.h"
|
|
|
|
const CONNECTION_TIME_DIGIT_MAX = 5; // 5 digits max
|
|
const CONNECTION_TIME_DEFAULT = 120; // 120 minutes
|
|
const CONNECTION_TIME_MIN = 1; // 1 minute
|
|
const CONNECTION_TIME_MAX = 71582; // 71582 minutes (max msec for ULONG)
|
|
|
|
const DISCONNECTION_TIME_DIGIT_MAX = 5; // 5 digits max
|
|
const DISCONNECTION_TIME_DEFAULT = 10; // 10 minutes
|
|
const DISCONNECTION_TIME_MIN = 1; // 1 minute
|
|
const DISCONNECTION_TIME_MAX = 71582; // 71582 minutes (max msec for ULONG)
|
|
|
|
const IDLE_TIME_DIGIT_MAX = 5; // 5 digits max
|
|
const IDLE_TIME_DEFAULT = 10; // 10 minutes
|
|
const IDLE_TIME_MIN = 1; // 1 minute
|
|
const IDLE_TIME_MAX = 71582; // 71582 minutes (max msec for ULONG)
|
|
|
|
const TIME_RESOLUTION = 60000; // stored as msec-seen as minutes
|
|
|
|
|
|
// forword declard.
|
|
DWORD wchar2TCHAR(TCHAR *dest, const WCHAR *src);
|
|
extern HINSTANCE GetInstance();
|
|
BOOL TSConfigDlg::m_sbWindowLogSet = FALSE;
|
|
|
|
|
|
// property page dialog procedure : handles dialog messages.
|
|
BOOL CALLBACK TSConfigDlg::PropertyPageDlgProc (HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (uMsg == WM_INITDIALOG)
|
|
{
|
|
// LPARAM points to the property sheet page.
|
|
// this will give us this pointer to access the class.
|
|
|
|
TSConfigDlg *pDlg = reinterpret_cast<TSConfigDlg*>(LPPROPSHEETPAGE(lParam)->lParam);
|
|
|
|
ASSERT(NULL != pDlg);
|
|
ASSERT(pDlg->AssertClass());
|
|
SetWindowLong(hwndDlg, DWL_USER, long(pDlg));
|
|
|
|
// ok now hereafter we can access the class pointer.
|
|
// maks_done: check mfc implementation, how do they do it ?
|
|
// what mfc does is - its hooks into the wnd creation process
|
|
// and keeps a map of hwnd vs objects.
|
|
|
|
m_sbWindowLogSet = TRUE;
|
|
|
|
return pDlg->OnInitDialog(hwndDlg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
|
|
|
// now we have set DWL_USER as class pointer during INIT DIALOG.
|
|
if (m_sbWindowLogSet)
|
|
{
|
|
TSConfigDlg *pDlg = reinterpret_cast<TSConfigDlg*>(GetWindowLong(hwndDlg, DWL_USER));
|
|
ASSERT(NULL != pDlg);
|
|
ASSERT(pDlg->AssertClass());
|
|
|
|
if (uMsg == WM_COMMAND)
|
|
return pDlg->OnCommand(wParam, lParam);
|
|
|
|
if (uMsg == WM_NOTIFY)
|
|
{
|
|
LOGMESSAGE3(_T("Received WM_NOTIFY:hwnddlg =%ul,wParam=%u,lParam=%ul"), hwndDlg, wParam, lParam);
|
|
return pDlg->OnNotify(wParam, lParam);
|
|
}
|
|
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Property Sheet Procedure : gets notified about CREATE, RELEASE events
|
|
UINT CALLBACK TSConfigDlg::PropSheetPageProc (
|
|
HWND /* hWnd */, // [in] Window handle - always null
|
|
UINT uMsg, // [in,out] Either the create or delete message
|
|
LPPROPSHEETPAGE pPsp // [in,out] Pointer to the property sheet struct
|
|
)
|
|
{
|
|
ASSERT( NULL != pPsp );
|
|
|
|
// We need to recover a pointer to the current instance. We can't just use
|
|
// "this" because we are in a static function
|
|
TSConfigDlg* pMe = reinterpret_cast<TSConfigDlg*>(pPsp->lParam);
|
|
ASSERT( NULL != pMe );
|
|
ASSERT(pMe->AssertClass());
|
|
|
|
switch( uMsg )
|
|
{
|
|
case PSPCB_CREATE:
|
|
break;
|
|
|
|
case PSPCB_RELEASE:
|
|
|
|
// this variable makes dialog proc setwindowlong on dialog handle.
|
|
m_sbWindowLogSet = FALSE;
|
|
delete pMe;
|
|
return 1; //(pfnOrig)(hWnd, uMsg, pPsp);
|
|
}
|
|
|
|
return 1;
|
|
|
|
} // end PropSheetPageProc()
|
|
|
|
|
|
|
|
TSConfigDlg::TSConfigDlg (LPWSTR wMachineName, LPWSTR wUserName)
|
|
{
|
|
ASSERT(wMachineName);
|
|
ASSERT(wUserName);
|
|
|
|
ASSERT(wcslen(wMachineName) < SIZE_MAX_SERVERNAME);
|
|
ASSERT(wcslen(wUserName) < SIZE_MAX_USERNAME);
|
|
|
|
VERIFY( wchar2TCHAR(m_Username, wUserName) < SIZE_MAX_USERNAME);
|
|
VERIFY( wchar2TCHAR(m_Servername, wMachineName) < SIZE_MAX_SERVERNAME);
|
|
|
|
LOGMESSAGE0(_T("TSConfigDlg::TSConfigDlg ()"));
|
|
|
|
m_tPropSheetPage.dwSize = sizeof (PROPSHEETPAGE);
|
|
m_tPropSheetPage.hInstance = GetInstance ();
|
|
m_tPropSheetPage.pszTemplate = MAKEINTRESOURCE(IDD);
|
|
m_tPropSheetPage.dwFlags = PSP_USECALLBACK;
|
|
m_tPropSheetPage.pfnDlgProc = PropertyPageDlgProc;
|
|
m_tPropSheetPage.pfnCallback = PropSheetPageProc;
|
|
m_tPropSheetPage.lParam = long(this);
|
|
|
|
m_sbWindowLogSet = FALSE;
|
|
m_id = IDD_TS_USER_CONFIG_EDIT;
|
|
}
|
|
|
|
|
|
|
|
BOOL TSConfigDlg::AssertClass() const
|
|
{
|
|
return m_id == IDD_TS_USER_CONFIG_EDIT;
|
|
}
|
|
|
|
TSConfigDlg::~TSConfigDlg ()
|
|
{
|
|
LOGMESSAGE0(_T("TSConfigDlg::~TSConfigDlg ()"));
|
|
}
|
|
|
|
BOOL TSConfigDlg::OnInitDialog(
|
|
HWND hwndDlg,
|
|
WPARAM /* wParam */,
|
|
LPARAM /* lParam */
|
|
)
|
|
{
|
|
m_hDlg = hwndDlg;
|
|
|
|
// get the user info and initialize dialog class members with it.
|
|
GetUserInfo();
|
|
|
|
// initializes the controls.
|
|
InitControls();
|
|
|
|
return 1; // non zero since we are not calling setfocus
|
|
}
|
|
|
|
|
|
APIERR TSConfigDlg::SetUserInfo ()
|
|
{
|
|
APIERR err;
|
|
USERCONFIG UserConfig;
|
|
|
|
/* If the object is not 'dirty', no need to save info.
|
|
*/
|
|
// if ( !_fDirty )
|
|
// return NERR_Success;
|
|
|
|
/* Zero-initialize USERCONFIG structure and copy member variable
|
|
* contents there.
|
|
*/
|
|
ZeroMemory( &UserConfig, sizeof(USERCONFIG) );
|
|
MembersToUCStruct( &UserConfig );
|
|
|
|
/*
|
|
* Save user's configuration.
|
|
*/
|
|
err = RegUserConfigSet(
|
|
GetServername(), // servername
|
|
GetUsername(), // username
|
|
&UserConfig,
|
|
sizeof(UserConfig)
|
|
);
|
|
|
|
// Don't reset 'dirty' flag to behave properly with new RegUserConfig APIs
|
|
// (we might get called twice, just like the UsrMgr objects to, so we want
|
|
// to happily write our our data twice, just like they do)
|
|
// _fDirty = FALSE;
|
|
|
|
//
|
|
// By not setting _fDirty = FALSE here we try to check the validity of the RemoteWFHomeDir whenever OK is pressed
|
|
// This is because MS used 2 structures to hold its HomeDir, and could compare the two. We only have one and rely
|
|
// on this dirty flag. This flag is used in USERPROP_DLG::I_PerformOne_Write(...) and is set in the
|
|
// USER_CONFIG::GetInfo and USER_CONFIG::GetDefaults and USERPROF_DLG_NT::PerformOne()
|
|
//
|
|
tDialogData._fWFHomeDirDirty = FALSE;
|
|
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
APIERR TSConfigDlg::GetUserInfo ()
|
|
{
|
|
APIERR err;
|
|
ULONG Length;
|
|
USERCONFIG UserConfig;
|
|
|
|
// calll regapi function for getting user configuration
|
|
err = RegUserConfigQuery (
|
|
GetServername(), // servername
|
|
GetUsername(), // username
|
|
&UserConfig, // address for userconfig buffer
|
|
sizeof(UserConfig), // size of buffer
|
|
&Length // returned size
|
|
);
|
|
|
|
if ( err == NERR_Success )
|
|
{
|
|
ASSERT(Length == sizeof(UserConfig));
|
|
}
|
|
else
|
|
{
|
|
LOGMESSAGE3(_T("RegUserConfigQuery failed for %s\\%s. Error = %ul"), GetServername(), GetUsername(), err);
|
|
LOGMESSAGE0(_T("Getting Deafult user config"));
|
|
|
|
err = RegDefaultUserConfigQuery(
|
|
GetServername(), // servername
|
|
&UserConfig, // address for userconfig buffer
|
|
sizeof(UserConfig), // size of buffer
|
|
&Length // returned length
|
|
);
|
|
|
|
if (err != NERR_Success)
|
|
{
|
|
LOGMESSAGE3(_T("RegDefaultUserConfigQuery failed for %s\\%s. Error = %ul"), GetServername(), GetUsername(), err);
|
|
|
|
// maks_todo: must initialize defaults known to us over here.
|
|
return err;
|
|
}
|
|
}
|
|
|
|
UCStructToMembers( &UserConfig );
|
|
|
|
|
|
tDialogData._fWFHomeDirDirty = FALSE;
|
|
tDialogData._fDirty = FALSE;
|
|
|
|
return err;
|
|
}
|
|
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: USER_CONFIG::UCStructToMembers
|
|
|
|
SYNOPSIS: Copies a given USERCONFIG structure elements into
|
|
corresponding member variables.
|
|
|
|
ENTRY: pUCStruct - pointer to USERCONFIG structure.
|
|
|
|
********************************************************************/
|
|
void TSConfigDlg::UCStructToMembers( PUSERCONFIG pUCStruct )
|
|
{
|
|
ASSERT(pUCStruct);
|
|
|
|
tDialogData._fAllowLogon = (BOOL)!pUCStruct->fLogonDisabled;
|
|
tDialogData._ulConnection = pUCStruct->MaxConnectionTime;
|
|
tDialogData._ulDisconnection = pUCStruct->MaxDisconnectionTime;
|
|
tDialogData._ulIdle = pUCStruct->MaxIdleTime;
|
|
_tcscpy(tDialogData._nlsInitialProgram, pUCStruct->InitialProgram);
|
|
_tcscpy(tDialogData._nlsWorkingDirectory, pUCStruct->WorkDirectory );
|
|
tDialogData._fClientSpecified = pUCStruct->fInheritInitialProgram;
|
|
tDialogData._fAutoClientDrives = pUCStruct->fAutoClientDrives;
|
|
tDialogData._fAutoClientLpts = pUCStruct->fAutoClientLpts;
|
|
tDialogData._fForceClientLptDef = pUCStruct->fForceClientLptDef;
|
|
tDialogData._iEncryption = (INT)pUCStruct->MinEncryptionLevel;
|
|
tDialogData._fDisableEncryption = pUCStruct->fDisableEncryption;
|
|
tDialogData._fHomeDirectoryMapRoot = pUCStruct->fHomeDirectoryMapRoot;
|
|
tDialogData._iBroken = (INT)pUCStruct->fResetBroken;
|
|
tDialogData._iReconnect = (INT)pUCStruct->fReconnectSame;
|
|
tDialogData._iCallback = (INT)pUCStruct->Callback;
|
|
_tcscpy(tDialogData._nlsPhoneNumber, pUCStruct->CallbackNumber );
|
|
tDialogData._iShadow = (INT)pUCStruct->Shadow;
|
|
_tcscpy(tDialogData._nlsNWLogonServer, pUCStruct->NWLogonServer );
|
|
_tcscpy(tDialogData._nlsWFProfilePath, pUCStruct->WFProfilePath );
|
|
_tcscpy(tDialogData._nlsWFHomeDir, pUCStruct->WFHomeDir );
|
|
_tcscpy(tDialogData._nlsWFHomeDirDrive, pUCStruct->WFHomeDirDrive);
|
|
|
|
}
|
|
|
|
|
|
/*******************************************************************
|
|
|
|
NAME: USER_CONFIG::MembersToUCStruct
|
|
|
|
SYNOPSIS: Copies member variables into a given USERCONFIG
|
|
structure elements.
|
|
|
|
ENTRY: pUCStruct - pointer to USERCONFIG structure.
|
|
|
|
********************************************************************/
|
|
|
|
void TSConfigDlg::MembersToUCStruct( PUSERCONFIG pUCStruct ) const
|
|
{
|
|
ASSERT(pUCStruct);
|
|
|
|
pUCStruct->fLogonDisabled = !tDialogData._fAllowLogon;
|
|
pUCStruct->MaxConnectionTime = tDialogData._ulConnection;
|
|
pUCStruct->MaxDisconnectionTime = tDialogData._ulDisconnection;
|
|
pUCStruct->MaxIdleTime = tDialogData._ulIdle;
|
|
_tcscpy( pUCStruct->InitialProgram, tDialogData._nlsInitialProgram);
|
|
_tcscpy( pUCStruct->WorkDirectory, tDialogData._nlsWorkingDirectory);
|
|
pUCStruct->fInheritInitialProgram = tDialogData._fClientSpecified;
|
|
pUCStruct->fAutoClientDrives = tDialogData._fAutoClientDrives;
|
|
pUCStruct->fAutoClientLpts = tDialogData._fAutoClientLpts;
|
|
pUCStruct->fForceClientLptDef = tDialogData._fForceClientLptDef;
|
|
pUCStruct->MinEncryptionLevel = (BYTE)tDialogData._iEncryption;
|
|
pUCStruct->fDisableEncryption = tDialogData._fDisableEncryption;
|
|
pUCStruct->fHomeDirectoryMapRoot = tDialogData._fHomeDirectoryMapRoot;
|
|
pUCStruct->fResetBroken = tDialogData._iBroken;
|
|
pUCStruct->fReconnectSame = tDialogData._iReconnect;
|
|
pUCStruct->Callback = (CALLBACKCLASS)tDialogData._iCallback;
|
|
_tcscpy( pUCStruct->CallbackNumber, tDialogData._nlsPhoneNumber);
|
|
pUCStruct->Shadow = (SHADOWCLASS)tDialogData._iShadow;
|
|
_tcscpy( pUCStruct->NWLogonServer, tDialogData._nlsNWLogonServer);
|
|
_tcscpy( pUCStruct->WFProfilePath, tDialogData._nlsWFProfilePath);
|
|
_tcscpy( pUCStruct->WFHomeDir, tDialogData._nlsWFHomeDir);
|
|
_tcscpy( pUCStruct->WFHomeDirDrive, tDialogData._nlsWFHomeDirDrive);
|
|
}
|
|
|
|
BOOL TSConfigDlg::OnNotify (WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int idCtrl = (int) wParam;
|
|
NMHDR *pnmh = (LPNMHDR) lParam;
|
|
|
|
// typedef struct tagNMHDR {
|
|
// HWND hwndFrom;
|
|
// UINT idFrom;
|
|
// UINT code;
|
|
// } NMHDR;
|
|
|
|
ASSERT(pnmh);
|
|
switch(pnmh->code)
|
|
{
|
|
case PSN_KILLACTIVE:
|
|
LOGMESSAGE0(_T("Its KillActive Notification"));
|
|
|
|
if (VerifyChanges())
|
|
// verify passed, allow the page to lose the activation
|
|
SetWindowLong(GetDlgHandle(), DWL_MSGRESULT, FALSE);
|
|
else
|
|
// no verify failed, prevent the page from losing the activation
|
|
SetWindowLong(GetDlgHandle(), DWL_MSGRESULT, TRUE);;
|
|
|
|
break;
|
|
|
|
case PSN_APPLY:
|
|
LOGMESSAGE0(_T("Its Apply Notification"));
|
|
ApplyChanges();
|
|
break;
|
|
|
|
case PSN_RESET:
|
|
// cancel changes.
|
|
LOGMESSAGE0(_T("Its Apply Reset"));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
BOOL TSConfigDlg::OnCommand(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
|
|
WORD wNotifyCode = HIWORD(wParam); // notification code
|
|
WORD wID = LOWORD(wParam); // item, control, or accelerator identifier
|
|
HWND hwndCtl = (HWND) lParam; // handle of control
|
|
|
|
//if (wNotifyCode == 0 || wNotifyCode == 1)
|
|
// return 1;
|
|
|
|
// dispatch the command messages accordingly.
|
|
switch(wID)
|
|
{
|
|
case IDC_UCE_ALLOWLOGON:
|
|
ALLOWLOGONEvent(wNotifyCode);
|
|
break;
|
|
|
|
case IDC_UCE_CONNECTION_NONE:
|
|
CONNECTION_NONEEvent(wNotifyCode);
|
|
break;
|
|
|
|
case IDC_UCE_DISCONNECTION_NONE:
|
|
DISCONNECTION_NONEEvent(wNotifyCode);
|
|
break;
|
|
|
|
case IDC_UCE_IDLE_NONE:
|
|
IDLE_NONEEvent(wNotifyCode);
|
|
break;
|
|
|
|
case IDC_UCE_INITIALPROGRAM_INHERIT:
|
|
INITIALPROGRAM_INHERITEvent(wNotifyCode);
|
|
break;
|
|
|
|
case IDC_UCE_SECURITY_DISABLEAFTERLOGON:
|
|
SECURITY_DISABLEAFTERLOGONEvent(wNotifyCode);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return 1; // since we do not process message.
|
|
}
|
|
|
|
BOOL TSConfigDlg::InitControls ()
|
|
{
|
|
TCHAR str[SIZE_SMALL_STRING_BUFFER];
|
|
|
|
|
|
struct
|
|
{
|
|
UINT uiControlID;
|
|
UINT uiNoOfStrings;
|
|
UINT auiStringList[7];
|
|
|
|
} atListControls[] =
|
|
{
|
|
{
|
|
IDC_UCE_SECURITY_ENCRYPT,
|
|
2,
|
|
{
|
|
IDS_UCE_ENCRYPT_NONE,
|
|
IDS_UCE_ENCRYPT_LEVEL1,
|
|
}
|
|
},
|
|
{
|
|
IDC_UCE_BROKEN,
|
|
2,
|
|
{
|
|
IDS_UCE_BROKEN_DISCONNECT,
|
|
IDS_UCE_BROKEN_RESET,
|
|
}
|
|
},
|
|
{
|
|
IDC_UCE_RECONNECT,
|
|
2,
|
|
{
|
|
IDS_UCE_RECONNECT_ANY,
|
|
IDS_UCE_RECONNECT_PREVIOUS,
|
|
}
|
|
},
|
|
{
|
|
IDC_UCE_CALLBACK,
|
|
3,
|
|
{
|
|
IDS_UCE_CALLBACK_DISABLE,
|
|
IDS_UCE_CALLBACK_ROVING,
|
|
IDS_UCE_CALLBACK_FIXED,
|
|
}
|
|
},
|
|
{
|
|
IDC_UCE_SHADOW,
|
|
5,
|
|
{
|
|
IDS_UCE_SHADOW_DISABLE,
|
|
IDS_UCE_SHADOW_INPUT_NOTIFY,
|
|
IDS_UCE_SHADOW_INPUT_NONOTIFY,
|
|
IDS_UCE_SHADOW_NOINPUT_NOTIFY,
|
|
IDS_UCE_SHADOW_NOINPUT_NONOTIFY,
|
|
}
|
|
}
|
|
};
|
|
|
|
// for each list/combo box control
|
|
for (int j = 0; j < sizeof(atListControls)/sizeof(atListControls[0]); j++)
|
|
{
|
|
// add all the strings specified for the control
|
|
for (UINT i = 0; i < atListControls[j].uiNoOfStrings; i++)
|
|
{
|
|
DWORD dwSize = LoadString(
|
|
GetInstance (),
|
|
atListControls[j].auiStringList[i],
|
|
str,
|
|
SIZE_SMALL_STRING_BUFFER);
|
|
|
|
ASSERT(dwSize != 0 && dwSize <= SIZE_SMALL_STRING_BUFFER - 1);
|
|
|
|
SendDlgItemMessage(
|
|
GetDlgHandle(),
|
|
atListControls[j].uiControlID,
|
|
CB_ADDSTRING,
|
|
0,
|
|
LPARAM(str));
|
|
}
|
|
}
|
|
|
|
// we dont want tristate buttons for now
|
|
// as we are not supporting multipal users
|
|
// lets make all the controls no tristate.
|
|
int aCheckBoxes[] =
|
|
{
|
|
IDC_UCE_ALLOWLOGON,
|
|
IDC_UCE_CONNECTION_NONE,
|
|
IDC_UCE_DISCONNECTION_NONE,
|
|
IDC_UCE_IDLE_NONE,
|
|
IDC_UCE_INITIALPROGRAM_INHERIT,
|
|
IDC_UCE_SECURITY_DISABLEAFTERLOGON
|
|
};
|
|
|
|
for (int i = 0; i < sizeof(aCheckBoxes)/sizeof(aCheckBoxes[0]); i++)
|
|
{
|
|
HWND hControlWnd = GetDlgItem(GetDlgHandle(), aCheckBoxes[i]);
|
|
ASSERT(hControlWnd);
|
|
|
|
//DWORD dwStyle = GetWindowLong(hControlWnd, GWL_STYLE);
|
|
//dwStyle = dwStyle & ~BS_3STATE;
|
|
|
|
SendMessage (hControlWnd, BM_SETSTYLE, LOWORD(BS_AUTOCHECKBOX), MAKELPARAM(0, 0));
|
|
}
|
|
|
|
|
|
// set text limit for the edit boxes.
|
|
// EM_SETLIMITTEXT
|
|
// wParam = (WPARAM) cbMax; // new text limits, in bytes
|
|
// lParam = 0; // not used, must be zero
|
|
|
|
|
|
struct
|
|
{
|
|
UINT uiEditControlid;
|
|
UINT uiLimitText;
|
|
} atTextLimits[] =
|
|
{
|
|
{IDC_UCE_CONNECTION, CONNECTION_TIME_DIGIT_MAX},
|
|
{IDC_UCE_DISCONNECTION, DISCONNECTION_TIME_DIGIT_MAX},
|
|
{IDC_UCE_IDLE, IDLE_TIME_DIGIT_MAX},
|
|
{IDC_UCE_INITIALPROGRAM_COMMANDLINE, MAX_INIT_PROGRAM_SIZE},
|
|
{IDC_UCE_INITIALPROGRAM_WORKINGDIRECTORY, MAX_INIT_DIR_SIZE}
|
|
};
|
|
|
|
|
|
for (i = 0; i < sizeof(atTextLimits)/sizeof(atTextLimits[0]); i++)
|
|
{
|
|
HWND hControlWnd = GetDlgItem(GetDlgHandle(), atTextLimits[i].uiEditControlid);
|
|
ASSERT(hControlWnd);
|
|
|
|
//DWORD dwStyle = GetWindowLong(hControlWnd, GWL_STYLE);
|
|
//dwStyle = dwStyle & ~BS_3STATE;
|
|
SendMessage (hControlWnd, EM_SETLIMITTEXT, atTextLimits[i].uiLimitText, MAKELPARAM(0, 0));
|
|
}
|
|
|
|
|
|
return MembersToControls();
|
|
|
|
}
|
|
|
|
BOOL TSConfigDlg::VerifyChanges ()
|
|
{
|
|
// do the necessary varification here.
|
|
|
|
// if data entered is good return TRUE
|
|
// otherwise display message and return FALSE
|
|
|
|
TDialogData tTemp;
|
|
return ControlsToMembers(&tTemp);
|
|
}
|
|
|
|
BOOL TSConfigDlg::ApplyChanges ()
|
|
{
|
|
ASSERT(VerifyChanges());
|
|
|
|
// control to members fails if the data is controls is bad.
|
|
// but since we have varified the changes before getting call to apply changes
|
|
// it must pass.
|
|
VERIFY( ControlsToMembers(&tDialogData) );
|
|
SetUserInfo();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::MembersToControls ()
|
|
{
|
|
VERIFY( SetAllowLogon ( tDialogData._fAllowLogon ));
|
|
VERIFY( SetConnectionTimeOut( tDialogData._ulConnection ));
|
|
VERIFY( SetDisConnectionTimeOut( tDialogData._ulDisconnection ));
|
|
VERIFY( SetIdleTimeOut( tDialogData._ulIdle ));
|
|
VERIFY( SetCommandLineAndWorkingDirectory(tDialogData._fClientSpecified, tDialogData._nlsWorkingDirectory, tDialogData._nlsInitialProgram));
|
|
VERIFY( SetSecurity(tDialogData._iEncryption, tDialogData._fDisableEncryption));
|
|
VERIFY( SetBrokenConnectionOption(tDialogData._iBroken));
|
|
VERIFY( SetReconnectDisconnection(tDialogData._iReconnect));
|
|
VERIFY( SetCallBackOptonAndPhoneNumber(tDialogData._iCallback, tDialogData._nlsPhoneNumber));
|
|
VERIFY( SetShadowing(tDialogData._iShadow));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::ControlsToMembers (TDialogData *pDlgData)
|
|
{
|
|
ASSERT(pDlgData);
|
|
if ( !GetAllowLogon (&pDlgData->_fAllowLogon))
|
|
return FALSE;
|
|
if ( !GetConnectionTimeOut(&pDlgData->_ulConnection))
|
|
return FALSE;
|
|
if ( !GetDisConnectionTimeOut(&pDlgData->_ulDisconnection))
|
|
return FALSE;
|
|
if ( !GetIdleTimeOut(&pDlgData->_ulIdle))
|
|
return FALSE;
|
|
if ( !GetCommandLineAndWorkingDirectory(&pDlgData->_fClientSpecified, pDlgData->_nlsWorkingDirectory, pDlgData->_nlsInitialProgram))
|
|
return FALSE;
|
|
if ( !GetSecurity(&pDlgData->_iEncryption, &pDlgData->_fDisableEncryption))
|
|
return FALSE;
|
|
if ( !GetBrokenConnectionOption(&pDlgData->_iBroken))
|
|
return FALSE;
|
|
if ( !GetReconnectDisconnection(&pDlgData->_iReconnect))
|
|
return FALSE;
|
|
if ( !GetCallBackOptonAndPhoneNumber(&pDlgData->_iCallback, pDlgData->_nlsPhoneNumber))
|
|
return FALSE;
|
|
if ( !GetShadowing(&pDlgData->_iShadow))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::GetAllowLogon (BOOL *pbAllowLogon)
|
|
{
|
|
ASSERT(pbAllowLogon);
|
|
*pbAllowLogon = IsChecked(IDC_UCE_ALLOWLOGON);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetAllowLogon (BOOL bAllowLogon)
|
|
{
|
|
SetCheck(IDC_UCE_ALLOWLOGON, bAllowLogon);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::GetConnectionTimeOut(ULONG *pValue)
|
|
{
|
|
|
|
ASSERT(pValue);
|
|
BOOL bResult = FALSE;
|
|
|
|
if (IsChecked(IDC_UCE_CONNECTION_NONE))
|
|
{
|
|
// maks_todo: assert that edit control is disabled.
|
|
// maks_todo : assert that edit control has value == 0
|
|
*pValue = 0;
|
|
bResult = TRUE;
|
|
|
|
}
|
|
else
|
|
{
|
|
// last parameter tells if the value is signed or unsigned.
|
|
// we ask it not to look for - sign.
|
|
// maks_todo:BUT WE MAY WANT TO CHNAGE THIS
|
|
*pValue = GetDlgItemInt(GetDlgHandle(), IDC_UCE_CONNECTION, &bResult, FALSE);
|
|
|
|
if (!bResult || *pValue == 0 || *pValue > 71582)
|
|
{
|
|
MessageBox(GetDlgHandle(), _T("The Connection Timeout value must 1 to 71582 minutes. Check the 'No Timeout' if you wish to specify no connection timeout"), _T("Termainl Server Properties"), MB_OK);
|
|
bResult = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
// users talk in terms of mins.
|
|
// we talk about msecs.
|
|
*pValue = *pValue * TIME_RESOLUTION;
|
|
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetConnectionTimeOut(ULONG iValue)
|
|
{
|
|
// users talk in terms of mins.
|
|
// we talk about msecs.
|
|
iValue = iValue / TIME_RESOLUTION;
|
|
|
|
SetCheck(IDC_UCE_CONNECTION_NONE, iValue == 0);
|
|
EnableControl(IDC_UCE_CONNECTION, iValue != 0);
|
|
SetDlgItemInt(GetDlgHandle(), IDC_UCE_CONNECTION, iValue, TRUE); // maks_todo : look into last param.
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::GetDisConnectionTimeOut(ULONG *pValue)
|
|
{
|
|
ASSERT(pValue);
|
|
BOOL bResult = FALSE;
|
|
|
|
if (IsChecked(IDC_UCE_DISCONNECTION_NONE))
|
|
{
|
|
// maks_todo: assert that edit control is disabled.
|
|
// maks_todo : assert that edit control has value == 0
|
|
*pValue = 0;
|
|
bResult = TRUE;
|
|
|
|
}
|
|
else
|
|
{
|
|
// last parameter tells if the value is signed or unsigned.
|
|
// we ask it not to look for - sign.
|
|
// maks_todo:BUT WE MAY WANT TO CHNAGE THIS
|
|
*pValue = GetDlgItemInt(GetDlgHandle(), IDC_UCE_DISCONNECTION, &bResult, FALSE);
|
|
|
|
if (!bResult || *pValue == 0 || *pValue > 71582)
|
|
{
|
|
MessageBox(GetDlgHandle(), _T("The Disconnection Timeout value must 1 to 71582 minutes. Check the 'No Timeout' if you wish to specify no Disconnection timeout"), _T("Termainl Server Properties"), MB_OK);
|
|
bResult = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
*pValue = *pValue * TIME_RESOLUTION;
|
|
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetDisConnectionTimeOut(ULONG iValue)
|
|
{
|
|
// users talk in terms of mins.
|
|
// we talk about msecs.
|
|
iValue = iValue / TIME_RESOLUTION;
|
|
|
|
SetCheck(IDC_UCE_DISCONNECTION_NONE, iValue == 0);
|
|
|
|
EnableControl(IDC_UCE_DISCONNECTION, iValue != 0);
|
|
SetDlgItemInt(GetDlgHandle(), IDC_UCE_DISCONNECTION, iValue, TRUE); // maks_todo : look into last param.
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::GetIdleTimeOut(ULONG *pValue)
|
|
{
|
|
ASSERT(pValue);
|
|
BOOL bResult = FALSE;
|
|
|
|
if (IsChecked(IDC_UCE_IDLE_NONE))
|
|
{
|
|
// maks_todo: assert that edit control is disabled.
|
|
// maks_todo : assert that edit control has value == 0
|
|
*pValue = 0;
|
|
bResult = TRUE;
|
|
|
|
}
|
|
else
|
|
{
|
|
// last parameter tells if the value is signed or unsigned.
|
|
// we ask it not to look for - sign.
|
|
// maks_todo:BUT WE MAY WANT TO CHNAGE THIS
|
|
*pValue = GetDlgItemInt(GetDlgHandle(), IDC_UCE_IDLE, &bResult, FALSE);
|
|
|
|
if (!bResult || *pValue == 0 || *pValue > 71582)
|
|
{
|
|
MessageBox(GetDlgHandle(), _T("The Idle Timeout value must 1 to 71582 minutes. Check the 'No Timeout' if you wish to specify no Idle timeout"), _T("Termainl Server Properties"), MB_OK);
|
|
bResult = FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
*pValue = *pValue * TIME_RESOLUTION;
|
|
|
|
|
|
return bResult;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetIdleTimeOut(ULONG iValue)
|
|
{
|
|
// users talk in terms of mins.
|
|
// we talk about msecs.
|
|
iValue = iValue / TIME_RESOLUTION;
|
|
|
|
SetCheck(IDC_UCE_IDLE_NONE, iValue == 0);
|
|
EnableControl(IDC_UCE_IDLE, iValue != 0);
|
|
SetDlgItemInt(GetDlgHandle(), IDC_UCE_IDLE, iValue, TRUE); // maks_todo : look into last param.
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetCommandLineAndWorkingDirectory(BOOL bUserInherited, LPCTSTR dir, LPCTSTR cmd)
|
|
{
|
|
ASSERT(dir);
|
|
ASSERT(cmd);
|
|
|
|
if (bUserInherited)
|
|
SetCheck(IDC_UCE_INITIALPROGRAM_INHERIT, bUserInherited);
|
|
|
|
// enable/disable edits according to check box status.
|
|
EnableControl(IDL_UCE_INITIALPROGRAM_COMMANDLINE1, !bUserInherited);
|
|
EnableControl(IDL_UCE_INITIALPROGRAM_WORKINGDIRECTORY1, !bUserInherited);
|
|
EnableControl(IDC_UCE_INITIALPROGRAM_COMMANDLINE, !bUserInherited);
|
|
EnableControl(IDC_UCE_INITIALPROGRAM_WORKINGDIRECTORY, !bUserInherited);
|
|
|
|
// set the text into edits.
|
|
SetDlgItemText(GetDlgHandle(), IDC_UCE_INITIALPROGRAM_COMMANDLINE, cmd);
|
|
SetDlgItemText(GetDlgHandle(), IDC_UCE_INITIALPROGRAM_WORKINGDIRECTORY, dir);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetCommandLineAndWorkingDirectory(BOOL *pbUserInherited, LPTSTR dir, LPTSTR cmd)
|
|
{
|
|
ASSERT(dir);
|
|
ASSERT(cmd);
|
|
|
|
*pbUserInherited = IsChecked(IDC_UCE_INITIALPROGRAM_INHERIT);
|
|
|
|
// set the text into edits.
|
|
GetDlgItemText(GetDlgHandle(), IDC_UCE_INITIALPROGRAM_COMMANDLINE, cmd, MAX_INIT_PROGRAM_SIZE);
|
|
GetDlgItemText(GetDlgHandle(), IDC_UCE_INITIALPROGRAM_WORKINGDIRECTORY, dir, MAX_INIT_DIR_SIZE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::SetSecurity(int iLevel, BOOL bDisableAfterLogon)
|
|
{
|
|
SetComboCurrentSel(IDC_UCE_SECURITY_ENCRYPT, iLevel);
|
|
SetCheck(IDC_UCE_SECURITY_DISABLEAFTERLOGON, bDisableAfterLogon);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetSecurity(int *piLevel, BOOL *pbDisableAfterLogon)
|
|
{
|
|
ASSERT(piLevel);
|
|
ASSERT(pbDisableAfterLogon);
|
|
|
|
*piLevel = GetComboCurrentSel(IDC_UCE_SECURITY_ENCRYPT);
|
|
*pbDisableAfterLogon = IsChecked(IDC_UCE_SECURITY_DISABLEAFTERLOGON);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetBrokenConnectionOption(int iLevel)
|
|
{
|
|
SetComboCurrentSel(IDC_UCE_BROKEN, iLevel);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetBrokenConnectionOption(int *piLevel)
|
|
{
|
|
*piLevel = GetComboCurrentSel(IDC_UCE_BROKEN);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetReconnectDisconnection(int iLevel)
|
|
{
|
|
|
|
SetComboCurrentSel(IDC_UCE_RECONNECT, iLevel);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetReconnectDisconnection(int *piLevel)
|
|
{
|
|
|
|
*piLevel = GetComboCurrentSel(IDC_UCE_RECONNECT);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetCallBackOptonAndPhoneNumber(int iCallBack, LPCTSTR PhoneNo)
|
|
{
|
|
SetComboCurrentSel(IDC_UCE_CALLBACK, iCallBack);
|
|
SetDlgItemText(GetDlgHandle(), IDC_UCE_PHONENUMBER, PhoneNo);
|
|
|
|
// enable/disable phone # accordingly.
|
|
EnableControl(IDL_UCE_PHONENUMBER, iCallBack != 0);
|
|
EnableControl(IDC_UCE_PHONENUMBER, iCallBack != 0);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetCallBackOptonAndPhoneNumber(int *piCallBack, LPTSTR PhoneNo)
|
|
{
|
|
*piCallBack = GetComboCurrentSel(IDC_UCE_CALLBACK);
|
|
GetDlgItemText(GetDlgHandle(), IDC_UCE_PHONENUMBER, PhoneNo, MAX_PHONENO_SIZE);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SetShadowing(int iLevel)
|
|
{
|
|
SetComboCurrentSel(IDC_UCE_SHADOW, iLevel);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::GetShadowing(int *piLevel)
|
|
{
|
|
*piLevel = GetComboCurrentSel(IDC_UCE_SHADOW);
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
// Utility function.
|
|
DWORD wchar2TCHAR(TCHAR *dest, const WCHAR *src)
|
|
{
|
|
ASSERT(dest && src);
|
|
|
|
#ifdef UNICODE
|
|
_tcscpy(dest, src);
|
|
#else
|
|
DWORD count;
|
|
count = WideCharToMultiByte(CP_ACP,
|
|
0,
|
|
src,
|
|
-1,
|
|
NULL,
|
|
0,
|
|
NULL,
|
|
NULL);
|
|
|
|
return WideCharToMultiByte(CP_ACP,
|
|
0,
|
|
src,
|
|
-1,
|
|
dest,
|
|
count,
|
|
NULL,
|
|
NULL);
|
|
|
|
#endif
|
|
return _tcslen(dest);
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::ALLOWLOGONEvent(WORD wNotifyCode)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::CONNECTION_NONEEvent(WORD wNotifyCode)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
EnableControl(IDC_UCE_CONNECTION, !IsChecked(IDC_UCE_CONNECTION_NONE));
|
|
|
|
//EnableControl(IDC_UCE_CONNECTION, iValue != 0);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::DISCONNECTION_NONEEvent(WORD wNotifyCode)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
EnableControl(IDC_UCE_DISCONNECTION, !IsChecked(IDC_UCE_DISCONNECTION_NONE));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::IDLE_NONEEvent(WORD wNotifyCode)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
EnableControl(IDC_UCE_IDLE, !IsChecked(IDC_UCE_IDLE_NONE));
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::INITIALPROGRAM_INHERITEvent(WORD wNotifyCode)
|
|
{
|
|
switch(wNotifyCode)
|
|
{
|
|
case BN_CLICKED:
|
|
EnableControl(IDL_UCE_INITIALPROGRAM_COMMANDLINE1,
|
|
!IsChecked(IDC_UCE_INITIALPROGRAM_INHERIT));
|
|
|
|
EnableControl(IDL_UCE_INITIALPROGRAM_WORKINGDIRECTORY1,
|
|
!IsChecked(IDC_UCE_INITIALPROGRAM_INHERIT));
|
|
|
|
EnableControl(IDC_UCE_INITIALPROGRAM_COMMANDLINE,
|
|
!IsChecked(IDC_UCE_INITIALPROGRAM_INHERIT));
|
|
|
|
EnableControl(IDC_UCE_INITIALPROGRAM_WORKINGDIRECTORY,
|
|
!IsChecked(IDC_UCE_INITIALPROGRAM_INHERIT));
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL TSConfigDlg::SECURITY_DISABLEAFTERLOGONEvent(WORD /* wNotifyCode */ )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL TSConfigDlg::IsChecked(UINT controlId)
|
|
{
|
|
ASSERT(GetDlgItem(GetDlgHandle(), controlId));
|
|
return BST_CHECKED == SendDlgItemMessage(GetDlgHandle(), controlId, BM_GETCHECK, 0, 0);
|
|
}
|
|
|
|
void TSConfigDlg::SetCheck(UINT controlId, BOOL bCheck)
|
|
{
|
|
ASSERT(GetDlgItem(GetDlgHandle(), controlId));
|
|
SendDlgItemMessage(GetDlgHandle(), controlId, BM_SETCHECK, bCheck ? BST_CHECKED : BST_UNCHECKED, 0);
|
|
}
|
|
|
|
void TSConfigDlg::EnableControl(UINT controlId, BOOL bEnable)
|
|
{
|
|
ASSERT(GetDlgItem(GetDlgHandle(), controlId));
|
|
EnableWindow(GetDlgItem(GetDlgHandle(), controlId), bEnable);
|
|
}
|
|
|
|
int TSConfigDlg::GetComboCurrentSel(UINT controlId)
|
|
{
|
|
ASSERT(GetDlgItem(GetDlgHandle(), controlId));
|
|
return SendDlgItemMessage(GetDlgHandle(), controlId, CB_GETCURSEL, 0, 0);
|
|
}
|
|
|
|
void TSConfigDlg::SetComboCurrentSel(UINT controlId, int iSel)
|
|
{
|
|
ASSERT(GetDlgItem(GetDlgHandle(), controlId));
|
|
SendDlgItemMessage(GetDlgHandle(), controlId, CB_SETCURSEL, iSel, 0);
|
|
}
|