2231 lines
68 KiB
C++
2231 lines
68 KiB
C++
/*******************************************************************************
|
|
*
|
|
* dialogs.cpp
|
|
*
|
|
* implementation of all dialog classes
|
|
*
|
|
* copyright notice: Copyright 1997, Citrix Systems Inc.
|
|
* Copyright (c) 1998 - 1999 Microsoft Corporation
|
|
*
|
|
* $Author: donm $ Don Messerli
|
|
*
|
|
* $Log: N:\nt\private\utils\citrix\winutils\tsadmin\VCS\dialogs.cpp $
|
|
*
|
|
* Rev 1.7 25 Apr 1998 13:43:16 donm
|
|
* MS 2167: try to use proper Wd from registry
|
|
*
|
|
* Rev 1.6 19 Jan 1998 16:46:08 donm
|
|
* new ui behavior for domains and servers
|
|
*
|
|
* Rev 1.5 03 Nov 1997 19:16:10 donm
|
|
* removed redundant message to add server to views
|
|
*
|
|
* Rev 1.4 03 Nov 1997 15:24:16 donm
|
|
* fixed AV in CServerFilterDialog
|
|
*
|
|
* Rev 1.3 22 Oct 1997 21:07:10 donm
|
|
* update
|
|
*
|
|
* Rev 1.2 18 Oct 1997 18:50:10 donm
|
|
* update
|
|
*
|
|
* Rev 1.1 13 Oct 1997 18:40:16 donm
|
|
* update
|
|
*
|
|
* Rev 1.0 30 Jul 1997 17:11:28 butchd
|
|
* Initial revision.
|
|
*
|
|
*******************************************************************************/
|
|
|
|
|
|
#include "stdafx.h"
|
|
#include "afxpriv.h"
|
|
#include "winadmin.h"
|
|
#include "admindoc.h"
|
|
#include "dialogs.h"
|
|
#include "..\..\inc\ansiuni.h"
|
|
|
|
|
|
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSendMessageDlg dialog
|
|
|
|
|
|
CSendMessageDlg::CSendMessageDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CSendMessageDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CSendMessageDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CSendMessageDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CSendMessageDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CSendMessageDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CSendMessageDlg)
|
|
ON_WM_HELPINFO()
|
|
ON_COMMAND(ID_HELP,OnCommandHelp)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CSendMessageDlg message handlers
|
|
void CSendMessageDlg::OnCommandHelp(void)
|
|
{
|
|
AfxGetApp()->WinHelp(CSendMessageDlg::IDD + HID_BASE_RESOURCE);
|
|
return;
|
|
}
|
|
|
|
BOOL CSendMessageDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// TODO: Add extra initialization here
|
|
|
|
// Form the default the message title.
|
|
CString DefTitleString;
|
|
TCHAR szTime[MAX_DATE_TIME_LENGTH];
|
|
|
|
CurrentDateTimeString(szTime);
|
|
DefTitleString.LoadString(IDS_DEFAULT_MESSAGE_TITLE);
|
|
wsprintf(m_szTitle, DefTitleString, ((CWinAdminApp*)AfxGetApp())->GetCurrentUserName(), szTime);
|
|
|
|
// Initialize the title edit control and set maximum length for title
|
|
// and message.
|
|
SetDlgItemText(IDC_MESSAGE_TITLE, m_szTitle);
|
|
((CEdit *)GetDlgItem(IDC_MESSAGE_TITLE))->LimitText(MSG_TITLE_LENGTH);
|
|
((CEdit *)GetDlgItem(IDC_MESSAGE_MESSAGE))->LimitText(MSG_MESSAGE_LENGTH);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CSendMessageDlg::OnOK()
|
|
{
|
|
// TODO: Add extra validation here
|
|
|
|
// Get the message title and message text.
|
|
GetDlgItemText(IDC_MESSAGE_TITLE, m_szTitle, MSG_TITLE_LENGTH+1);
|
|
GetDlgItemText(IDC_MESSAGE_MESSAGE, m_szMessage, MSG_MESSAGE_LENGTH+1);
|
|
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
BOOL CSendMessageDlg::OnHelpInfo(HELPINFO* pHelpInfo)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
//((CWinAdminApp*)AfxGetApp())->WinHelp(HID_BASE_CONTROL + pHelpInfo->iCtrlId, HELP_CONTEXTPOPUP);
|
|
if(pHelpInfo->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
if(pHelpInfo->iCtrlId != IDC_STATIC)
|
|
{
|
|
::WinHelp((HWND)pHelpInfo->hItemHandle,ID_HELP_FILE,HELP_WM_HELP,(ULONG_PTR)(LPVOID)aMenuHelpIDs);
|
|
}
|
|
}
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CShadowStartDlg dialog
|
|
|
|
|
|
CShadowStartDlg::CShadowStartDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CShadowStartDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CShadowStartDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// CShadowStartDlg static tables
|
|
|
|
|
|
|
|
struct {
|
|
LPCTSTR String;
|
|
DWORD VKCode;
|
|
} HotkeyLookupTable[] =
|
|
{
|
|
TEXT("0"), '0',
|
|
TEXT("1"), '1',
|
|
TEXT("2"), '2',
|
|
TEXT("3"), '3',
|
|
TEXT("4"), '4',
|
|
TEXT("5"), '5',
|
|
TEXT("6"), '6',
|
|
TEXT("7"), '7',
|
|
TEXT("8"), '8',
|
|
TEXT("9"), '9',
|
|
TEXT("A"), 'A',
|
|
TEXT("B"), 'B',
|
|
TEXT("C"), 'C',
|
|
TEXT("D"), 'D',
|
|
TEXT("E"), 'E',
|
|
TEXT("F"), 'F',
|
|
TEXT("G"), 'G',
|
|
TEXT("H"), 'H',
|
|
TEXT("I"), 'I',
|
|
TEXT("J"), 'J',
|
|
TEXT("K"), 'K',
|
|
TEXT("L"), 'L',
|
|
TEXT("M"), 'M',
|
|
TEXT("N"), 'N',
|
|
TEXT("O"), 'O',
|
|
TEXT("P"), 'P',
|
|
TEXT("Q"), 'Q',
|
|
TEXT("R"), 'R',
|
|
TEXT("S"), 'S',
|
|
TEXT("T"), 'T',
|
|
TEXT("U"), 'U',
|
|
TEXT("V"), 'V',
|
|
TEXT("W"), 'W',
|
|
TEXT("X"), 'X',
|
|
TEXT("Y"), 'Y',
|
|
TEXT("Z"), 'Z',
|
|
TEXT("{backspace}"), VK_BACK,
|
|
TEXT("{delete}"), VK_DELETE,
|
|
TEXT("{down}"), VK_DOWN,
|
|
TEXT("{end}"), VK_END,
|
|
TEXT("{enter}"), VK_RETURN,
|
|
/// TEXT("{esc}"), VK_ESCAPE, // KLB 07-16-95
|
|
/// TEXT("{F1}"), VK_F1,
|
|
TEXT("{F2}"), VK_F2,
|
|
TEXT("{F3}"), VK_F3,
|
|
TEXT("{F4}"), VK_F4,
|
|
TEXT("{F5}"), VK_F5,
|
|
TEXT("{F6}"), VK_F6,
|
|
TEXT("{F7}"), VK_F7,
|
|
TEXT("{F8}"), VK_F8,
|
|
TEXT("{F9}"), VK_F9,
|
|
TEXT("{F10}"), VK_F10,
|
|
TEXT("{F11}"), VK_F11,
|
|
TEXT("{F12}"), VK_F12,
|
|
TEXT("{home}"), VK_HOME,
|
|
TEXT("{insert}"), VK_INSERT,
|
|
TEXT("{left}"), VK_LEFT,
|
|
TEXT("{-}"), VK_SUBTRACT,
|
|
TEXT("{pagedown}"), VK_NEXT,
|
|
TEXT("{pageup}"), VK_PRIOR,
|
|
TEXT("{+}"), VK_ADD,
|
|
TEXT("{prtscrn}"), VK_SNAPSHOT,
|
|
TEXT("{right}"), VK_RIGHT,
|
|
TEXT("{spacebar}"), VK_SPACE,
|
|
TEXT("{*}"), VK_MULTIPLY,
|
|
TEXT("{tab}"), VK_TAB,
|
|
TEXT("{up}"), VK_UP,
|
|
NULL, NULL
|
|
};
|
|
|
|
|
|
void CShadowStartDlg::OnSelChange( )
|
|
{/*
|
|
*/
|
|
CComboBox *pComboBox = ((CComboBox *)GetDlgItem(IDC_SHADOWSTART_HOTKEY));
|
|
|
|
// Get the current hotkey selection.
|
|
DWORD dwKey = ( DWORD )pComboBox->GetItemData(pComboBox->GetCurSel());
|
|
|
|
switch (dwKey )
|
|
{
|
|
case VK_ADD :
|
|
case VK_MULTIPLY:
|
|
case VK_SUBTRACT:
|
|
// change the text
|
|
GetDlgItem(IDC_PRESS_KEY)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_PRESS_NUMKEYPAD)->ShowWindow(SW_SHOW);
|
|
break;
|
|
default :
|
|
// change the text
|
|
GetDlgItem(IDC_PRESS_NUMKEYPAD)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_PRESS_KEY)->ShowWindow(SW_SHOW);
|
|
break;
|
|
}
|
|
}
|
|
void CShadowStartDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CShadowStartDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CShadowStartDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CShadowStartDlg)
|
|
ON_WM_HELPINFO()
|
|
ON_CBN_SELCHANGE( IDC_SHADOWSTART_HOTKEY , OnSelChange )
|
|
ON_COMMAND(ID_HELP,OnCommandHelp)
|
|
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CShadowStartDlg message handlers
|
|
void CShadowStartDlg::OnCommandHelp(void)
|
|
{
|
|
AfxGetApp()->WinHelp(CShadowStartDlg::IDD + HID_BASE_RESOURCE);
|
|
return;
|
|
}
|
|
|
|
BOOL CShadowStartDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
GetDlgItem(IDC_PRESS_NUMKEYPAD)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_PRESS_KEY)->ShowWindow(SW_SHOW);
|
|
|
|
// TODO: Add extra initialization here
|
|
int index, match = -1;
|
|
CComboBox *pComboBox = ((CComboBox *)GetDlgItem(IDC_SHADOWSTART_HOTKEY));
|
|
|
|
// Initialize the hotkey combo box.
|
|
for(int i=0; HotkeyLookupTable[i].String; i++ ) {
|
|
if((index = pComboBox->AddString(HotkeyLookupTable[i].String)) < 0) {
|
|
// ErrorMessage(IDP_ERROR_STARTSHADOWHOTKEYBOX);
|
|
break;
|
|
}
|
|
if(pComboBox->SetItemData(index, HotkeyLookupTable[i].VKCode) < 0) {
|
|
pComboBox->DeleteString(index);
|
|
// ErrorMessage(IDP_ERROR_STARTSHADOWHOTKEYBOX);
|
|
break;
|
|
}
|
|
|
|
// If this is our current hotkey key, save it's index.
|
|
if(m_ShadowHotkeyKey == (int)HotkeyLookupTable[i].VKCode) {
|
|
match = index;
|
|
switch ( HotkeyLookupTable[i].VKCode)
|
|
{
|
|
case VK_ADD :
|
|
case VK_MULTIPLY:
|
|
case VK_SUBTRACT:
|
|
// change the text
|
|
GetDlgItem(IDC_PRESS_KEY)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_PRESS_NUMKEYPAD)->ShowWindow(SW_SHOW);
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Select the current hotkey string in the combo box.
|
|
if(match)
|
|
pComboBox->SetCurSel(match);
|
|
|
|
// Initialize shift state checkboxes.
|
|
CheckDlgButton( IDC_SHADOWSTART_SHIFT,
|
|
(m_ShadowHotkeyShift & KBDSHIFT) ?
|
|
TRUE : FALSE );
|
|
CheckDlgButton( IDC_SHADOWSTART_CTRL,
|
|
(m_ShadowHotkeyShift & KBDCTRL) ?
|
|
TRUE : FALSE );
|
|
CheckDlgButton( IDC_SHADOWSTART_ALT,
|
|
(m_ShadowHotkeyShift & KBDALT) ?
|
|
TRUE : FALSE );
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
void CShadowStartDlg::OnOK()
|
|
{
|
|
// TODO: Add extra validation here
|
|
CComboBox *pComboBox = ((CComboBox *)GetDlgItem(IDC_SHADOWSTART_HOTKEY));
|
|
|
|
// Get the current hotkey selection.
|
|
m_ShadowHotkeyKey = (int)pComboBox->GetItemData(pComboBox->GetCurSel());
|
|
|
|
// Get shift state checkbox states and form hotkey shift state.
|
|
m_ShadowHotkeyShift = 0;
|
|
m_ShadowHotkeyShift |=
|
|
((CButton *)GetDlgItem(IDC_SHADOWSTART_SHIFT))->GetCheck() ?
|
|
KBDSHIFT : 0;
|
|
m_ShadowHotkeyShift |=
|
|
((CButton *)GetDlgItem(IDC_SHADOWSTART_CTRL))->GetCheck() ?
|
|
KBDCTRL : 0;
|
|
m_ShadowHotkeyShift |=
|
|
((CButton *)GetDlgItem(IDC_SHADOWSTART_ALT))->GetCheck() ?
|
|
KBDALT : 0;
|
|
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
|
|
BOOL CShadowStartDlg::OnHelpInfo(HELPINFO* pHelpInfo)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
//((CWinAdminApp*)AfxGetApp())->WinHelp(HID_BASE_CONTROL + pHelpInfo->iCtrlId, HELP_CONTEXTPOPUP);
|
|
if(pHelpInfo->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
if(pHelpInfo->iCtrlId != IDC_STATIC)
|
|
{
|
|
::WinHelp((HWND)pHelpInfo->hItemHandle,ID_HELP_FILE,HELP_WM_HELP,(ULONG_PTR)(LPVOID)aMenuHelpIDs);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPasswordDlg dialog
|
|
|
|
|
|
CPasswordDlg::CPasswordDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CPasswordDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CPasswordDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CPasswordDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CPasswordDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CPasswordDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CPasswordDlg)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPasswordDlg message handlers
|
|
|
|
BOOL CPasswordDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// TODO: Add extra initialization here
|
|
CString Prompt;
|
|
|
|
Prompt.LoadString((m_DlgMode == PwdDlg_UserMode) ?
|
|
IDS_PWDDLG_USER : IDS_PWDDLG_WINSTATION );
|
|
SetDlgItemText(IDL_CPDLG_PROMPT, Prompt);
|
|
((CEdit *)GetDlgItem(IDC_CPDLG_PASSWORD))->LimitText(PASSWORD_LENGTH);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CPasswordDlg::OnOK()
|
|
{
|
|
// TODO: Add extra validation here
|
|
// Read password.
|
|
GetDlgItemText(IDC_CPDLG_PASSWORD, m_szPassword, PASSWORD_LENGTH+1);
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPreferencesDlg dialog
|
|
|
|
CPreferencesDlg::CPreferencesDlg(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CPreferencesDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CPreferencesDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CPreferencesDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CPreferencesDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CPreferencesDlg)
|
|
ON_BN_CLICKED(IDC_PREFERENCES_PROC_MANUAL, OnPreferencesProcManual)
|
|
ON_BN_CLICKED(IDC_PREFERENCES_PROC_EVERY, OnPreferencesProcEvery)
|
|
ON_BN_CLICKED(IDC_PREFERENCES_STATUS_EVERY, OnPreferencesStatusEvery)
|
|
ON_BN_CLICKED(IDC_PREFERENCES_STATUS_MANUAL, OnPreferencesStatusManual)
|
|
ON_WM_CLOSE()
|
|
ON_WM_HELPINFO()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CPreferencesDlg message handlers
|
|
|
|
|
|
BOOL CPreferencesDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// TODO: Add extra initialization here
|
|
CWinAdminApp *App = (CWinAdminApp*)AfxGetApp();
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)App->GetDocument();
|
|
|
|
if(App->GetProcessListRefreshTime() == INFINITE) {
|
|
CheckRadioButton(IDC_PREFERENCES_PROC_MANUAL, IDC_PREFERENCES_PROC_EVERY,
|
|
IDC_PREFERENCES_PROC_MANUAL);
|
|
SetDlgItemInt(IDC_PREFERENCES_PROC_SECONDS, 5);
|
|
} else {
|
|
CheckRadioButton(IDC_PREFERENCES_PROC_MANUAL, IDC_PREFERENCES_PROC_EVERY,
|
|
IDC_PREFERENCES_PROC_EVERY);
|
|
SetDlgItemInt(IDC_PREFERENCES_PROC_SECONDS, App->GetProcessListRefreshTime()/1000);
|
|
}
|
|
|
|
GetDlgItem(IDC_PREFERENCES_PROC_SECONDS)->EnableWindow((App->GetProcessListRefreshTime() == INFINITE) ? FALSE : TRUE);
|
|
((CEdit *)GetDlgItem(IDC_PREFERENCES_PROC_SECONDS))->LimitText(MAX_AUTOREFRESH_DIGITS-1);
|
|
((CSpinButtonCtrl*)GetDlgItem(IDC_PREFERENCES_PROC_SPIN))->SetRange(MIN_AUTOREFRESH_VALUE, MAX_AUTOREFRESH_VALUE);
|
|
|
|
if(App->GetStatusRefreshTime() == INFINITE) {
|
|
CheckRadioButton(IDC_PREFERENCES_STATUS_MANUAL, IDC_PREFERENCES_STATUS_EVERY,
|
|
IDC_PREFERENCES_STATUS_MANUAL);
|
|
SetDlgItemInt(IDC_PREFERENCES_STATUS_SECONDS, 1);
|
|
} else {
|
|
CheckRadioButton(IDC_PREFERENCES_STATUS_MANUAL, IDC_PREFERENCES_STATUS_EVERY,
|
|
IDC_PREFERENCES_STATUS_EVERY);
|
|
SetDlgItemInt(IDC_PREFERENCES_STATUS_SECONDS, App->GetStatusRefreshTime()/1000);
|
|
}
|
|
|
|
GetDlgItem(IDC_PREFERENCES_STATUS_SECONDS)->EnableWindow((App->GetStatusRefreshTime() == INFINITE) ? FALSE : TRUE);
|
|
((CEdit *)GetDlgItem(IDC_PREFERENCES_STATUS_SECONDS))->LimitText(MAX_AUTOREFRESH_DIGITS-1);
|
|
((CSpinButtonCtrl*)GetDlgItem(IDC_PREFERENCES_STATUS_SPIN))->SetRange(MIN_AUTOREFRESH_VALUE, MAX_AUTOREFRESH_VALUE);
|
|
|
|
CheckDlgButton(IDC_PREFERENCES_CONFIRM, App->AskConfirmation() ? TRUE : FALSE);
|
|
CheckDlgButton(IDC_PREFERENCES_SAVE, App->SavePreferences() ? TRUE : FALSE);
|
|
CheckDlgButton(IDC_PREFERENCES_PERSISTENT, pDoc->AreConnectionsPersistent() ? TRUE : FALSE);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnOK()
|
|
{
|
|
// TODO: Add extra validation here
|
|
CWinAdminApp *App = (CWinAdminApp*)AfxGetApp();
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)App->GetDocument();
|
|
|
|
ULONG value;
|
|
|
|
if(((CButton*)GetDlgItem(IDC_PREFERENCES_PROC_MANUAL))->GetCheck()) {
|
|
App->SetProcessListRefreshTime(INFINITE);
|
|
// Tell the document that it has changed so
|
|
// that he can wakeup the process thread
|
|
((CWinAdminDoc*)App->GetDocument())->ProcessListRefreshChanged(INFINITE);
|
|
} else {
|
|
value = GetDlgItemInt(IDC_PREFERENCES_PROC_SECONDS);
|
|
|
|
if((value < MIN_AUTOREFRESH_VALUE) || (value > MAX_AUTOREFRESH_VALUE)) {
|
|
// Invalid automatic refresh value
|
|
CString MessageString;
|
|
CString TitleString;
|
|
CString FormatString;
|
|
|
|
TitleString.LoadString(AFX_IDS_APP_TITLE);
|
|
FormatString.LoadString(IDS_REFRESH_RANGE);
|
|
|
|
MessageString.Format(FormatString, MIN_AUTOREFRESH_VALUE,
|
|
MAX_AUTOREFRESH_VALUE);
|
|
MessageBox(MessageString, TitleString, MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
GetDlgItem(IDC_PREFERENCES_PROC_SECONDS)->SetFocus();
|
|
return;
|
|
} else {
|
|
// Has the value changed
|
|
BOOL bChanged = FALSE;
|
|
if(value*1000 != App->GetProcessListRefreshTime())
|
|
bChanged = TRUE;
|
|
//Save value in member variable as msec.
|
|
App->SetProcessListRefreshTime(value * 1000);
|
|
// Tell the document that it has changed so
|
|
// that he can wakeup the process thread
|
|
if(bChanged) {
|
|
((CWinAdminDoc*)App->GetDocument())->ProcessListRefreshChanged(value * 1000);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(((CButton*)GetDlgItem(IDC_PREFERENCES_STATUS_MANUAL))->GetCheck()) {
|
|
App->SetStatusRefreshTime(INFINITE);
|
|
} else {
|
|
value = GetDlgItemInt(IDC_PREFERENCES_STATUS_SECONDS);
|
|
|
|
if((value < MIN_AUTOREFRESH_VALUE) || (value > MAX_AUTOREFRESH_VALUE)) {
|
|
// Invalid automatic refresh value
|
|
CString MessageString;
|
|
CString TitleString;
|
|
CString FormatString;
|
|
|
|
TitleString.LoadString(AFX_IDS_APP_TITLE);
|
|
FormatString.LoadString(IDS_REFRESH_RANGE);
|
|
|
|
MessageString.Format(FormatString, MIN_AUTOREFRESH_VALUE,
|
|
MAX_AUTOREFRESH_VALUE);
|
|
MessageBox(MessageString, TitleString, MB_ICONEXCLAMATION | MB_OK);
|
|
|
|
GetDlgItem(IDC_PREFERENCES_STATUS_SECONDS)->SetFocus();
|
|
return;
|
|
} else {
|
|
//Save value in member variable as msec.
|
|
App->SetStatusRefreshTime(value * 1000);
|
|
}
|
|
}
|
|
|
|
App->SetConfirmation(((CButton *)GetDlgItem(IDC_PREFERENCES_CONFIRM))->GetCheck());
|
|
App->SetSavePreferences(((CButton *)GetDlgItem(IDC_PREFERENCES_SAVE))->GetCheck());
|
|
pDoc->SetConnectionsPersistent(((CButton *)GetDlgItem(IDC_PREFERENCES_PERSISTENT))->GetCheck());
|
|
|
|
CDialog::OnOK();
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnClose()
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
|
|
CDialog::OnClose();
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnPreferencesProcManual()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
GetDlgItem(IDC_PREFERENCES_PROC_SECONDS)->EnableWindow(FALSE);
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnPreferencesProcEvery()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
GetDlgItem(IDC_PREFERENCES_PROC_SECONDS)->EnableWindow(TRUE);
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnPreferencesStatusEvery()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
GetDlgItem(IDC_PREFERENCES_STATUS_SECONDS)->EnableWindow(TRUE);
|
|
}
|
|
|
|
|
|
void CPreferencesDlg::OnPreferencesStatusManual()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
GetDlgItem(IDC_PREFERENCES_STATUS_SECONDS)->EnableWindow(FALSE);
|
|
}
|
|
|
|
|
|
BOOL CPreferencesDlg::OnHelpInfo(HELPINFO* pHelpInfo)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
//((CWinAdminApp*)AfxGetApp())->WinHelp(HID_BASE_CONTROL + pHelpInfo->iCtrlId, HELP_CONTEXTPOPUP);
|
|
if(pHelpInfo->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
if(pHelpInfo->iCtrlId != IDC_STATIC)
|
|
{
|
|
::WinHelp((HWND)pHelpInfo->hItemHandle,ID_HELP_FILE,HELP_WM_HELP,(ULONG_PTR)(LPVOID)aMenuHelpIDs);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStatusDlg dialog
|
|
|
|
|
|
CStatusDlg::CStatusDlg(CWinStation *pWinStation, UINT Id, CWnd* pParent /*=NULL*/)
|
|
: CDialog(Id, pParent)
|
|
{
|
|
m_pWinStation = pWinStation;
|
|
//{{AFX_DATA_INIT(CStatusDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CStatusDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CStatusDlg)
|
|
ON_MESSAGE(WM_STATUSSTART, OnStatusStart)
|
|
ON_MESSAGE(WM_STATUSREADY, OnStatusReady)
|
|
ON_MESSAGE(WM_STATUSABORT, OnStatusAbort)
|
|
ON_MESSAGE(WM_STATUSREFRESHNOW, OnRefreshNow)
|
|
ON_BN_CLICKED(IDC_RESETCOUNTERS, OnResetcounters)
|
|
ON_BN_CLICKED(IDC_REFRESHNOW, OnClickedRefreshnow)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CStatusDlg message handlers
|
|
|
|
BOOL CStatusDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// TODO: Add extra initialization here
|
|
|
|
/*
|
|
* Fetch current (big) size of dialog, then calculate the window size
|
|
* needed to show the 'little' version of the dialog. Then, size the
|
|
* window to the little version size and set the size flag to indicate
|
|
* that we're 'little'.
|
|
*/
|
|
RECT rectBigSize, rectLittleSize;
|
|
|
|
GetWindowRect(&rectBigSize);
|
|
m_BigSize.cx = (rectBigSize.right - rectBigSize.left) + 1;
|
|
m_BigSize.cy = (rectBigSize.bottom - rectBigSize.top) + 1;
|
|
|
|
// Some status dialogs don't have "More Info"
|
|
CWnd *pWnd = GetDlgItem(IDC_MOREINFO);
|
|
if(pWnd) {
|
|
pWnd->GetWindowRect(&rectLittleSize);
|
|
|
|
m_LittleSize.cx = m_BigSize.cx;
|
|
m_LittleSize.cy = (rectLittleSize.bottom - rectBigSize.top) + 10;
|
|
|
|
SetWindowPos( NULL, 0, 0, m_LittleSize.cx, m_LittleSize.cy,
|
|
SWP_NOMOVE | SWP_NOZORDER );
|
|
m_bWeAreLittle = TRUE;
|
|
}
|
|
|
|
#if 0
|
|
/*
|
|
* Disable the 'reset counters' button if we're read-only, and set the
|
|
* 'reset counters' flag to FALSE;
|
|
*/
|
|
if ( m_bReadOnly )
|
|
GetDlgItem(IDC_RESETCOUNTERS)->EnableWindow(FALSE);
|
|
|
|
#endif
|
|
/*
|
|
* Create CWSStatusThread, intialize its member variables, and start it up.
|
|
*/
|
|
m_pWSStatusThread = new CWSStatusThread;
|
|
if(m_pWSStatusThread) {
|
|
m_pWSStatusThread->m_LogonId = m_pWinStation->GetLogonId();
|
|
m_pWSStatusThread->m_hServer = m_pWinStation->GetServer()->GetHandle();
|
|
m_pWSStatusThread->m_hDlg = m_hWnd;
|
|
VERIFY(m_pWSStatusThread->CreateThread());
|
|
}
|
|
|
|
m_bResetCounters = FALSE;
|
|
|
|
GetDlgItem(IDC_COMMON_ICOMPRESSIONRATIO2)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_OCOMPRESSIONRATIO2)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_IPERCENTFRAMEERRORS2)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_OPERCENTFRAMEERRORS2)->ShowWindow(SW_HIDE);
|
|
|
|
// If we don't have Reliable Pd loaded, default error fields to 'N/A'
|
|
// (m_szICompressionRatio got initialized to the 'n/a' string)...
|
|
if(!m_bReliable) {
|
|
SetDlgItemText(IDC_COMMON_IFRAMEERRORS, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_OFRAMEERRORS, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_IPERCENTFRAMEERRORS, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_OPERCENTFRAMEERRORS, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_ITIMEOUTERRORS, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_OTIMEOUTERRORS, m_szICompressionRatio);
|
|
}
|
|
|
|
// Default the Compression Ratio fields to 'N/A'.
|
|
SetDlgItemText(IDC_COMMON_ICOMPRESSIONRATIO, m_szICompressionRatio);
|
|
SetDlgItemText(IDC_COMMON_OCOMPRESSIONRATIO, m_szICompressionRatio);
|
|
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
|
|
void CStatusDlg::SetInfoFields( PWINSTATIONINFORMATION pCurrent,
|
|
PWINSTATIONINFORMATION pNew )
|
|
{
|
|
/*
|
|
* If the 'reset counters' flag is set, 1-fill the current Input and Output
|
|
* PROTOCOLCOUNTERS structures (to force all fields to update), copy the
|
|
* pNew PROTOCOLSTATUS information into the global m_BaseStatus structure,
|
|
* and reset the flag.
|
|
*/
|
|
if(m_bResetCounters) {
|
|
memset(&pCurrent->Status.Input, 0xff, sizeof(pCurrent->Status.Input));
|
|
memset(&pCurrent->Status.Output, 0xff, sizeof(pCurrent->Status.Output));
|
|
m_BaseStatus = pNew->Status;
|
|
m_bResetCounters = FALSE;
|
|
}
|
|
|
|
/*
|
|
* Set title and determine Pds loaded if change in connect state.
|
|
*/
|
|
if(pCurrent->ConnectState != pNew->ConnectState) {
|
|
TCHAR szTitle[128];
|
|
CString TitleFormat;
|
|
LPCTSTR pState = NULL;
|
|
|
|
TitleFormat.LoadString(IDS_STATUS_FORMAT);
|
|
|
|
pState = StrConnectState( pNew->ConnectState, FALSE );
|
|
if(pState)
|
|
{
|
|
wsprintf( szTitle, TitleFormat, pNew->LogonId,pState);
|
|
SetWindowText(szTitle);
|
|
}
|
|
|
|
/*
|
|
* TODO when WinStationGetInformation can return all PDs loaded:
|
|
* Determine Pds that are loaded and set the state of
|
|
* associated flags and field defaults.
|
|
*/
|
|
}
|
|
|
|
/*
|
|
* Set UserName and WinStationName if change. We will also
|
|
* set the WinStationName if there was a change in the connect state,
|
|
* even if the WinStationName itself may not have changed, since we
|
|
* represent connected and disconnect WinStationName fields differently.
|
|
*/
|
|
if(lstrcmp(pCurrent->UserName, pNew->UserName))
|
|
SetDlgItemText(IDC_COMMON_USERNAME, pNew->UserName);
|
|
|
|
if(lstrcmp(pCurrent->WinStationName, pNew->WinStationName) ||
|
|
(pCurrent->ConnectState != pNew->ConnectState)) {
|
|
|
|
TCHAR szWSName[WINSTATIONNAME_LENGTH+3];
|
|
|
|
if(pNew->ConnectState == State_Disconnected) {
|
|
|
|
lstrcpy( szWSName, TEXT("(") );
|
|
lstrcat( szWSName, pNew->WinStationName );
|
|
lstrcat( szWSName, TEXT(")") );
|
|
|
|
} else
|
|
lstrcpy( szWSName, pNew->WinStationName );
|
|
|
|
SetDlgItemText(IDC_COMMON_WINSTATIONNAME, szWSName);
|
|
}
|
|
|
|
/*
|
|
* Set the common Input and Output numeric fields.
|
|
*/
|
|
if(pCurrent->Status.Input.Bytes != pNew->Status.Input.Bytes)
|
|
SetDlgItemInt(IDC_COMMON_IBYTES,
|
|
pNew->Status.Input.Bytes -
|
|
m_BaseStatus.Input.Bytes,
|
|
FALSE);
|
|
if(pCurrent->Status.Output.Bytes != pNew->Status.Output.Bytes)
|
|
SetDlgItemInt(IDC_COMMON_OBYTES,
|
|
pNew->Status.Output.Bytes -
|
|
m_BaseStatus.Output.Bytes,
|
|
FALSE);
|
|
|
|
if(pCurrent->Status.Input.Frames != pNew->Status.Input.Frames)
|
|
SetDlgItemInt(IDC_COMMON_IFRAMES,
|
|
pNew->Status.Input.Frames -
|
|
m_BaseStatus.Input.Frames,
|
|
FALSE);
|
|
if(pCurrent->Status.Output.Frames != pNew->Status.Output.Frames)
|
|
SetDlgItemInt(IDC_COMMON_OFRAMES,
|
|
pNew->Status.Output.Frames -
|
|
m_BaseStatus.Output.Frames,
|
|
FALSE);
|
|
|
|
if((pCurrent->Status.Input.Bytes != pNew->Status.Input.Bytes) ||
|
|
(pCurrent->Status.Input.Frames != pNew->Status.Input.Frames)) {
|
|
|
|
UINT temp;
|
|
|
|
temp = (pNew->Status.Input.Frames - m_BaseStatus.Input.Frames) ?
|
|
((pNew->Status.Input.Bytes - m_BaseStatus.Input.Bytes) /
|
|
(pNew->Status.Input.Frames - m_BaseStatus.Input.Frames)) : 0;
|
|
|
|
if(temp != m_IBytesPerFrame)
|
|
SetDlgItemInt(IDC_COMMON_IBYTESPERFRAME,
|
|
m_IBytesPerFrame = temp, FALSE);
|
|
}
|
|
if((pCurrent->Status.Output.Bytes != pNew->Status.Output.Bytes) ||
|
|
(pCurrent->Status.Output.Frames != pNew->Status.Output.Frames)) {
|
|
|
|
UINT temp;
|
|
|
|
temp = (pNew->Status.Output.Frames - m_BaseStatus.Output.Frames) ?
|
|
((pNew->Status.Output.Bytes - m_BaseStatus.Output.Bytes) /
|
|
(pNew->Status.Output.Frames - m_BaseStatus.Output.Frames)) : 0;
|
|
|
|
if(temp != m_OBytesPerFrame)
|
|
SetDlgItemInt( IDC_COMMON_OBYTESPERFRAME,
|
|
m_OBytesPerFrame = temp, FALSE);
|
|
}
|
|
|
|
if(m_bReliable) {
|
|
|
|
if(pCurrent->Status.Input.Errors != pNew->Status.Input.Errors)
|
|
SetDlgItemInt(IDC_COMMON_IFRAMEERRORS,
|
|
pNew->Status.Input.Errors -
|
|
m_BaseStatus.Input.Errors,
|
|
FALSE);
|
|
if(pCurrent->Status.Output.Errors != pNew->Status.Output.Errors)
|
|
SetDlgItemInt(IDC_COMMON_OFRAMEERRORS,
|
|
pNew->Status.Output.Errors -
|
|
m_BaseStatus.Output.Errors,
|
|
FALSE);
|
|
|
|
if((pCurrent->Status.Input.Frames != pNew->Status.Input.Frames) ||
|
|
(pCurrent->Status.Input.Errors != pNew->Status.Input.Errors)) {
|
|
|
|
TCHAR szTemp[10];
|
|
int q, r;
|
|
|
|
if((pNew->Status.Input.Errors - m_BaseStatus.Input.Errors) &&
|
|
(pNew->Status.Input.Frames - m_BaseStatus.Input.Frames)) {
|
|
double temp;
|
|
|
|
temp = ((double)(pNew->Status.Input.Errors - m_BaseStatus.Input.Errors) * 100.0)
|
|
/ (double)(pNew->Status.Input.Frames - m_BaseStatus.Input.Frames);
|
|
q = (int)temp;
|
|
if ( (r = (int)((temp - (double)q) * 100.0)) == 0 )
|
|
r = 1;
|
|
|
|
} else {
|
|
/*
|
|
* Special case for 0 frames or 0 errors.
|
|
*/
|
|
q = 0;
|
|
r = 0;
|
|
}
|
|
lstrnprintf(szTemp, 10, TEXT("%d.%02d%%"), q, r);
|
|
|
|
/*
|
|
* Only output if changed from previous.
|
|
*/
|
|
if(lstrcmp(szTemp, m_szIPercentFrameErrors)) {
|
|
lstrcpy(m_szIPercentFrameErrors, szTemp);
|
|
GetDlgItem(IDC_COMMON_IPERCENTFRAMEERRORS)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_IPERCENTFRAMEERRORS2)->ShowWindow(SW_SHOW);
|
|
SetDlgItemText(IDC_COMMON_IPERCENTFRAMEERRORS2, szTemp);
|
|
}
|
|
}
|
|
|
|
if((pCurrent->Status.Output.Frames != pNew->Status.Output.Frames) ||
|
|
(pCurrent->Status.Output.Errors != pNew->Status.Output.Errors)) {
|
|
|
|
TCHAR szTemp[10];
|
|
int q, r;
|
|
|
|
if((pNew->Status.Output.Errors - m_BaseStatus.Output.Errors) &&
|
|
(pNew->Status.Output.Frames - m_BaseStatus.Output.Frames)) {
|
|
double temp;
|
|
|
|
temp = ((double)(pNew->Status.Output.Errors - m_BaseStatus.Output.Errors) * 100.0)
|
|
/ (double)(pNew->Status.Output.Frames - m_BaseStatus.Output.Frames);
|
|
q = (int)temp;
|
|
if ( (r = (int)((temp - (double)q) * 100.0)) == 0 )
|
|
r = 1;
|
|
|
|
} else {
|
|
/*
|
|
* Special case for 0 frames or 0 errors.
|
|
*/
|
|
q = 0;
|
|
r = 0;
|
|
}
|
|
lstrnprintf(szTemp, 10, TEXT("%d.%02d%%"), q, r);
|
|
|
|
/*
|
|
* Only output if changed from previous.
|
|
*/
|
|
if(lstrcmp(szTemp, m_szOPercentFrameErrors)) {
|
|
lstrcpy(m_szOPercentFrameErrors, szTemp);
|
|
GetDlgItem(IDC_COMMON_OPERCENTFRAMEERRORS)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_OPERCENTFRAMEERRORS2)->ShowWindow(SW_SHOW);
|
|
SetDlgItemText(IDC_COMMON_OPERCENTFRAMEERRORS2, szTemp);
|
|
}
|
|
}
|
|
|
|
if(pCurrent->Status.Input.Timeouts != pNew->Status.Input.Timeouts)
|
|
SetDlgItemInt(IDC_COMMON_ITIMEOUTERRORS,
|
|
pNew->Status.Input.Timeouts -
|
|
m_BaseStatus.Input.Timeouts,
|
|
FALSE);
|
|
if(pCurrent->Status.Output.Timeouts != pNew->Status.Output.Timeouts)
|
|
SetDlgItemInt(IDC_COMMON_OTIMEOUTERRORS,
|
|
pNew->Status.Output.Timeouts -
|
|
m_BaseStatus.Output.Timeouts,
|
|
FALSE);
|
|
}
|
|
|
|
/*
|
|
* NOTE: for these compression ratio calculations, the "CompressedBytes" field is
|
|
* actually 'Bytes before compression', that is, it is the byte count in the middle
|
|
* of the WD/PD stack. "WdBytes" are the bytes input/output at the app level (and is
|
|
* not displayed in any WinAdmin counters). "CompressedBytes" include any overhead
|
|
* bytes added by the stack. "Bytes" represent the actual number of bytes input/output
|
|
* over the 'wire'; hence, we use Bytes for all counter display and "CompressedBytes" to
|
|
* calculate compression ratios.
|
|
*/
|
|
if((pNew->Status.Input.CompressedBytes || m_BaseStatus.Input.CompressedBytes) &&
|
|
((pCurrent->Status.Input.Bytes != pNew->Status.Input.Bytes) ||
|
|
(pCurrent->Status.Input.CompressedBytes != pNew->Status.Input.CompressedBytes)) ) {
|
|
|
|
TCHAR szTemp[10];
|
|
int q, r;
|
|
|
|
if((pNew->Status.Input.CompressedBytes - m_BaseStatus.Input.CompressedBytes)) {
|
|
double temp;
|
|
|
|
temp = (double)(pNew->Status.Input.CompressedBytes -
|
|
m_BaseStatus.Input.CompressedBytes) /
|
|
(double)(pNew->Status.Input.Bytes - m_BaseStatus.Input.Bytes);
|
|
q = (int)temp;
|
|
r = (int)((temp - (double)q) * 100.0);
|
|
|
|
} else {
|
|
/*
|
|
* Special case for 0 compressed bytes (compression turned off or counters reset).
|
|
*/
|
|
q = 0;
|
|
r = 0;
|
|
}
|
|
lstrnprintf(szTemp, 10, TEXT("%d.%02d"), q, r);
|
|
|
|
/*
|
|
* Only output if changed from previous.
|
|
*/
|
|
if(lstrcmp(szTemp, m_szICompressionRatio)) {
|
|
lstrcpy(m_szICompressionRatio, szTemp);
|
|
GetDlgItem(IDC_COMMON_ICOMPRESSIONRATIO)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_ICOMPRESSIONRATIO2)->ShowWindow(SW_SHOW);
|
|
SetDlgItemText(IDC_COMMON_ICOMPRESSIONRATIO2, szTemp);
|
|
}
|
|
}
|
|
|
|
if((pNew->Status.Output.CompressedBytes || m_BaseStatus.Output.CompressedBytes) &&
|
|
((pCurrent->Status.Output.Bytes != pNew->Status.Output.Bytes) ||
|
|
(pCurrent->Status.Output.CompressedBytes != pNew->Status.Output.CompressedBytes))) {
|
|
|
|
TCHAR szTemp[10];
|
|
int q, r;
|
|
|
|
if((pNew->Status.Output.CompressedBytes - m_BaseStatus.Output.CompressedBytes)) {
|
|
double temp;
|
|
|
|
temp = (double)(pNew->Status.Output.CompressedBytes -
|
|
m_BaseStatus.Output.CompressedBytes) /
|
|
(double)(pNew->Status.Output.Bytes - m_BaseStatus.Output.Bytes);
|
|
q = (int)temp;
|
|
r = (int)((temp - (double)q) * 100.0);
|
|
|
|
} else {
|
|
/*
|
|
* Special case for 0 compressed bytes (compression turned off or counters reset).
|
|
*/
|
|
q = 0;
|
|
r = 0;
|
|
}
|
|
lstrnprintf(szTemp, 10, TEXT("%d.%02d"), q, r);
|
|
|
|
/*
|
|
* Only output if changed from previous.
|
|
*/
|
|
if(lstrcmp(szTemp, m_szOCompressionRatio)) {
|
|
lstrcpy(m_szOCompressionRatio, szTemp);
|
|
GetDlgItem(IDC_COMMON_OCOMPRESSIONRATIO)->ShowWindow(SW_HIDE);
|
|
GetDlgItem(IDC_COMMON_OCOMPRESSIONRATIO2)->ShowWindow(SW_SHOW);
|
|
SetDlgItemText(IDC_COMMON_OCOMPRESSIONRATIO2, szTemp);
|
|
}
|
|
}
|
|
|
|
} // end CStatusDlg::SetInfoFields
|
|
|
|
|
|
void CStatusDlg::InitializeStatus()
|
|
{
|
|
|
|
// Initialize structures and variables.
|
|
memset( &m_WSInfo, 0xff, sizeof(m_WSInfo) );
|
|
memset( &m_BaseStatus, 0, sizeof(m_BaseStatus) );
|
|
m_IBytesPerFrame = m_OBytesPerFrame = INFINITE;
|
|
lstrcpy(m_szICompressionRatio, TEXT("n/a"));
|
|
lstrcpy(m_szOCompressionRatio, m_szICompressionRatio);
|
|
|
|
// If this WinStation does not have a Reliable PD loaded,
|
|
// set flag to skip those counters.
|
|
PDPARAMS PdParams;
|
|
ULONG ReturnLength;
|
|
|
|
PdParams.SdClass = SdReliable;
|
|
if (!WinStationQueryInformation(m_pWinStation->GetServer()->GetHandle(),
|
|
m_pWinStation->GetLogonId(),
|
|
WinStationPdParams,
|
|
&PdParams, sizeof(PdParams),
|
|
&ReturnLength ) ||
|
|
(PdParams.SdClass != SdReliable) ) {
|
|
m_bReliable = FALSE;
|
|
} else {
|
|
m_bReliable = TRUE;
|
|
}
|
|
|
|
} // end CStatusDlg::InitializeStatus
|
|
|
|
void CStatusDlg::OnCancel()
|
|
{
|
|
// TODO: Add extra cleanup here
|
|
m_pWSStatusThread->ExitThread();
|
|
CDialog::OnCancel();
|
|
}
|
|
|
|
void CStatusDlg::OnResetcounters()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
m_bResetCounters = TRUE;
|
|
OnClickedRefreshnow();
|
|
|
|
}
|
|
|
|
void CStatusDlg::OnClickedRefreshnow()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
// return(0);
|
|
|
|
}
|
|
|
|
|
|
void CStatusDlg::PostNcDestroy()
|
|
{
|
|
CDialog::PostNcDestroy();
|
|
|
|
delete this;
|
|
}
|
|
|
|
BOOL CStatusDlg::PreTranslateMessage(MSG *pMsg)
|
|
{
|
|
if ( IsDialogMessage(pMsg) )
|
|
return(TRUE);
|
|
else
|
|
return( CDialog::PreTranslateMessage(pMsg) );
|
|
|
|
} // end CStatusDlg::PreTranslateMessage
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnRefreshNow - CWSStatusDlg member function: command
|
|
*
|
|
* Processes in response to main frame's WM_STATUSREFRESHNOW notification
|
|
* that the user has changed the status refresh options.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CStatusDlg::OnRefreshNow( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnRefreshNow
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusStart - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSSTART message to initialize the 'static'
|
|
* PD-related fields.
|
|
*
|
|
* NOTE: the derived class must override this function to process any
|
|
* PD-related fields as necessary, then call / return this function.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) returns the result of the OnStatusReady member function,
|
|
* which is always 0, indicating operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CStatusDlg::OnStatusStart( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Call / return the OnStatusReady function to update the standard dialog
|
|
* info fields.
|
|
*/
|
|
return ( OnStatusReady( wParam, lParam ) );
|
|
|
|
} // end CWSStatusDlg::OnStatusStart
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusReady - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSREADY message to update the dialog Info fields.
|
|
*
|
|
* NOTE: the derived class must override this function to call it's
|
|
* override of the SetInfoFields function, which could then call / return
|
|
* this function or completely override all functionality contained here.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CStatusDlg::OnStatusReady( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Update dialog fields with information from the CWStatusThread's
|
|
* WINSTATIONINFORMATION structure.
|
|
*/
|
|
SetInfoFields( &m_WSInfo, &(m_pWSStatusThread->m_WSInfo) );
|
|
|
|
/*
|
|
* Set our working WSInfo structure to the new one and signal the thread
|
|
* that we're done.
|
|
*/
|
|
m_WSInfo = m_pWSStatusThread->m_WSInfo;
|
|
m_pWSStatusThread->SignalConsumed();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnStatusReady
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusAbort - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSABORT message to exit the thread and dialog.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CStatusDlg::OnStatusAbort( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Call the OnCancel() member function to exit dialog and thread and
|
|
* perform proper cleanup.
|
|
*/
|
|
OnCancel();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnStatusAbort
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAsyncStatusDlg dialog
|
|
|
|
|
|
CAsyncStatusDlg::CAsyncStatusDlg(CWinStation *pWinStation, CWnd* pParent /*=NULL*/)
|
|
: CStatusDlg(pWinStation, CAsyncStatusDlg::IDD, pParent),
|
|
m_hRedBrush(NULL),
|
|
m_LEDToggleTimer(0)
|
|
{
|
|
//{{AFX_DATA_INIT(CAsyncStatusDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
int i;
|
|
|
|
/*
|
|
* Initialize member variables, our local status storage,
|
|
* and create a modeless dialog.
|
|
*/
|
|
// m_LogonId = LogonId;
|
|
// m_bReadOnly = bReadOnly;
|
|
InitializeStatus();
|
|
|
|
/*
|
|
* Create a solid RED brush for painting the 'LED's when 'on'.
|
|
*/
|
|
VERIFY( m_hRedBrush = CreateSolidBrush(RGB(255,0,0)) );
|
|
|
|
/*
|
|
* Create the led objects (must do BEFORE dialog create).
|
|
*/
|
|
for ( i = 0; i < NUM_LEDS; i++ )
|
|
m_pLeds[i] = new CLed(m_hRedBrush);
|
|
|
|
/*
|
|
* Finally, create the modeless dialog.
|
|
*/
|
|
VERIFY(CStatusDlg::Create(IDD_ASYNC_STATUS));
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* ~CAsyncStatusDlg - CAsyncStatusDlg destructor
|
|
*
|
|
* ENTRY:
|
|
* EXIT:
|
|
* (Refer to MFC CDialog::~CDialog documentation)
|
|
*
|
|
******************************************************************************/
|
|
|
|
CAsyncStatusDlg::~CAsyncStatusDlg()
|
|
{
|
|
int i;
|
|
|
|
/*
|
|
* Zap our led objects.
|
|
*/
|
|
for ( i = 0; i < NUM_LEDS; i++ )
|
|
if ( m_pLeds[i] )
|
|
delete m_pLeds[i];
|
|
|
|
} // end CAsyncStatusDlg::~CAsyncStatusDlg
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* InitializeStatus - CAsyncStatusDlg member function: override
|
|
*
|
|
* Special case reset of the LED states in the WINSTATIONINFORMATION
|
|
* status structure.
|
|
*
|
|
* ENTRY:
|
|
* EXIT:
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
CAsyncStatusDlg::InitializeStatus()
|
|
{
|
|
/*
|
|
* Call the parent classes' InitializeStatus(), then reset the 'LED'
|
|
* states to all 'off' & 'not toggled'.
|
|
*/
|
|
CStatusDlg::InitializeStatus();
|
|
m_WSInfo.Status.AsyncSignal = m_WSInfo.Status.AsyncSignalMask = 0;
|
|
|
|
} // end CAsyncStatusDlg::InitializeStatus
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* SetInfoFields - CAsyncStatusDlg member function: override
|
|
*
|
|
* Update the fields in the dialog with new data, if necessary.
|
|
*
|
|
* ENTRY:
|
|
* pCurrent (input)
|
|
* points to WINSTATIONINFORMATION structure containing the current
|
|
* dialog data.
|
|
* pNew (input)
|
|
* points to WINSTATIONINFORMATION structure containing the new
|
|
* dialog data.
|
|
*
|
|
* EXIT:
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
CAsyncStatusDlg::SetInfoFields( PWINSTATIONINFORMATION pCurrent,
|
|
PWINSTATIONINFORMATION pNew )
|
|
{
|
|
BOOL bSetTimer = FALSE;
|
|
|
|
/*
|
|
* Call the parent's SetInfoFields().
|
|
*/
|
|
CStatusDlg::SetInfoFields( pCurrent, pNew );
|
|
|
|
/*
|
|
* Set new LED states if state change, or set up for quick toggle if
|
|
* no state changed, but change(s) were detected since last query.
|
|
*/
|
|
if ( (pCurrent->Status.AsyncSignal & MS_DTR_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_DTR_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_DTR;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DTR))->
|
|
Update(pNew->Status.AsyncSignal & MS_DTR_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_DTR ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_DTR_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DTR))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
if ( (pCurrent->Status.AsyncSignal & MS_RTS_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_RTS_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_RTS;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RTS))->
|
|
Update(pNew->Status.AsyncSignal & MS_RTS_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_RTS ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_RTS_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RTS))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
if ( (pCurrent->Status.AsyncSignal & MS_CTS_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_CTS_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_CTS;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_CTS))->
|
|
Update(pNew->Status.AsyncSignal & MS_CTS_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_CTS ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_CTS_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_CTS))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
if ( (pCurrent->Status.AsyncSignal & MS_RLSD_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_RLSD_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_RLSD;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DCD))->
|
|
Update(pNew->Status.AsyncSignal & MS_RLSD_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_RLSD ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_RLSD_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DCD))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
if ( (pCurrent->Status.AsyncSignal & MS_DSR_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_DSR_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_DSR;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DSR))->
|
|
Update(pNew->Status.AsyncSignal & MS_DSR_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_DSR ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_DSR_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DSR))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
if ( (pCurrent->Status.AsyncSignal & MS_RING_ON) !=
|
|
(pNew->Status.AsyncSignal & MS_RING_ON) ) {
|
|
|
|
pNew->Status.AsyncSignalMask &= ~EV_RING;
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RI))->
|
|
Update(pNew->Status.AsyncSignal & MS_RING_ON);
|
|
|
|
} else if ( pNew->Status.AsyncSignalMask & EV_RING ) {
|
|
|
|
pCurrent->Status.AsyncSignal ^= MS_RING_ON;
|
|
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RI))->Toggle();
|
|
|
|
bSetTimer = TRUE;
|
|
}
|
|
|
|
/*
|
|
* Create our led toggle timer if needed.
|
|
*/
|
|
if ( bSetTimer && !m_LEDToggleTimer )
|
|
m_LEDToggleTimer = SetTimer( IDD_ASYNC_STATUS,
|
|
ASYNC_LED_TOGGLE_MSEC, NULL );
|
|
|
|
/*
|
|
* Set ASYNC-specific numeric fields if change.
|
|
*/
|
|
if ( pCurrent->Status.Input.AsyncFramingError != pNew->Status.Input.AsyncFramingError )
|
|
SetDlgItemInt( IDC_ASYNC_IFRAMING,
|
|
pNew->Status.Input.AsyncFramingError - m_BaseStatus.Input.AsyncFramingError,
|
|
FALSE );
|
|
if ( pCurrent->Status.Output.AsyncFramingError != pNew->Status.Output.AsyncFramingError )
|
|
SetDlgItemInt( IDC_ASYNC_OFRAMING,
|
|
pNew->Status.Output.AsyncFramingError - m_BaseStatus.Output.AsyncFramingError,
|
|
FALSE );
|
|
|
|
if ( pCurrent->Status.Input.AsyncOverrunError != pNew->Status.Input.AsyncOverrunError )
|
|
SetDlgItemInt( IDC_ASYNC_IOVERRUN,
|
|
pNew->Status.Input.AsyncOverrunError - m_BaseStatus.Input.AsyncOverrunError,
|
|
FALSE );
|
|
if ( pCurrent->Status.Output.AsyncOverrunError != pNew->Status.Output.AsyncOverrunError )
|
|
SetDlgItemInt( IDC_ASYNC_OOVERRUN,
|
|
pNew->Status.Output.AsyncOverrunError - m_BaseStatus.Output.AsyncOverrunError,
|
|
FALSE );
|
|
|
|
if ( pCurrent->Status.Input.AsyncOverflowError != pNew->Status.Input.AsyncOverflowError )
|
|
SetDlgItemInt( IDC_ASYNC_IOVERFLOW,
|
|
pNew->Status.Input.AsyncOverflowError - m_BaseStatus.Input.AsyncOverflowError,
|
|
FALSE );
|
|
if ( pCurrent->Status.Output.AsyncOverflowError != pNew->Status.Output.AsyncOverflowError )
|
|
SetDlgItemInt( IDC_ASYNC_OOVERFLOW,
|
|
pNew->Status.Output.AsyncOverflowError - m_BaseStatus.Output.AsyncOverflowError,
|
|
FALSE );
|
|
|
|
if ( pCurrent->Status.Input.AsyncParityError != pNew->Status.Input.AsyncParityError )
|
|
SetDlgItemInt( IDC_ASYNC_IPARITY,
|
|
pNew->Status.Input.AsyncParityError - m_BaseStatus.Input.AsyncParityError,
|
|
FALSE );
|
|
if ( pCurrent->Status.Output.AsyncParityError != pNew->Status.Output.AsyncParityError )
|
|
SetDlgItemInt( IDC_ASYNC_OPARITY,
|
|
pNew->Status.Output.AsyncParityError - m_BaseStatus.Output.AsyncParityError,
|
|
FALSE );
|
|
|
|
} // end CAsyncStatusDlg::SetInfoFields
|
|
|
|
|
|
void CAsyncStatusDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CAsyncStatusDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CAsyncStatusDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CAsyncStatusDlg)
|
|
ON_MESSAGE(WM_STATUSSTART, OnStatusStart)
|
|
ON_MESSAGE(WM_STATUSREADY, OnStatusReady)
|
|
ON_MESSAGE(WM_STATUSABORT, OnStatusAbort)
|
|
ON_MESSAGE(WM_STATUSREFRESHNOW, OnRefreshNow)
|
|
ON_BN_CLICKED(IDC_RESETCOUNTERS, OnResetcounters)
|
|
ON_BN_CLICKED(IDC_REFRESHNOW, OnClickedRefreshnow)
|
|
ON_BN_CLICKED(IDC_MOREINFO, OnMoreinfo)
|
|
ON_WM_TIMER()
|
|
ON_WM_NCDESTROY()
|
|
ON_WM_HELPINFO()
|
|
ON_COMMAND(ID_HELP,OnCommandHelp)
|
|
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CAsyncStatusDlg message handlers
|
|
/*******************************************************************************
|
|
*
|
|
* OnInitDialog - CAsyncStatusDlg member function: command (override)
|
|
*
|
|
* Performs async-specific dialog intialization.
|
|
*
|
|
* ENTRY:
|
|
* EXIT:
|
|
* (Refer to CDialog::OnInitDialog documentation)
|
|
*
|
|
******************************************************************************/
|
|
static int LedIds[NUM_LEDS] = {
|
|
IDC_ASYNC_DTR,
|
|
IDC_ASYNC_RTS,
|
|
IDC_ASYNC_CTS,
|
|
IDC_ASYNC_DSR,
|
|
IDC_ASYNC_DCD,
|
|
IDC_ASYNC_RI };
|
|
|
|
BOOL CAsyncStatusDlg::OnInitDialog()
|
|
{
|
|
int i;
|
|
|
|
/*
|
|
* Perform parent's OnInitDialog() first.
|
|
*/
|
|
CStatusDlg::OnInitDialog();
|
|
|
|
/*
|
|
* Subclass the led controls and default to 'off'.
|
|
*/
|
|
for ( i = 0; i < NUM_LEDS; i++ ) {
|
|
m_pLeds[i]->Subclass( (CStatic *)GetDlgItem(LedIds[i]) );
|
|
m_pLeds[i]->Update(0);
|
|
}
|
|
|
|
return(TRUE);
|
|
|
|
} // end CAsyncStatusDlg::OnInitDialog
|
|
|
|
void CAsyncStatusDlg::OnCommandHelp(void)
|
|
{
|
|
AfxGetApp()->WinHelp(CAsyncStatusDlg::IDD + HID_BASE_RESOURCE);
|
|
return;
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusStart - CAsyncStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSSTART message to initialize the 'static'
|
|
* PD-related fields.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CAsyncStatusDlg::OnStatusStart( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Fetch the PD-specific information from the CWStatusThread's PDCONFIG
|
|
* structure and initialize dialog fields.
|
|
*/
|
|
SetDlgItemText( IDC_ASYNC_DEVICE,
|
|
m_pWSStatusThread->m_PdConfig.Params.Async.DeviceName );
|
|
SetDlgItemInt( IDC_ASYNC_BAUD,
|
|
m_pWSStatusThread->m_PdConfig.Params.Async.BaudRate,
|
|
FALSE );
|
|
|
|
/*
|
|
* Call / return our OnStatusReady() function.
|
|
*/
|
|
return ( OnStatusReady( wParam, lParam ) );
|
|
|
|
} // end CAsyncStatusDlg::OnStatusStart
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusReady - CAsyncStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSREADY message to update the dialog Info fields.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CAsyncStatusDlg::OnStatusReady( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* If the LED toggle timer is still active now, kill it and flag so.
|
|
*/
|
|
if ( m_LEDToggleTimer ) {
|
|
|
|
KillTimer(m_LEDToggleTimer);
|
|
m_LEDToggleTimer = 0;
|
|
}
|
|
|
|
/*
|
|
* Call / return the parent classes' OnStatusReady() function.
|
|
*/
|
|
return (CStatusDlg::OnStatusReady( wParam, lParam ));
|
|
|
|
} // end CAsyncStatusDlg::OnStatusReady
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnTimer - CAsyncStatusDlg member function: command (override)
|
|
*
|
|
* Used for quick 'LED toggle'.
|
|
*
|
|
* ENTRY:
|
|
* EXIT:
|
|
* (Refer to CWnd::OnTimer documentation)
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
CAsyncStatusDlg::OnTimer(UINT nIDEvent)
|
|
{
|
|
/*
|
|
* Process this timer event if it it our 'LED toggle' event.
|
|
*/
|
|
if ( nIDEvent == m_LEDToggleTimer ) {
|
|
|
|
/*
|
|
* Toggle each led that is flagged as 'changed'.
|
|
*/
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_DTR )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DTR))->Toggle();
|
|
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_RTS )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RTS))->Toggle();
|
|
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_CTS )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_CTS))->Toggle();
|
|
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_RLSD )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DCD))->Toggle();
|
|
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_DSR )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_DSR))->Toggle();
|
|
|
|
if ( m_WSInfo.Status.AsyncSignalMask & EV_RING )
|
|
((CLed *)GetDlgItem(IDC_ASYNC_RI))->Toggle();
|
|
|
|
/*
|
|
* Kill this timer event and indicate so.
|
|
*/
|
|
KillTimer(m_LEDToggleTimer);
|
|
m_LEDToggleTimer = 0;
|
|
|
|
} else
|
|
CDialog::OnTimer(nIDEvent);
|
|
|
|
} // end CAsyncStatusDlg::OnTimer
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnNcDestroy - CAsyncStatusDlg member function: command
|
|
*
|
|
* Clean up before deleting dialog object.
|
|
*
|
|
* ENTRY:
|
|
* EXIT:
|
|
* (Refer to CWnd::OnNcDestroy documentation)
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
CAsyncStatusDlg::OnNcDestroy()
|
|
{
|
|
/*
|
|
* Delete the red brush we made.
|
|
*/
|
|
DeleteObject(m_hRedBrush);
|
|
|
|
/*
|
|
* If the LED toggle timer is still active, kill it.
|
|
*/
|
|
if ( m_LEDToggleTimer )
|
|
KillTimer(m_LEDToggleTimer);
|
|
|
|
/*
|
|
* Call parent after we've cleaned up.
|
|
*/
|
|
CStatusDlg::OnNcDestroy();
|
|
|
|
} // end CAsyncStatusDlg::OnNcDestroy
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusAbort - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSABORT message to exit the thread and dialog.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CAsyncStatusDlg::OnStatusAbort( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Call the OnCancel() member function to exit dialog and thread and
|
|
* perform proper cleanup.
|
|
*/
|
|
OnCancel();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnStatusAbort
|
|
|
|
|
|
void CAsyncStatusDlg::OnResetcounters()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
m_bResetCounters = TRUE;
|
|
OnClickedRefreshnow();
|
|
|
|
}
|
|
|
|
void CAsyncStatusDlg::OnClickedRefreshnow()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
// return(0);
|
|
|
|
}
|
|
|
|
void CAsyncStatusDlg::OnMoreinfo()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
CString ButtonText;
|
|
|
|
if(m_bWeAreLittle) {
|
|
// We are now little size: go to big size.
|
|
SetWindowPos(NULL, 0, 0, m_BigSize.cx, m_BigSize.cy,
|
|
SWP_NOMOVE | SWP_NOZORDER);
|
|
|
|
ButtonText.LoadString(IDS_LESSINFO);
|
|
SetDlgItemText(IDC_MOREINFO, ButtonText);
|
|
|
|
m_bWeAreLittle = FALSE;
|
|
|
|
} else {
|
|
// We are now big size: go to little size.
|
|
SetWindowPos( NULL, 0, 0, m_LittleSize.cx, m_LittleSize.cy,
|
|
SWP_NOMOVE | SWP_NOZORDER);
|
|
|
|
ButtonText.LoadString(IDS_MOREINFO);
|
|
SetDlgItemText(IDC_MOREINFO, ButtonText);
|
|
|
|
m_bWeAreLittle = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnRefreshNow - CWSStatusDlg member function: command
|
|
*
|
|
* Processes in response to main frame's WM_STATUSREFRESHNOW notification
|
|
* that the user has changed the status refresh options.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CAsyncStatusDlg::OnRefreshNow( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnRefreshNow
|
|
|
|
|
|
BOOL CAsyncStatusDlg::OnHelpInfo(HELPINFO* pHelpInfo)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
//((CWinAdminApp*)AfxGetApp())->WinHelp(HID_BASE_CONTROL + pHelpInfo->iCtrlId, HELP_CONTEXTPOPUP);
|
|
if(pHelpInfo->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
if(pHelpInfo->iCtrlId != IDC_STATIC)
|
|
{
|
|
::WinHelp((HWND)pHelpInfo->hItemHandle,ID_HELP_FILE,HELP_WM_HELP,(ULONG_PTR)(LPVOID)aMenuHelpIDs);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CNetworkStatusDlg dialog
|
|
|
|
|
|
CNetworkStatusDlg::CNetworkStatusDlg(CWinStation *pWinStation, CWnd* pParent /*=NULL*/)
|
|
: CStatusDlg(pWinStation, CNetworkStatusDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CNetworkStatusDlg)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
|
|
InitializeStatus();
|
|
|
|
VERIFY( CStatusDlg::Create(IDD_NETWORK_STATUS) );
|
|
}
|
|
|
|
|
|
void CNetworkStatusDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CNetworkStatusDlg)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CNetworkStatusDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CNetworkStatusDlg)
|
|
ON_MESSAGE(WM_STATUSSTART, OnStatusStart)
|
|
ON_MESSAGE(WM_STATUSREADY, OnStatusReady)
|
|
ON_MESSAGE(WM_STATUSABORT, OnStatusAbort)
|
|
ON_MESSAGE(WM_STATUSREFRESHNOW, OnRefreshNow)
|
|
ON_BN_CLICKED(IDC_RESETCOUNTERS, OnResetcounters)
|
|
ON_BN_CLICKED(IDC_REFRESHNOW, OnClickedRefreshnow)
|
|
ON_BN_CLICKED(IDC_MOREINFO, OnMoreinfo)
|
|
ON_WM_HELPINFO()
|
|
ON_COMMAND(ID_HELP,OnCommandHelp)
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CNetworkStatusDlg message handlers
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusStart - CNetworkStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSSTART message to initialize the 'static'
|
|
* PD-related fields.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CNetworkStatusDlg::OnStatusStart( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
DEVICENAME DeviceName;
|
|
PDCONFIG3 PdConfig3;
|
|
LONG Status;
|
|
ULONG ByteCount;
|
|
HANDLE hServer;
|
|
|
|
CWinAdminDoc *pDoc = (CWinAdminDoc*)((CWinAdminApp*)AfxGetApp())->GetDocument();
|
|
if(pDoc->IsInShutdown()) return 0;
|
|
|
|
if(m_pWinStation->GetSdClass() == SdOemTransport) {
|
|
CString LabelString;
|
|
LabelString.LoadString(IDS_DEVICE);
|
|
SetDlgItemText(IDC_LABEL, LabelString);
|
|
|
|
ULONG Length;
|
|
PDCONFIG PdConfig;
|
|
|
|
if(Status = WinStationQueryInformation(m_pWinStation->GetServer()->GetHandle(),
|
|
m_pWinStation->GetLogonId(),
|
|
WinStationPd,
|
|
&PdConfig,
|
|
sizeof(PDCONFIG),
|
|
&Length)) {
|
|
wcscpy(DeviceName, PdConfig.Params.OemTd.DeviceName);
|
|
}
|
|
} else {
|
|
/*
|
|
* Fetch the registry configuration for the PD specified in the
|
|
* CWStatusThread's PDCONFIG structure and initialize dialog fields.
|
|
*/
|
|
hServer = RegOpenServer(m_pWinStation->GetServer()->IsCurrentServer() ? NULL : m_pWinStation->GetServer()->GetName());
|
|
|
|
PWDNAME pWdRegistryName = m_pWinStation->GetWdRegistryName();
|
|
|
|
if (!pWdRegistryName || (Status = RegPdQuery(hServer,
|
|
pWdRegistryName,
|
|
TRUE,
|
|
m_pWSStatusThread->m_PdConfig.Create.PdName,
|
|
&PdConfig3, sizeof(PDCONFIG3), &ByteCount)) ) {
|
|
|
|
// We don't currently look at the registry names on remote servers.
|
|
// If ICA is in use on the remote server and not on this server,
|
|
// we won't have a registry name - try "wdica" and "icawd"
|
|
if(m_pWinStation->IsICA()) {
|
|
if(Status = RegPdQuery(hServer,
|
|
TEXT("icawd"),
|
|
TRUE,
|
|
m_pWSStatusThread->m_PdConfig.Create.PdName,
|
|
&PdConfig3, sizeof(PDCONFIG3), &ByteCount) ) {
|
|
|
|
Status = RegPdQuery(hServer,
|
|
TEXT("wdica"),
|
|
TRUE,
|
|
m_pWSStatusThread->m_PdConfig.Create.PdName,
|
|
&PdConfig3, sizeof(PDCONFIG3), &ByteCount);
|
|
}
|
|
}
|
|
|
|
if(Status) memset(&PdConfig3, 0, sizeof(PDCONFIG3));
|
|
}
|
|
|
|
ULONG Length = 0;
|
|
PWSTR pLanAdapter = NULL;
|
|
//
|
|
// Try the new interface first (NT5 server ?)
|
|
//
|
|
if (WinStationGetLanAdapterName(m_pWinStation->GetServer()->GetHandle(),
|
|
m_pWSStatusThread->m_PdConfig.Params.Network.LanAdapter,
|
|
(lstrlen(m_pWSStatusThread->m_PdConfig.Create.PdName) + 1) * sizeof(WCHAR),
|
|
m_pWSStatusThread->m_PdConfig.Create.PdName,
|
|
&Length,
|
|
&pLanAdapter))
|
|
{
|
|
//NT5 Server
|
|
SetDlgItemText( IDC_NETWORK_LANADAPTER, pLanAdapter );
|
|
if(pLanAdapter)
|
|
{
|
|
WinStationFreeMemory(pLanAdapter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Check the return code indicating that the interface is not available.
|
|
//
|
|
DWORD dwError = GetLastError();
|
|
if (dwError != RPC_S_PROCNUM_OUT_OF_RANGE)
|
|
{
|
|
//Error getting Name.
|
|
SetDlgItemText( IDC_NETWORK_LANADAPTER, GetUnknownString());
|
|
}
|
|
else // maybe a Hydra 4 server ?
|
|
{
|
|
|
|
if (RegGetNetworkDeviceName(hServer, &PdConfig3, &(m_pWSStatusThread->m_PdConfig.Params),
|
|
DeviceName, DEVICENAME_LENGTH +1 ) == ERROR_SUCCESS)
|
|
{
|
|
SetDlgItemText( IDC_NETWORK_LANADAPTER, DeviceName );
|
|
|
|
}
|
|
else
|
|
{
|
|
//Error
|
|
SetDlgItemText( IDC_NETWORK_LANADAPTER, GetUnknownString());
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseServer(hServer);
|
|
}
|
|
|
|
/*
|
|
* Call / return parent classes' OnStatusStart().
|
|
*/
|
|
return ( CStatusDlg::OnStatusStart( wParam, lParam ) );
|
|
|
|
} // end CNetworkStatusDlg::OnStatusStart
|
|
|
|
|
|
void CNetworkStatusDlg::OnResetcounters()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
m_bResetCounters = TRUE;
|
|
OnClickedRefreshnow();
|
|
|
|
}
|
|
|
|
void CNetworkStatusDlg::OnClickedRefreshnow()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
// return(0);
|
|
|
|
}
|
|
|
|
void CNetworkStatusDlg::OnMoreinfo()
|
|
{
|
|
// TODO: Add your control notification handler code here
|
|
|
|
}
|
|
void CNetworkStatusDlg::OnCommandHelp(void)
|
|
{
|
|
AfxGetApp()->WinHelp(CNetworkStatusDlg::IDD + HID_BASE_RESOURCE);
|
|
return;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnRefreshNow - CWSStatusDlg member function: command
|
|
*
|
|
* Processes in response to main frame's WM_STATUSREFRESHNOW notification
|
|
* that the user has changed the status refresh options.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CNetworkStatusDlg::OnRefreshNow( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Tell the status thread to wake up now.
|
|
*/
|
|
m_pWSStatusThread->SignalWakeUp();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnRefreshNow
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusReady - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSREADY message to update the dialog Info fields.
|
|
*
|
|
* NOTE: the derived class must override this function to call it's
|
|
* override of the SetInfoFields function, which could then call / return
|
|
* this function or completely override all functionality contained here.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CNetworkStatusDlg::OnStatusReady( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Update dialog fields with information from the CWStatusThread's
|
|
* WINSTATIONINFORMATION structure.
|
|
*/
|
|
SetInfoFields( &m_WSInfo, &(m_pWSStatusThread->m_WSInfo) );
|
|
|
|
/*
|
|
* Set our working WSInfo structure to the new one and signal the thread
|
|
* that we're done.
|
|
*/
|
|
m_WSInfo = m_pWSStatusThread->m_WSInfo;
|
|
m_pWSStatusThread->SignalConsumed();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnStatusReady
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* OnStatusAbort - CWSStatusDlg member function: command
|
|
*
|
|
* Process the WM_STATUSABORT message to exit the thread and dialog.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* EXIT:
|
|
* (LRESULT) always returns 0 to indicate operation complete.
|
|
*
|
|
******************************************************************************/
|
|
|
|
LRESULT
|
|
CNetworkStatusDlg::OnStatusAbort( WPARAM wParam,
|
|
LPARAM lParam )
|
|
{
|
|
/*
|
|
* Call the OnCancel() member function to exit dialog and thread and
|
|
* perform proper cleanup.
|
|
*/
|
|
OnCancel();
|
|
|
|
return(0);
|
|
|
|
} // end CWSStatusDlg::OnStatusAbort
|
|
|
|
|
|
BOOL CNetworkStatusDlg::OnHelpInfo(HELPINFO* pHelpInfo)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
//((CWinAdminApp*)AfxGetApp())->WinHelp(HID_BASE_CONTROL + pHelpInfo->iCtrlId, HELP_CONTEXTPOPUP);
|
|
if(pHelpInfo->iContextType == HELPINFO_WINDOW)
|
|
{
|
|
if(pHelpInfo->iCtrlId != IDC_STATIC)
|
|
{
|
|
::WinHelp((HWND)pHelpInfo->hItemHandle,ID_HELP_FILE,HELP_WM_HELP,(ULONG_PTR)(LPVOID)aMenuHelpIDs);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
CMyDialog::CMyDialog(CWnd* pParent /*=NULL*/)
|
|
: CDialog(CMyDialog::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CMyDialog)
|
|
m_cstrServerName = _T("");
|
|
//}}AFX_DATA_INIT
|
|
}
|
|
|
|
|
|
void CMyDialog::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CMyDialog)
|
|
DDX_Text(pDX, IDC_EDIT_FINDSERVER, m_cstrServerName);
|
|
DDV_MaxChars(pDX, m_cstrServerName, 256);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CMyDialog, CDialog)
|
|
//{{AFX_MSG_MAP(CMyDialog)
|
|
// NOTE: the ClassWizard will add message map macros here
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
|
|
|