able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/sdktools/verifier/win2k/vsetpage.cxx

1078 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//
// Driver Verifier UI
// Copyright (c) Microsoft Corporation, 1999
//
//
// module: VSetPage.cxx
// author: DMihai
// created: 07/07/99
//
// Description:
//
// Volatile settings PropertyPage.
#include "stdafx.h"
#include "drvvctrl.hxx"
#include "VSetPage.hxx"
#include "DrvCSht.hxx"
#include <Cderr.h>
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
// timer ID
#define REFRESH_TIMER_ID 0x1324
// manual, high, normal, low speed
#define REFRESH_SPEED_VARS 4
// timer intervals in millisec for manual, high, normal, low speed
static UINT uTimerIntervals[ REFRESH_SPEED_VARS ] =
{
0, // Manual
1000, // High Speed
5000, // Normal Speed
10000 // Low Speed
};
//
// help IDs
//
static DWORD MyHelpIds[] =
{
IDC_VSETTINGS_DRIVERS_LIST, IDH_DV_VolatileTab_driver_details,
IDC_VSETTINGS_NORMAL_VERIF_CHECK, IDH_DV_SettingsTab_verifytype_sppool,
IDC_VSETTINGS_PAGEDC_VERIF_CHECK, IDH_DV_SettingsTab_verifytype_irql,
IDC_VSETTINGS_ALLOCF_VERIF_CHECK, IDH_DV_SettingsTab_verifytype_resource,
IDC_VSETTINGS_APPLY_BUTTON, IDH_DV_VolatileTab_Applybut,
IDC_VSETTINGS_ADD_BUTTON, IDH_DV_VolatileTab_Addbut,
IDC_VSETTINGS_DONTVERIFY_BUTTON, IDH_DV_VolatileTab_Removebut,
IDC_VSETTINGS_REFRESH_BUTTON, IDH_DV_common_refresh_nowbutton,
IDC_VSETTINGS_MANUAL_RADIO, IDH_DV_common_refresh_manual,
IDC_VSETTINGS_HSPEED_RADIO, IDH_DV_common_refresh_high,
IDC_VSETTINGS_NORM_RADIO, IDH_DV_common_refresh_normal,
IDC_VSETTINGS_LOW_RADIO, IDH_DV_common_refresh_low,
0, 0
};
/////////////////////////////////////////////////////////////
// CVolatileSettPage property page
IMPLEMENT_DYNCREATE(CVolatileSettPage, CPropertyPage)
CVolatileSettPage::CVolatileSettPage() : CPropertyPage(CVolatileSettPage::IDD)
{
//{{AFX_DATA_INIT(CVolatileSettPage)
m_nUpdateIntervalIndex = 2;
m_bAllocFCheck = FALSE;
m_bNormalCheck = FALSE;
m_bPagedCCheck = FALSE;
//}}AFX_DATA_INIT
m_bAscendDrvNameSort = FALSE;
m_bAscendDrvStatusSort = FALSE;
m_uTimerHandler = 0;
m_nSortColumnIndex = 0;
m_eApplyButtonState = vrfControlDisabled;
m_bTimerBlocked = FALSE;
}
CVolatileSettPage::~CVolatileSettPage()
{
}
void CVolatileSettPage::DoDataExchange(CDataExchange* pDX)
{
if( ! pDX->m_bSaveAndValidate )
{
// query the kernel
KrnGetSystemVerifierState( &m_KrnVerifState );
}
CPropertyPage::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CVolatileSettPage)
DDX_Control(pDX, IDC_VSETTINGS_DRIVERS_LIST, m_DriversList);
DDX_Control(pDX, IDC_VSETTINGS_PAGEDC_VERIF_CHECK, m_PagedCCheck);
DDX_Control(pDX, IDC_VSETTINGS_NORMAL_VERIF_CHECK, m_NormalVerifCheck);
DDX_Control(pDX, IDC_VSETTINGS_ALLOCF_VERIF_CHECK, m_AllocFCheck);
DDX_Control(pDX, IDC_VSETTINGS_APPLY_BUTTON, m_ApplyButton);
DDX_Radio(pDX, IDC_VSETTINGS_MANUAL_RADIO, m_nUpdateIntervalIndex);
//}}AFX_DATA_MAP
if( pDX->m_bSaveAndValidate )
{
DDX_Check(pDX, IDC_VSETTINGS_NORMAL_VERIF_CHECK, m_bNormalCheck);
DDX_Check(pDX, IDC_VSETTINGS_PAGEDC_VERIF_CHECK, m_bPagedCCheck);
DDX_Check(pDX, IDC_VSETTINGS_ALLOCF_VERIF_CHECK, m_bAllocFCheck);
}
}
BEGIN_MESSAGE_MAP(CVolatileSettPage, CPropertyPage)
//{{AFX_MSG_MAP(CVolatileSettPage)
ON_BN_CLICKED(IDC_VSETTINGS_REFRESH_BUTTON, OnCrtstatRefreshButton)
ON_NOTIFY(LVN_COLUMNCLICK, IDC_VSETTINGS_DRIVERS_LIST, OnColumnclickCrtstatDriversList)
ON_WM_TIMER()
ON_BN_CLICKED(IDC_VSETTINGS_HSPEED_RADIO, OnCrtstatHspeedRadio)
ON_BN_CLICKED(IDC_VSETTINGS_LOW_RADIO, OnCrtstatLowRadio)
ON_BN_CLICKED(IDC_VSETTINGS_MANUAL_RADIO, OnCrtstatManualRadio)
ON_BN_CLICKED(IDC_VSETTINGS_NORM_RADIO, OnCrtstatNormRadio)
ON_BN_CLICKED(IDC_VSETTINGS_APPLY_BUTTON, OnApplyButton)
ON_BN_CLICKED(IDC_VSETTINGS_ALLOCF_VERIF_CHECK, OnCheck )
ON_BN_CLICKED(IDC_VSETTINGS_ADD_BUTTON, OnAddButton)
ON_BN_CLICKED(IDC_VSETTINGS_DONTVERIFY_BUTTON, OnDontVerifyButton)
ON_BN_CLICKED(IDC_VSETTINGS_NORMAL_VERIF_CHECK, OnCheck )
ON_BN_CLICKED(IDC_VSETTINGS_PAGEDC_VERIF_CHECK, OnCheck )
ON_NOTIFY(NM_RCLICK, IDC_VSETTINGS_DRIVERS_LIST, OnRclickDriversList)
ON_COMMAND(ID_VOLATILE_ADD_DRIVERS, OnAddButton)
ON_COMMAND(ID_VOLATILE_REMOVE_DRIVERS, OnDontVerifyButton)
ON_MESSAGE( WM_HELP, OnHelp )
ON_MESSAGE( WM_CONTEXTMENU, OnContextMenu )
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
void CVolatileSettPage::UpdateControlsState()
{
EnableControl( m_ApplyButton, m_eApplyButtonState );
}
/////////////////////////////////////////////////////////////////////////////
void CVolatileSettPage::EnableControl( CWnd &wndCtrl,
VRF_CONTROL_STATE eNewState )
{
BOOL bEnabled = wndCtrl.IsWindowEnabled();
if( bEnabled )
{
if( eNewState == vrfControlDisabled )
wndCtrl.EnableWindow( FALSE );
}
else
{
if( eNewState == vrfControlEnabled )
wndCtrl.EnableWindow( TRUE );
}
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::SetupListHeader()
{
CString strDrivers, strStatus;
VERIFY( strDrivers.LoadString( IDS_DRIVERS ) );
VERIFY( strStatus.LoadString( IDS_STATUS ) );
// list's regtangle
CRect rectWnd;
m_DriversList.GetClientRect( &rectWnd );
LVCOLUMN lvColumn;
// column 0
memset( &lvColumn, 0, sizeof( lvColumn ) );
lvColumn.mask = LVCF_FMT | LVCF_SUBITEM | LVCF_TEXT | LVCF_WIDTH;
lvColumn.fmt = LVCFMT_LEFT;
lvColumn.iSubItem = 0;
lvColumn.pszText = strDrivers.GetBuffer( strDrivers.GetLength() + 1 );
lvColumn.cx = (int)( rectWnd.Width() * 0.47 );
VERIFY( m_DriversList.InsertColumn( 0, &lvColumn ) != -1 );
strDrivers.ReleaseBuffer();
// column 1
lvColumn.iSubItem = 1;
lvColumn.pszText = strStatus.GetBuffer( strStatus.GetLength() + 1 );
lvColumn.cx = (int)( rectWnd.Width() * 0.47 );
VERIFY( m_DriversList.InsertColumn( 1, &lvColumn ) != -1 );
strStatus.ReleaseBuffer();
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::FillTheList()
{
LVITEM lvItem;
int nActualIndex;
BOOL *pbAlreadyInList;
ULONG uCrtVerifiedDriver;
int nItemCount;
int nCrtListItem;
TCHAR strDriverName[ _MAX_PATH ];
BOOL bResult;
if( m_KrnVerifState.DriverCount == 0 )
{
//
// clear the list
//
VERIFY( m_DriversList.DeleteAllItems() );
}
else
{
//
// there are some drivers currently verified
//
pbAlreadyInList = new BOOL[ m_KrnVerifState.DriverCount ];
if( pbAlreadyInList == NULL )
{
return;
}
for( uCrtVerifiedDriver = 0; uCrtVerifiedDriver < m_KrnVerifState.DriverCount; uCrtVerifiedDriver++)
{
pbAlreadyInList[ uCrtVerifiedDriver ] = FALSE;
}
//
// parse all the current list items
//
nItemCount = m_DriversList.GetItemCount();
for( nCrtListItem = 0; nCrtListItem < nItemCount; nCrtListItem++ )
{
//
// get the current driver's name from the list
//
ZeroMemory( &lvItem, sizeof( lvItem ) );
lvItem.mask = LVIF_TEXT;
lvItem.iItem = nCrtListItem;
lvItem.iSubItem = 0;
lvItem.pszText = strDriverName;
lvItem.cchTextMax = sizeof( strDriverName ) / sizeof( strDriverName[0] );
bResult = m_DriversList.GetItem( &lvItem );
if( bResult == FALSE )
{
//
// could not get the current item's attributes?
//
ASSERT( FALSE );
//
// remove this item from the list
//
VERIFY( m_DriversList.DeleteItem( nCrtListItem ) );
nCrtListItem--;
nItemCount--;
}
else
{
//
// see is the current driver is still in m_KrnVerifState
//
for( uCrtVerifiedDriver = 0; uCrtVerifiedDriver < m_KrnVerifState.DriverCount; uCrtVerifiedDriver++)
{
if( _tcsicmp( strDriverName,
m_KrnVerifState.DriverInfo[ uCrtVerifiedDriver ].Name ) == 0 )
{
//
// update the item's data with the current index in the array
//
lvItem.mask = LVIF_PARAM;
lvItem.lParam = uCrtVerifiedDriver;
VERIFY( m_DriversList.SetItem( &lvItem ) != -1 );
//
// update the second column
//
UpdateStatusColumn( nCrtListItem, uCrtVerifiedDriver );
//
// mark the current driver as updated
//
pbAlreadyInList[ uCrtVerifiedDriver ] = TRUE;
break;
}
}
//
// If the driver is no longer verified, remove it from the list
//
if( uCrtVerifiedDriver >= m_KrnVerifState.DriverCount )
{
VERIFY( m_DriversList.DeleteItem( nCrtListItem ) );
nCrtListItem--;
nItemCount--;
}
}
}
//
// add the drivers that were not in the list before this update
//
for( uCrtVerifiedDriver = 0; uCrtVerifiedDriver < m_KrnVerifState.DriverCount; uCrtVerifiedDriver++)
{
if( ! pbAlreadyInList[ uCrtVerifiedDriver ] )
{
//
// add a new item for this
//
ZeroMemory( &lvItem, sizeof( lvItem ) );
//
// sub-item 0
//
lvItem.mask = LVIF_TEXT | LVIF_PARAM;
lvItem.lParam = uCrtVerifiedDriver;
lvItem.iItem = m_DriversList.GetItemCount();
lvItem.iSubItem = 0;
lvItem.pszText = m_KrnVerifState.DriverInfo[ uCrtVerifiedDriver ].Name;
nActualIndex = m_DriversList.InsertItem( &lvItem );
VERIFY( nActualIndex != -1 );
//
// sub-item 1
//
UpdateStatusColumn( nActualIndex, uCrtVerifiedDriver );
}
}
delete pbAlreadyInList;
}
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::UpdateStatusColumn( int nItemIndex, ULONG uCrtDriver )
{
LVITEM lvItem;
CString strStatus;
ASSERT( nItemIndex >= 0 &&
(UINT)nItemIndex < m_KrnVerifState.DriverCount &&
nItemIndex < m_DriversList.GetItemCount() &&
uCrtDriver >= 0 &&
uCrtDriver < m_KrnVerifState.DriverCount &&
uCrtDriver < (ULONG)m_DriversList.GetItemCount() );
// determine what's the appropriate value for the second column
if( ! m_KrnVerifState.DriverInfo[ uCrtDriver ].Loads )
{
VERIFY( strStatus.LoadString( IDS_NEVER_LOADED ) );
}
else
{
if( m_KrnVerifState.DriverInfo[ uCrtDriver ].Loads ==
m_KrnVerifState.DriverInfo[ uCrtDriver ].Unloads )
{
VERIFY( strStatus.LoadString( IDS_UNLOADED ) );
}
else
{
if( m_KrnVerifState.DriverInfo[ uCrtDriver ].Loads >
m_KrnVerifState.DriverInfo[ uCrtDriver ].Unloads )
{
VERIFY( strStatus.LoadString( IDS_LOADED ) );
}
else
{
ASSERT( FALSE );
VERIFY( strStatus.LoadString( IDS_UNKNOWN ) );
}
}
}
// update the list item
memset( &lvItem, 0, sizeof( lvItem ) );
lvItem.mask = LVIF_TEXT;
lvItem.iItem = nItemIndex;
lvItem.iSubItem = 1;
lvItem.pszText = strStatus.GetBuffer( strStatus.GetLength() + 1 );
VERIFY( m_DriversList.SetItem( &lvItem ) != -1 );
strStatus.ReleaseBuffer();
}
/////////////////////////////////////////////////////////////
int CALLBACK CVolatileSettPage::DrvStatusCmpFunc(
LPARAM lParam1,
LPARAM lParam2,
LPARAM lParamSort)
{
UINT uIndex1 = (UINT)lParam1;
UINT uIndex2 = (UINT)lParam2;
CVolatileSettPage *pThis = (CVolatileSettPage *)lParamSort;
ASSERT_VALID( pThis );
int nCmpRez = 0;
// sanity check
if( uIndex1 > pThis->m_KrnVerifState.DriverCount ||
uIndex2 > pThis->m_KrnVerifState.DriverCount )
{
ASSERT( FALSE );
return 0;
}
// difference between loads and unloads #
LONG lLoadDiff1 = (LONG)pThis->m_KrnVerifState.DriverInfo[ uIndex1 ].Loads -
(LONG)pThis->m_KrnVerifState.DriverInfo[ uIndex1 ].Unloads;
LONG lLoadDiff2 = (LONG)pThis->m_KrnVerifState.DriverInfo[ uIndex2 ].Loads -
(LONG)pThis->m_KrnVerifState.DriverInfo[ uIndex2 ].Unloads;
if( lLoadDiff1 == lLoadDiff2 )
{
nCmpRez = 0;
}
else
{
if( lLoadDiff1 > lLoadDiff2 )
nCmpRez = 1;
else
nCmpRez = -1;
}
if( pThis->m_bAscendDrvStatusSort )
nCmpRez *= -1;
return nCmpRez;
}
/////////////////////////////////////////////////////////////
int CALLBACK CVolatileSettPage::DrvNameCmpFunc(
LPARAM lParam1,
LPARAM lParam2,
LPARAM lParamSort)
{
UINT uIndex1 = (UINT)lParam1;
UINT uIndex2 = (UINT)lParam2;
CVolatileSettPage *pThis = (CVolatileSettPage *)lParamSort;
ASSERT_VALID( pThis );
int nCmpRez = 0;
// sanity check
if( uIndex1 > pThis->m_KrnVerifState.DriverCount ||
uIndex2 > pThis->m_KrnVerifState.DriverCount )
{
ASSERT( FALSE );
return 0;
}
nCmpRez = _tcsicmp( pThis->m_KrnVerifState.DriverInfo[ uIndex1 ].Name,
pThis->m_KrnVerifState.DriverInfo[ uIndex2 ].Name );
if( ! nCmpRez )
{
// same name ???
nCmpRez = 0;
}
else
{
if( pThis->m_bAscendDrvNameSort )
nCmpRez *= -1;
}
return nCmpRez;
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnRefreshTimerChanged()
{
UINT uTimerElapse = 0;
// kill the pending timer
if( m_uTimerHandler != 0 )
{
VERIFY( KillTimer( REFRESH_TIMER_ID ) );
}
// sanity check
if( m_nUpdateIntervalIndex < 0 ||
m_nUpdateIntervalIndex >= REFRESH_SPEED_VARS )
{
m_nUpdateIntervalIndex = 0;
CheckRadioButton( IDC_VSETTINGS_MANUAL_RADIO, IDC_VSETTINGS_LOW_RADIO,
IDC_VSETTINGS_MANUAL_RADIO );
}
// new timer interval
uTimerElapse = uTimerIntervals[ m_nUpdateIntervalIndex ];
if( uTimerElapse > 0 )
{
VERIFY( m_uTimerHandler = SetTimer( REFRESH_TIMER_ID,
uTimerElapse, NULL ) );
}
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::SortTheList()
{
if( m_nSortColumnIndex )
{
m_DriversList.SortItems( DrvStatusCmpFunc, (LPARAM)this );
}
else
{
m_DriversList.SortItems( DrvNameCmpFunc, (LPARAM)this );
}
}
/////////////////////////////////////////////////////////////
// CVolatileSettPage message handlers
BOOL CVolatileSettPage::OnInitDialog()
{
CPropertyPage::OnInitDialog();
//
// set the checkboxes state
//
if( KrnGetSystemVerifierState( &m_KrnVerifState ) &&
m_KrnVerifState.DriverCount > 0 )
{
m_NormalVerifCheck.SetCheck( m_KrnVerifState.SpecialPool );
m_PagedCCheck.SetCheck( m_KrnVerifState.IrqlChecking );
m_AllocFCheck.SetCheck( m_KrnVerifState.FaultInjection );
}
//
// see if we can modify options on the fly
//
if( g_OsVersion.dwMajorVersion < 5 || g_OsVersion.dwBuildNumber < 2055 )
{
m_NormalVerifCheck.EnableWindow( FALSE );
m_PagedCCheck.EnableWindow( FALSE );
m_AllocFCheck.EnableWindow( FALSE );
}
//
// setup the list
//
SetupListHeader();
FillTheList();
SortTheList();
OnRefreshTimerChanged();
UpdateControlsState();
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnCrtstatRefreshButton()
{
if( UpdateData( FALSE ) )
{
FillTheList();
SortTheList();
}
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnColumnclickCrtstatDriversList(NMHDR* pNMHDR,
LRESULT* pResult)
{
NM_LISTVIEW* pNMListView = (NM_LISTVIEW*)pNMHDR;
if( pNMListView->iSubItem )
{
if( m_nSortColumnIndex == pNMListView->iSubItem )
{
// change the current ascend/descend order for this column
m_bAscendDrvStatusSort = !m_bAscendDrvStatusSort;
}
}
else
{
if( m_nSortColumnIndex == pNMListView->iSubItem )
{
// change the current ascend/descend order for this column
m_bAscendDrvNameSort = !m_bAscendDrvNameSort;
}
}
m_nSortColumnIndex = pNMListView->iSubItem;
SortTheList();
*pResult = 0;
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnRclickDriversList(NMHDR* pNMHDR, LRESULT* pResult)
{
POINT point;
CMenu theMenu, *pTrackedMenu = NULL;
BOOL bShowRemoveMenuItem = FALSE;
int nItems = m_DriversList.GetItemCount();
for(int nCrtItem = 0; nCrtItem < nItems; nCrtItem++ )
{
if( m_DriversList.GetItemState( nCrtItem, LVIS_SELECTED ) &
LVIS_SELECTED )
{
bShowRemoveMenuItem = TRUE;
}
}
if( bShowRemoveMenuItem )
{
VERIFY( theMenu.LoadMenu( IDM_ADD_REMOVE_DRIVERS ) );
}
else
{
VERIFY( theMenu.LoadMenu( IDM_ADD_DRIVERS ) );
}
pTrackedMenu = theMenu.GetSubMenu( 0 );
if( pTrackedMenu != NULL )
{
ASSERT_VALID( pTrackedMenu );
VERIFY( ::GetCursorPos( &point ) );
VERIFY( pTrackedMenu->TrackPopupMenu(
TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON,
point.x, point.y,
this ) );
}
else
{
ASSERT( FALSE );
}
*pResult = 0;
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnTimer(UINT nIDEvent)
{
if( m_bTimerBlocked != TRUE && nIDEvent == REFRESH_TIMER_ID )
{
CDrvChkSheet *pParentSheet = (CDrvChkSheet *)GetParent();
if( pParentSheet != NULL )
{
ASSERT_VALID( pParentSheet );
if( pParentSheet->GetActivePage() == this )
{
// refresh the displayed data
OnCrtstatRefreshButton();
}
}
}
CPropertyPage::OnTimer(nIDEvent);
}
/////////////////////////////////////////////////////////////////////////////
void CVolatileSettPage::OnCheck()
{
m_eApplyButtonState = vrfControlEnabled;
UpdateControlsState();
}
/////////////////////////////////////////////////////////////////////////////
void CVolatileSettPage::OnApplyButton()
{
if( ApplyTheChanges() )
{
m_eApplyButtonState = vrfControlDisabled;
UpdateControlsState();
}
}
/////////////////////////////////////////////////////////////////////////////
BOOL CVolatileSettPage::ApplyTheChanges()
{
if( UpdateData( TRUE ) )
{
return VrfSetVolatileOptions(
m_bNormalCheck,
m_bPagedCCheck,
m_bAllocFCheck );
}
return FALSE;
}
/////////////////////////////////////////////////////////////
BOOL CVolatileSettPage::OnQueryCancel()
{
// give parent PropertySheet a chance to refuse the Cancel if needed
CDrvChkSheet *pParentSheet = (CDrvChkSheet *)GetParent();
if( pParentSheet != NULL )
{
ASSERT_VALID( pParentSheet );
if( ! pParentSheet->OnQueryCancel() )
{
return FALSE;
}
}
return CPropertyPage::OnQueryCancel();
}
/////////////////////////////////////////////////////////////
BOOL CVolatileSettPage::OnApply()
{
// refuse to apply
// (we don't use the standard PropertSheet buttons; Apply, OK)
return FALSE;
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnCrtstatManualRadio()
{
// switch to manual refresh
m_nUpdateIntervalIndex = 0;
OnRefreshTimerChanged();
}
void CVolatileSettPage::OnCrtstatHspeedRadio()
{
// switch to high speed refresh
m_nUpdateIntervalIndex = 1;
OnRefreshTimerChanged();
}
void CVolatileSettPage::OnCrtstatNormRadio()
{
// switch to normal speed refresh
m_nUpdateIntervalIndex = 2;
OnRefreshTimerChanged();
}
void CVolatileSettPage::OnCrtstatLowRadio()
{
// switch to low speed refresh
m_nUpdateIntervalIndex = 3;
OnRefreshTimerChanged();
}
/////////////////////////////////////////////////////////////
#define VRF_MAX_CHARS_FOR_OPEN 4096
void CVolatileSettPage::OnAddButton()
{
static BOOL bChangedDirectory = FALSE;
POSITION pos;
BOOL bEnabledSome = FALSE;
DWORD dwRetValue;
DWORD dwOldMaxFileName = 0;
DWORD dwErrorCode;
int nFileNameStartIndex;
INT_PTR nResult;
TCHAR szDriversDir[ _MAX_PATH ];
TCHAR szAppTitle[ _MAX_PATH ];
TCHAR *szFilesBuffer = NULL;
TCHAR *szOldFilesBuffer = NULL;
CString strPathName;
CString strFileName;
CFileDialog fileDlg(
TRUE, // open file
_T( "sys" ), // default extension
NULL, // no initial file name
OFN_ALLOWMULTISELECT | // multiple selection
OFN_HIDEREADONLY | // hide the "open read-only" checkbox
OFN_NONETWORKBUTTON | // no network button
OFN_NOTESTFILECREATE | // don't test for write protection, a full disk, etc.
OFN_SHAREAWARE, // don't check the existance of file with OpenFile
_T( "Drivers (*.sys)|*.sys||" ) ); // only one filter
//
// check the max length for the returned string
//
if( fileDlg.m_ofn.nMaxFile < VRF_MAX_CHARS_FOR_OPEN )
{
//
// allocate a new buffer for the file names
//
szFilesBuffer = new TCHAR[ VRF_MAX_CHARS_FOR_OPEN ];
szFilesBuffer[ 0 ] = (TCHAR)0;
if( szFilesBuffer != NULL )
{
//
// Save the old buffer address and length
//
dwOldMaxFileName = fileDlg.m_ofn.nMaxFile;
szOldFilesBuffer = fileDlg.m_ofn.lpstrFile;
//
// Set the new buffer address and length
//
fileDlg.m_ofn.lpstrFile = szFilesBuffer;
fileDlg.m_ofn.nMaxFile = VRF_MAX_CHARS_FOR_OPEN;
}
}
//
// Dialog title
//
if( GetStringFromResources(
IDS_APPTITLE,
szAppTitle,
ARRAY_LENGTH( szAppTitle ) ) )
{
fileDlg.m_ofn.lpstrTitle = szAppTitle;
}
//
// We change directory first time we try this to %windir%\system32\drivers
//
if( bChangedDirectory == FALSE )
{
dwRetValue = ExpandEnvironmentStrings(
_T( "%windir%\\system32\\drivers" ),
szDriversDir,
ARRAY_LENGTH( szDriversDir ) );
if( dwRetValue > 0 && dwRetValue <= ARRAY_LENGTH( szDriversDir ) )
{
fileDlg.m_ofn.lpstrInitialDir = szDriversDir;
}
bChangedDirectory = TRUE;
}
//
// show the file selection dialog
//
nResult = fileDlg.DoModal();
switch( nResult )
{
case IDOK:
break;
case IDCANCEL:
goto cleanup;
default:
dwErrorCode = CommDlgExtendedError();
if( dwErrorCode == FNERR_BUFFERTOOSMALL )
{
VrfErrorResourceFormat(
IDS_TOO_MANY_FILES_SELECTED );
}
else
{
VrfErrorResourceFormat(
IDS_CANNOT_OPEN_FILES,
dwErrorCode );
}
goto cleanup;
}
//
// Block the timer
//
m_bTimerBlocked = TRUE;
//
// Parse all the selected files and try to enable them for verification
//
pos = fileDlg.GetStartPosition();
while( pos != NULL )
{
//
// Get the full path for the next file
//
strPathName = fileDlg.GetNextPathName( pos );
//
// split only the file name, without the directory
//
nFileNameStartIndex = strPathName.ReverseFind( _T( '\\' ) );
if( nFileNameStartIndex < 0 )
{
//
// this shoudn't happen but you never know :-)
//
nFileNameStartIndex = 0;
}
else
{
//
// skip the backslash
//
nFileNameStartIndex++;
}
strFileName = strPathName.Right( strPathName.GetLength() - nFileNameStartIndex );
//
// Try to add this driver to the current verification list
//
if( VrfVolatileAddDriver( (LPCTSTR)strFileName ) )
{
bEnabledSome = TRUE;
}
}
//
// Enable the timer
//
m_bTimerBlocked = FALSE;
//
// Refresh
//
if( bEnabledSome == TRUE )
{
OnCrtstatRefreshButton();
}
cleanup:
if( szFilesBuffer != NULL )
{
fileDlg.m_ofn.nMaxFile = dwOldMaxFileName;
fileDlg.m_ofn.lpstrFile = szOldFilesBuffer;
delete szFilesBuffer;
}
}
/////////////////////////////////////////////////////////////
void CVolatileSettPage::OnDontVerifyButton()
{
int nItems;
UINT uIndexInArray;
BOOL bDisabledSome = FALSE;
//
// Block the timer
//
m_bTimerBlocked = TRUE;
//
// The number of items in the list
//
nItems = m_DriversList.GetItemCount();
//
// Parse all the items, looking for the selected ones.
//
for(int nCrtItem = 0; nCrtItem < nItems; nCrtItem++ )
{
if( m_DriversList.GetItemState( nCrtItem, LVIS_SELECTED ) & LVIS_SELECTED )
{
//
// Get the index of the corresponding entry in the array
//
uIndexInArray = (UINT)m_DriversList.GetItemData( nCrtItem );
//
// sanity checks
//
if( uIndexInArray >= m_KrnVerifState.DriverCount )
{
ASSERT( FALSE );
continue;
}
if( VrfVolatileRemoveDriver( m_KrnVerifState.DriverInfo[ uIndexInArray ].Name ) )
{
bDisabledSome = TRUE;
}
}
}
//
// Enable the timer
//
m_bTimerBlocked = FALSE;
//
// If we disabled some drivers' verification we need to refresh the list
//
if( bDisabledSome )
{
OnCrtstatRefreshButton();
}
}
/////////////////////////////////////////////////////////////
LONG CVolatileSettPage::OnHelp( WPARAM wParam, LPARAM lParam )
{
LONG lResult = 0;
LPHELPINFO lpHelpInfo = (LPHELPINFO)lParam;
::WinHelp(
(HWND) lpHelpInfo->hItemHandle,
VERIFIER_HELP_FILE,
HELP_WM_HELP,
(DWORD_PTR) MyHelpIds );
return lResult;
}
/////////////////////////////////////////////////////////////
LONG CVolatileSettPage::OnContextMenu( WPARAM wParam, LPARAM lParam )
{
LONG lResult = 0;
::WinHelp(
(HWND) wParam,
VERIFIER_HELP_FILE,
HELP_CONTEXTMENU,
(DWORD_PTR) MyHelpIds );
return lResult;
}
Reference in a new issue Copy permalink