/******************************************************************************* * * 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()