able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/shell/osshell/snapins/devmgr/snapin/devdrvpg.cpp

1213 lines
37 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (C) 1997-1999 Microsoft Corporation
Module Name:
devdrvpg.cpp
Abstract:
This module implements CDeviceDriverPage -- device driver property page
Author:
William Hsieh (williamh) created
Revision History:
--*/
// devdrvpg.cpp : implementation file
//
#include "devmgr.h"
#include "devdrvpg.h"
#include "cdriver.h"
#include "tswizard.h"
#include "devrmdlg.h"
//
// help topic ids
//
// BUGBUG: JasonC 3/23/2000
// Add context help for driver rollback button.
//
const DWORD g_a106HelpIDs[]=
{
IDC_DEVDRV_ICON, IDH_DISABLEHELP, // Driver: "" (Static)
IDC_DEVDRV_DESC, IDH_DISABLEHELP, // Driver: "" (Static)
IDC_DEVDRV_TITLE_DRIVERPROVIDER, idh_devmgr_driver_provider_main,
IDC_DEVDRV_DRIVERPROVIDER, idh_devmgr_driver_provider_main,
IDC_DEVDRV_TITLE_DRIVERDATE, idh_devmgr_driver_date_main,
IDC_DEVDRV_DRIVERDATE, idh_devmgr_driver_date_main,
IDC_DEVDRV_TITLE_DRIVERVERSION, idh_devmgr_driver_version_main,
IDC_DEVDRV_DRIVERVERSION, idh_devmgr_driver_version_main,
IDC_DEVDRV_TITLE_DRIVERSIGNER, idh_devmgr_digital_signer,
IDC_DEVDRV_DRIVERSIGNER, idh_devmgr_digital_signer,
IDC_DEVDRV_DETAILS, idh_devmgr_devdrv_details, // Driver: "Driver Details" (Button)
IDC_DEVDRV_DETAILS_TEXT, idh_devmgr_devdrv_details, // Driver: "Driver Details" (Button)
IDC_DEVDRV_UNINSTALL, idh_devmgr_devdrv_uninstall, // Driver: "Uninstall" (Button)
IDC_DEVDRV_UNINSTALL_TEXT, idh_devmgr_devdrv_uninstall, // Driver: "Uninstall" (Button)
IDC_DEVDRV_CHANGEDRIVER, idh_devmgr_driver_change_driver, // Driver: "&Change Driver..." (Button)
IDC_DEVDRV_CHANGEDRIVER_TEXT, idh_devmgr_driver_change_driver, // Driver: "&Change Driver..." (Button)
IDC_DEVDRV_ROLLBACK, idh_devmgr_rollback_button, // Driver: "Roll Back Driver..." (Button)
IDC_DEVDRV_ROLLBACK_TEXT, idh_devmgr_rollback_button, // Driver: "Roll Back Driver..." (Button)
0, 0
};
CDeviceDriverPage::~CDeviceDriverPage()
{
if (m_pDriver) {
delete m_pDriver;
}
}
BOOL
CDeviceDriverPage::OnCommand(
WPARAM wParam,
LPARAM lParam
)
{
if (BN_CLICKED == HIWORD(wParam)) {
switch (LOWORD(wParam)) {
case IDC_DEVDRV_DETAILS:
{
//
// We first need to call CDriver::BuildDriverList to build up a list
// of drivers for this device. This can take some time so we will put
// up the busy cursor.
//
HCURSOR hCursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
CDriver* pDriver;
pDriver = m_pDevice->CreateDriver();
if (pDriver) {
pDriver->BuildDriverList(NULL);
SetCursor(hCursorOld);
//
// Show driver file details
//
if (pDriver->GetCount() > 0) {
if (pDriver) {
CDriverFilesDlg DriverFilesDlg(m_pDevice, pDriver);
DriverFilesDlg.DoModal(m_hDlg, (LPARAM)&DriverFilesDlg);
}
} else {
//
// No driver files are loaded for this device
//
String strNoDrivers;
strNoDrivers.LoadString(g_hInstance, IDS_DEVDRV_NODRIVERFILE);
MessageBox(m_hDlg, strNoDrivers, m_pDevice->GetDisplayName(), MB_OK);
return FALSE;
}
delete pDriver;
pDriver = NULL;
}
break;
}
case IDC_DEVDRV_UNINSTALL:
{
BOOL fChanged;
BOOL Refresh = (m_pDevice->IsPhantom() ||
m_pDevice->HasProblem() ||
!m_pDevice->IsStarted());
if (UninstallDrivers(m_pDevice, m_hDlg, &fChanged) && fChanged) {
//
// Enable refresh since we disabled it in the beginning.
//
// We only need to force a refresh here if the device that
// was removed was a Phantom device. This is because Phantom
// devices don't have kernel mode devnodes and so they won't
// generate a WM_DEVICECHANGE like live devnodes will.
//
if (Refresh) {
m_pDevice->m_pMachine->ScheduleRefresh();
}
::DestroyWindow(GetParent(m_hDlg));
}
break;
}
case IDC_DEVDRV_CHANGEDRIVER:
{
BOOL fChanged;
DWORD Reboot = 0;
if (UpdateDriver(m_pDevice, m_hDlg, &fChanged, &Reboot) && fChanged) {
//
// ISSUE: JasonC 2/7/00
//
// A refresh on m_pDevice->m_pMachine is necessary here.
// Since we are running on a different thread and each
// property page may have cached the HDEVINFO and the
// SP_DEVINFO_DATA, refresh on the CMachine object can not
// be done here. The problem is worsen by the fact that
// user can go back to the device tree and work on the tree
// while this property sheet is still up.
// It would be nice if MMC would support modal dialog boxes!
//
m_pDevice->PropertyChanged();
m_pDevice->GetClass()->PropertyChanged();
m_pDevice->m_pMachine->DiTurnOnDiFlags(*m_pDevice, DI_PROPERTIES_CHANGE);
UpdateControls();
PropSheet_SetTitle(GetParent(m_hDlg), PSH_PROPTITLE, m_pDevice->GetDisplayName());
PropSheet_CancelToClose(GetParent(m_hDlg));
if (Reboot & (DI_NEEDRESTART | DI_NEEDREBOOT)) {
m_pDevice->m_pMachine->DiTurnOnDiFlags(*m_pDevice, DI_NEEDREBOOT);
}
}
break;
}
case IDC_DEVDRV_ROLLBACK:
{
BOOL fChanged;
DWORD Reboot = 0;
if (RollbackDriver(m_pDevice, m_hDlg, &fChanged, &Reboot) && fChanged) {
//
// ISSUE: JasonC 2/7/00
//
// A refresh on m_pDevice->m_pMachine is necessary here.
// Since we are running on a different thread and each
// property page may have cached the HDEVINFO and the
// SP_DEVINFO_DATA, refresh on the CMachine object can not
// be done here. The problem is worsen by the fact that
// user can go back to the device tree and work on the tree
// while this property sheet is still up.
// It would be nice if MMC would support modal dialog boxes!
//
m_pDevice->PropertyChanged();
m_pDevice->GetClass()->PropertyChanged();
m_pDevice->m_pMachine->DiTurnOnDiFlags(*m_pDevice, DI_PROPERTIES_CHANGE);
UpdateControls();
PropSheet_SetTitle(GetParent(m_hDlg), PSH_PROPTITLE, m_pDevice->GetDisplayName());
PropSheet_CancelToClose(GetParent(m_hDlg));
if (Reboot & (DI_NEEDRESTART | DI_NEEDREBOOT)) {
m_pDevice->m_pMachine->DiTurnOnDiFlags(*m_pDevice, DI_NEEDREBOOT);
}
}
break;
}
default:
break;
}
}
return FALSE;
}
//
// This function uninstalls the drivers for the given device
// INPUT:
// pDevice -- the object represent the device
// hDlg -- the property page window handle
// pfChanged -- optional buffer to receive if drivers
// were uninstalled.
// OUTPUT:
// TRUE -- function succeeded.
// FALSE -- function failed.
//
BOOL
CDeviceDriverPage::UninstallDrivers(
CDevice* pDevice,
HWND hDlg,
BOOL *pfUninstalled
)
{
BOOL Return = FALSE;
int MsgBoxResult;
TCHAR szText[MAX_PATH];
CMachine *pMachine;
if (pDevice->m_pMachine->m_ParentMachine) {
pMachine = pDevice->m_pMachine->m_ParentMachine;
} else {
pMachine = pDevice->m_pMachine;
}
if(!pDevice->m_pMachine->IsLocal() || !g_HasLoadDriverNamePrivilege) {
//
// Must be an admin and on the local machine to remove a device.
//
return FALSE;
}
BOOL Refresh = (pDevice->IsPhantom() ||
pDevice->HasProblem() ||
!pDevice->IsStarted());
pMachine->EnableRefresh(FALSE);
CRemoveDevDlg TheDlg(pDevice);
if (IDOK == TheDlg.DoModal(hDlg, (LPARAM) &TheDlg)) {
DWORD DiFlags;
DiFlags = pDevice->m_pMachine->DiGetFlags(*pDevice);
//
// We don't check to see if the device manager is connected to the local
// machine because if it wasn't we would not have allowed the user to
// get this far since we don't allow them to remove a device if it
// is not connected to the local machine.
//
if (PromptForRestart(hDlg, DiFlags, IDS_REMOVEDEV_RESTART) == IDNO) {
Refresh = TRUE;
}
if (Refresh) {
pMachine->ScheduleRefresh();
}
Return = TRUE;
}
pMachine->EnableRefresh(TRUE);
return Return;
}
BOOL
CDeviceDriverPage::LaunchTroubleShooter(
CDevice* pDevice,
HWND hDlg,
BOOL *pfChanged
)
{
BOOL fChanged = FALSE;
DWORD Status, Problem = 0;
CProblemAgent* ProblemAgent;
if (pDevice->GetStatus(&Status, &Problem) || pDevice->IsPhantom())
{
//
// if the device is a phantom device, use the CM_PROB_DEVICE_NOT_THERE
//
if (pDevice->IsPhantom())
{
Problem = CM_PROB_DEVICE_NOT_THERE;
Status = DN_HAS_PROBLEM;
}
//
// if the device is not started and no problem is assigned to it
// fake the problem number to be failed start.
//
if (!(Status & DN_STARTED) && !Problem && pDevice->IsRAW())
{
Problem = CM_PROB_FAILED_START;
}
}
ProblemAgent = new CProblemAgent(pDevice, Problem, FALSE);
if (ProblemAgent) {
fChanged = ProblemAgent->FixIt(GetParent(hDlg));
delete ProblemAgent;
}
if (pfChanged) {
*pfChanged = fChanged;
}
return TRUE;
}
//
// This function updates drivers for the given device
// INPUT:
// pDevice -- the object represent the device
// hDlg -- the property page window handle
// pfChanged -- optional buffer to receive if driver changes
// have occured.
// OUTPUT:
// TRUE -- function succeeded.
// FALSE -- function failed.
//
BOOL
CDeviceDriverPage::RollbackDriver(
CDevice* pDevice,
HWND hDlg,
BOOL *pfChanged,
DWORD *pdwReboot
)
{
HCURSOR hCursorOld;
BOOL RollbackSuccessful = FALSE;
DWORD RollbackError = ERROR_CANCELLED;
DWORD Status = 0, Problem = 0;
//
// Verify that the process has Admin credentials and that we are running on the local
// machine.
//
if (!pDevice || !pDevice->m_pMachine->IsLocal() || !g_HasLoadDriverNamePrivilege) {
ASSERT(FALSE);
return FALSE;
}
hCursorOld = SetCursor(LoadCursor(NULL, IDC_WAIT));
//
// If the device has the DN_WILL_BE_REMOVED flag set and the user is
// attempting to roll back the driver then we will prompt them for a
// reboot and include text in the prompt that explains this device
// is in the process of being removed.
//
if (pDevice->GetStatus(&Status, &Problem) &&
(Status & DN_WILL_BE_REMOVED)) {
if (PromptForRestart(m_hDlg, DI_NEEDRESTART, IDS_WILL_BE_REMOVED_NO_ROLLBACK_DRIVER) == IDYES) {
::DestroyWindow(GetParent(m_hDlg));
}
return FALSE;
}
//
// First check to see if there are any drivers to Rollback
//
CSafeRegistry regRollback;
TCHAR RollbackSubkeyName[MAX_PATH + 1];
TCHAR ReinstallString[MAX_PATH];
BOOL bFoundMatch = FALSE;
int index = 0;
ReinstallString[0] = TEXT('\0');
RollbackSubkeyName[0] = TEXT('\0');
if (regRollback.Open(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Reinstall"))) {
DWORD SubkeySize = ARRAYLEN(RollbackSubkeyName);
while (!bFoundMatch && regRollback.EnumerateSubkey(index, RollbackSubkeyName, &SubkeySize)) {
CSafeRegistry regRollbackSubkey;
if (regRollbackSubkey.Open(regRollback, RollbackSubkeyName)) {
DWORD regType, cbSize;
LPTSTR DeviceInstanceIds;
cbSize = 0;
if (regRollbackSubkey.GetValue(TEXT("DeviceInstanceIds"), &regType, NULL, &cbSize)) {
//
// Allocate memory to hold the DeviceInstanceIds
//
DeviceInstanceIds = (LPTSTR)LocalAlloc(LPTR, cbSize);
if (DeviceInstanceIds) {
ZeroMemory(DeviceInstanceIds, cbSize);
if (regRollbackSubkey.GetValue(TEXT("DeviceInstanceIds"), &regType,
(PBYTE)DeviceInstanceIds, &cbSize)) {
//
// Compare the list of DeviceInstanceIds in this registry key with this
// devices DeviceInstanceId
//
for (LPTSTR p = DeviceInstanceIds; *p; p += (lstrlen(p) + 1)) {
if (!lstrcmpi(p, pDevice->GetDeviceID())) {
bFoundMatch = TRUE;
cbSize = sizeof(ReinstallString);
regRollbackSubkey.GetValue(TEXT("ReinstallString"), &regType,
(PBYTE)ReinstallString, &cbSize);
break;
}
}
}
LocalFree(DeviceInstanceIds);
}
}
}
SubkeySize = ARRAYLEN(RollbackSubkeyName);
index++;
}
}
if (bFoundMatch) {
//
// Check the ReinstallString path to verify that a backup directory actually exists.
// We first need to strip the INF name off of the end of the path.
//
PTSTR p;
//
// Assume that the directory does NOT exist
//
bFoundMatch = FALSE;
if (ReinstallString[0] != TEXT('\0')) {
p = StrRChr(ReinstallString, NULL, TEXT('\\'));
if (p) {
*p = 0;
WIN32_FIND_DATA findData;
HANDLE FindHandle;
UINT OldMode;
OldMode = SetErrorMode(SEM_FAILCRITICALERRORS);
FindHandle = FindFirstFile(ReinstallString, &findData);
if(FindHandle != INVALID_HANDLE_VALUE) {
FindClose(FindHandle);
bFoundMatch = TRUE;
} else {
//
// The directory does not exist. Make sure we clean out the registry key
//
regRollback.DeleteSubkey(RollbackSubkeyName);
}
SetErrorMode(OldMode);
}
}
}
if (bFoundMatch) {
//
// We found a match, lets ask the user if they want to rollback the drivers
//
String strYesRollback;
strYesRollback.LoadString(g_hInstance, IDS_DEVDRV_YESROLLBACK);
if (MessageBox(hDlg, strYesRollback, pDevice->GetDisplayName(), MB_YESNO) == IDYES) {
RollbackSuccessful = pDevice->m_pMachine->RollbackDriver(hDlg, RollbackSubkeyName, 0x3, pdwReboot);
if (!RollbackSuccessful) {
RollbackError = GetLastError();
}
}
} else {
//
// We could not find a drivers backup for this device. Lets ask the user if they want
// to start the troubleshooter.
//
String strNoRollback;
strNoRollback.LoadString(g_hInstance, IDS_DEVDRV_NOROLLBACK);
if (MessageBox(hDlg, strNoRollback, pDevice->GetDisplayName(), MB_YESNO) == IDYES) {
LaunchTroubleShooter(pDevice, hDlg, pfChanged);
}
}
if (hCursorOld) {
SetCursor(hCursorOld);
}
//
// We will assume that something changed when we called InstallDevInst()
// unless it returned FALSE and GetLastError() == ERROR_CANCELLED
//
if (pfChanged) {
*pfChanged = TRUE;
if (!bFoundMatch || (!RollbackSuccessful && (ERROR_CANCELLED == RollbackError))) {
*pfChanged = FALSE;
}
}
return TRUE;
}
//
// This function updates drivers for the given device
// INPUT:
// pDevice -- the object represent the device
// hDlg -- the property page window handle
// pfChanged -- optional buffer to receive if driver changes
// have occured.
// OUTPUT:
// TRUE -- function succeeded.
// FALSE -- function failed.
//
BOOL
CDeviceDriverPage::UpdateDriver(
CDevice* pDevice,
HWND hDlg,
BOOL *pfChanged,
DWORD *pdwReboot
)
{
BOOL Installed = FALSE;
DWORD InstallError = ERROR_SUCCESS;
DWORD Status = 0, Problem = 0;
//
// Must be an admin and on the local machine to update a device.
//
if (!pDevice || !pDevice->m_pMachine->IsLocal() || !g_HasLoadDriverNamePrivilege) {
ASSERT(FALSE);
return FALSE;
}
//
// If the device has the DN_WILL_BE_REMOVED flag set and the user is
// attempting to update the driver then we will prompt them for a
// reboot and include text in the prompt that explains this device
// is in the process of being removed.
//
if (pDevice->GetStatus(&Status, &Problem) &&
(Status & DN_WILL_BE_REMOVED)) {
if (PromptForRestart(m_hDlg, DI_NEEDRESTART, IDS_WILL_BE_REMOVED_NO_UPDATE_DRIVER) == IDYES) {
::DestroyWindow(GetParent(m_hDlg));
}
return FALSE;
}
Installed = pDevice->m_pMachine->InstallDevInst(hDlg, pDevice->GetDeviceID(), TRUE, pdwReboot);
if (!Installed) {
InstallError = GetLastError();
}
//
// We will assume that something changed when we called InstallDevInst()
// unless it returned FALSE and GetLastError() == ERROR_CANCELLED
//
if (pfChanged) {
*pfChanged = TRUE;
if (!Installed && (ERROR_CANCELLED == InstallError)) {
*pfChanged = FALSE;
}
}
return TRUE;
}
void
CDeviceDriverPage::InitializeDriver()
{
if (m_pDriver) {
delete m_pDriver;
m_pDriver = NULL;
}
m_pDriver = m_pDevice->CreateDriver();
}
void
CDeviceDriverPage::UpdateControls(
LPARAM lParam
)
{
if (lParam) {
m_pDevice = (CDevice*) lParam;
}
try {
//
// Calling PropertyChanged() will update the display name for the device. We need
// to do this in case a 3rd party property sheet did something that could change
// the device's display name.
//
m_pDevice->PropertyChanged();
//
// If we are not running locally then don't bother showing the driver
// details since we can't get a list of the drivers and we can't get
// any information about the driver.
//
if (!m_pDevice->m_pMachine->IsLocal()) {
::EnableWindow(GetControl(IDC_DEVDRV_DETAILS), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_DETAILS_TEXT), FALSE);
}
//
// can not change driver on remote machine or the user
// has no Administrator privilege.
//
if (!m_pDevice->m_pMachine->IsLocal() || !g_HasLoadDriverNamePrivilege) {
::EnableWindow(GetControl(IDC_DEVDRV_CHANGEDRIVER), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_CHANGEDRIVER_TEXT), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_ROLLBACK), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_ROLLBACK_TEXT), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_UNINSTALL), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_UNINSTALL_TEXT), FALSE);
}
//
// Hide the uninstall button if the device cannot be uninstalled
//
else if (!m_pDevice->IsUninstallable()) {
::EnableWindow(GetControl(IDC_DEVDRV_UNINSTALL), FALSE);
::EnableWindow(GetControl(IDC_DEVDRV_UNINSTALL_TEXT), FALSE);
}
HICON hIconOld;
m_IDCicon = IDC_DEVDRV_ICON; // Save for cleanup in OnDestroy.
hIconOld = (HICON)SendDlgItemMessage(m_hDlg, IDC_DEVDRV_ICON, STM_SETICON,
(WPARAM)(m_pDevice->LoadClassIcon()),
0
);
if (hIconOld) {
DestroyIcon(hIconOld);
}
InitializeDriver();
SetDlgItemText(m_hDlg, IDC_DEVDRV_DESC, m_pDevice->GetDisplayName());
String strDriverProvider, strDriverDate, strDriverVersion, strDriverSigner;
m_pDevice->GetProviderString(strDriverProvider);
SetDlgItemText(m_hDlg, IDC_DEVDRV_DRIVERPROVIDER, strDriverProvider);
m_pDevice->GetDriverDateString(strDriverDate);
SetDlgItemText(m_hDlg, IDC_DEVDRV_DRIVERDATE, strDriverDate);
m_pDevice->GetDriverVersionString(strDriverVersion);
SetDlgItemText(m_hDlg, IDC_DEVDRV_DRIVERVERSION, strDriverVersion);
if (m_pDriver) {
m_pDriver->GetDriverSignerString(strDriverSigner);
}
//
// If we could not get a digital signature string or then just display
// Unknown for the Digital Signer.
//
if (strDriverSigner.IsEmpty()) {
strDriverSigner.LoadString(g_hInstance, IDS_UNKNOWN);
}
SetDlgItemText(m_hDlg, IDC_DEVDRV_DRIVERSIGNER, strDriverSigner);
AddToolTips(m_hDlg, IDC_DEVDRV_DRIVERSIGNER, (LPTSTR)strDriverSigner, &m_hwndDigitalSignerTip);
}
catch (CMemoryException* e) {
e->Delete();
// report memory error
MsgBoxParam(m_hDlg, 0, 0, 0);
}
}
BOOL
CDeviceDriverPage::OnHelp(
LPHELPINFO pHelpInfo
)
{
WinHelp((HWND)pHelpInfo->hItemHandle, DEVMGR_HELP_FILE_NAME, HELP_WM_HELP,
(ULONG_PTR)g_a106HelpIDs);
return FALSE;
}
BOOL
CDeviceDriverPage::OnContextMenu(
HWND hWnd,
WORD xPos,
WORD yPos
)
{
WinHelp(hWnd, DEVMGR_HELP_FILE_NAME, HELP_CONTEXTMENU,
(ULONG_PTR)g_a106HelpIDs);
return FALSE;
}
//////////////////////////////////////////////////////////////////////////////////////////
//
// Driver Files
//
const DWORD g_a110HelpIDs[]=
{
IDC_DRIVERFILES_ICON, IDH_DISABLEHELP, // Driver: "" (Icon)
IDC_DRIVERFILES_DESC, IDH_DISABLEHELP, // Driver: "" (Static)
IDC_DRIVERFILES_FILES, IDH_DISABLEHELP, // Driver: "Provider:" (Static)
IDC_DRIVERFILES_FILELIST, idh_devmgr_driver_driver_files, // Driver: "" (ListBox)
IDC_DRIVERFILES_TITLE_PROVIDER, idh_devmgr_driver_provider, // Driver: "Provider:" (Static)
IDC_DRIVERFILES_PROVIDER, idh_devmgr_driver_provider, // Driver: "" (Static)
IDC_DRIVERFILES_TITLE_COPYRIGHT,idh_devmgr_driver_copyright, // Driver: "Copyright:" (Static)
IDC_DRIVERFILES_COPYRIGHT, idh_devmgr_driver_copyright, // Driver: "" (Static)
IDC_DRIVERFILES_TITLE_DIGITALSIGNER, IDH_DISABLEHELP,
IDC_DRIVERFILES_DIGITALSIGNER, IDH_DISABLEHELP,
IDC_DRIVERFILES_TITLE_VERSION, idh_devmgr_driver_file_version, // Driver: "Version:" (Static)
IDC_DRIVERFILES_VERSION, idh_devmgr_driver_file_version, // Driver: "File Version:" (Static)
0, 0
};
BOOL CDriverFilesDlg::OnInitDialog()
{
int SignedIndex = 0, BlankIndex = 0, DriverBlockIndex = 0;
try {
HICON hIcon;
hIcon = (HICON)SendDlgItemMessage(m_hDlg, IDC_DRIVERFILES_ICON, STM_SETICON,
(WPARAM)(m_pDevice->LoadClassIcon()), 0);
if (hIcon) {
DestroyIcon(hIcon);
}
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_DESC, m_pDevice->GetDisplayName());
//
// Create the ImageList that contains the signed and blank images.
//
// NOTE: On BiDi builds we need to set the ILC_MIRROR flag so that the
// signed/unsigned icons are not mirrored.
//
m_ImageList = ImageList_Create(GetSystemMetrics(SM_CXSMICON),
GetSystemMetrics(SM_CYSMICON),
ILC_MASK |
(GetWindowLong(GetParent(m_hDlg), GWL_EXSTYLE) & WS_EX_LAYOUTRTL)
? ILC_MIRROR
: 0,
1,
1
);
if (m_ImageList) {
ImageList_SetBkColor(m_ImageList, GetSysColor(COLOR_WINDOW));
if ((hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_BLANK))) != NULL) {
BlankIndex = ImageList_AddIcon(m_ImageList, hIcon);
DestroyIcon(hIcon);
}
if ((hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_SIGNED))) != NULL) {
SignedIndex = ImageList_AddIcon(m_ImageList, hIcon);
DestroyIcon(hIcon);
}
if ((hIcon = LoadIcon(g_hInstance, MAKEINTRESOURCE(IDI_DRIVERBLOCK))) != NULL) {
DriverBlockIndex = ImageList_AddIcon(m_ImageList, hIcon);
DestroyIcon(hIcon);
}
}
//
//Initialize the list of drivers
//
LV_COLUMN lvcCol;
LV_ITEM lviItem;
CDriverFile* pDrvFile;
PVOID Context;
HWND hwndFileList = GetDlgItem(m_hDlg, IDC_DRIVERFILES_FILELIST);
//
// Insert a single column for this list.
//
lvcCol.mask = LVCF_FMT | LVCF_WIDTH;
lvcCol.fmt = LVCFMT_LEFT;
lvcCol.iSubItem = 0;
ListView_InsertColumn(hwndFileList, 0, (LV_COLUMN FAR *)&lvcCol);
ListView_SetExtendedListViewStyle(hwndFileList, LVS_EX_FULLROWSELECT | LVS_EX_LABELTIP);
if (m_ImageList) {
ListView_SetImageList(hwndFileList, m_ImageList, LVSIL_SMALL);
}
ListView_DeleteAllItems(hwndFileList);
if (m_pDriver && m_pDriver->GetFirstDriverFile(&pDrvFile, Context)) {
do {
ASSERT(pDrvFile);
LPCTSTR pFullPathName;
pFullPathName = pDrvFile->GetFullPathName();
if (pFullPathName) {
lviItem.mask = LVIF_TEXT | LVIF_PARAM | LVIF_IMAGE;
lviItem.iSubItem = 0;
lviItem.lParam = (LPARAM)pDrvFile;
lviItem.iItem = ListView_GetItemCount(hwndFileList);
lviItem.pszText = (LPTSTR)pFullPathName;
if (m_ImageList) {
if (pDrvFile->IsDriverBlocked()) {
//
// If the driver is blocked then it gets a special
// icon.
//
lviItem.iImage = DriverBlockIndex;
} else {
//
// If the driver is not blocked then show an icon
// if the driver is digitally signed.
//
lviItem.iImage = (pDrvFile->GetWin32Error() == NO_ERROR) ?
SignedIndex : BlankIndex;
}
}
ListView_InsertItem(hwndFileList, &lviItem);
}
} while (m_pDriver->GetNextDriverFile(&pDrvFile, Context));
if (ListView_GetItemCount(hwndFileList) >= 1) {
ListView_SetItemState(hwndFileList,
0,
LVIS_SELECTED | LVIS_FOCUSED,
LVIS_SELECTED | LVIS_FOCUSED
);
ListView_EnsureVisible(hwndFileList, 0, FALSE);
ListView_SetColumnWidth(hwndFileList, 0, LVSCW_AUTOSIZE_USEHEADER);
ShowCurDriverFileDetail();
} else {
//
// nothing on the driver file list, disable it
//
::EnableWindow(GetControl(IDC_DRIVERFILES_FILELIST), FALSE);
}
}
}
catch (CMemoryException* e) {
e->Delete();
return FALSE;
}
return TRUE;
}
void
CDriverFilesDlg::OnCommand(
WPARAM wParam,
LPARAM lParam
)
{
if (BN_CLICKED == HIWORD(wParam)) {
if (IDOK == LOWORD(wParam)) {
EndDialog(m_hDlg, IDOK);
} else if (IDCANCEL == LOWORD(wParam)) {
EndDialog(m_hDlg, IDCANCEL);
}
}
}
BOOL
CDriverFilesDlg::OnNotify(
LPNMHDR pnmhdr
)
{
switch (pnmhdr->code) {
case LVN_ITEMCHANGED:
ShowCurDriverFileDetail();
break;
case NM_RETURN:
case NM_CLICK:
if (pnmhdr->idFrom == IDS_DRIVERFILES_BLOCKDRIVERLINK) {
LaunchHelpForBlockedDriver();
}
break;
}
return FALSE;
}
BOOL
CDriverFilesDlg::OnDestroy()
{
HICON hIcon;
if(hIcon = (HICON)SendDlgItemMessage(m_hDlg, IDC_DRIVERFILES_ICON, STM_GETICON, 0, 0)) {
DestroyIcon(hIcon);
}
if (m_ImageList) {
ImageList_Destroy(m_ImageList);
}
return FALSE;
}
BOOL
CDriverFilesDlg::OnHelp(
LPHELPINFO pHelpInfo
)
{
WinHelp((HWND)pHelpInfo->hItemHandle, DEVMGR_HELP_FILE_NAME, HELP_WM_HELP,
(ULONG_PTR)g_a110HelpIDs);
return FALSE;
}
BOOL
CDriverFilesDlg::OnContextMenu(
HWND hWnd,
WORD xPos,
WORD yPos
)
{
WinHelp(hWnd, DEVMGR_HELP_FILE_NAME, HELP_CONTEXTMENU,
(ULONG_PTR)g_a110HelpIDs);
return FALSE;
}
void
CDriverFilesDlg::ShowCurDriverFileDetail()
{
HWND hwndFileList = GetDlgItem(m_hDlg, IDC_DRIVERFILES_FILELIST);
LVITEM lvItem;
LPCTSTR pString;
lvItem.mask = LVIF_PARAM;
lvItem.iSubItem = 0;
lvItem.iItem = ListView_GetNextItem(hwndFileList,
-1,
LVNI_SELECTED
);
if (lvItem.iItem != -1) {
try {
ListView_GetItem(hwndFileList, &lvItem);
CDriverFile* pDrvFile = (CDriverFile*)lvItem.lParam;
ASSERT(pDrvFile);
TCHAR TempString[LINE_LEN];
LPCTSTR pFullPathName;
pFullPathName = pDrvFile->GetFullPathName();
if (!pFullPathName || (pDrvFile->GetAttributes() == 0xFFFFFFFF)) {
//
// This is the case when the file is not present on the system
//
LoadResourceString(IDS_NOT_PRESENT, TempString, ARRAYLEN(TempString));
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_VERSION, TempString);
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_PROVIDER, TempString);
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_COPYRIGHT, TempString);
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_DIGITALSIGNER, TempString);
ShowWindow(GetControl(IDS_DRIVERFILES_BLOCKDRIVERLINK), FALSE);
} else {
if (!pDrvFile->HasVersionInfo()) {
//
// This is the case when the file is present but it does not have
// version information.
//
LoadResourceString(IDS_UNKNOWN, TempString, ARRAYLEN(TempString));
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_VERSION, TempString);
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_PROVIDER, TempString);
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_COPYRIGHT, TempString);
} else {
//
// Show the file version information.
//
TempString[0] = _T('\0');
pString = pDrvFile->GetVersion();
if (!pString && _T('\0') == TempString[0]) {
LoadResourceString(IDS_NOT_AVAILABLE, TempString, ARRAYLEN(TempString));
pString = TempString;
}
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_VERSION, (LPTSTR)pString);
pString = pDrvFile->GetProvider();
if (!pString && _T('\0') == TempString[0]) {
LoadResourceString(IDS_NOT_AVAILABLE, TempString, ARRAYLEN(TempString));
pString = TempString;
}
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_PROVIDER, (LPTSTR)pString);
pString = pDrvFile->GetCopyright();
if (!pString && _T('\0') == TempString[0]) {
LoadResourceString(IDS_NOT_AVAILABLE, TempString, ARRAYLEN(TempString));
pString = TempString;
}
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_COPYRIGHT, (LPTSTR)pString);
}
//
// Show the digital signer if the file is signed.
//
pString = pDrvFile->GetDigitalSigner();
if (!pString) {
TempString[0] = _T('\0');
LoadResourceString(((pDrvFile->GetWin32Error() != 0) &&
(pDrvFile->GetWin32Error() != 0xFFFFFFFF) &&
(pDrvFile->GetWin32Error() != ERROR_DRIVER_BLOCKED))
? IDS_NO_DIGITALSIGNATURE
: IDS_NOT_AVAILABLE,
TempString,
ARRAYLEN(TempString));
pString = TempString;
}
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_DIGITALSIGNER, (LPTSTR)pString);
//
// Show the block driver link if this driver is blocked and it
// has a block driver html help ID.
//
ShowWindow(GetControl(IDS_DRIVERFILES_BLOCKDRIVERLINK),
pDrvFile->GetBlockedDriverHtmlHelpID()
? TRUE
: FALSE);
}
}
catch (CMemoryException* e) {
e->Delete();
// report memory error
MsgBoxParam(m_hDlg, 0, 0, 0);
}
} else {
// no selection
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_VERSION, TEXT(""));
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_PROVIDER, TEXT(""));
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_COPYRIGHT, TEXT(""));
SetDlgItemText(m_hDlg, IDC_DRIVERFILES_DIGITALSIGNER, TEXT(""));
}
}
void
CDriverFilesDlg::LaunchHelpForBlockedDriver()
{
HWND hwndFileList = GetDlgItem(m_hDlg, IDC_DRIVERFILES_FILELIST);
LVITEM lvItem;
LPCTSTR pHtmlHelpID;
String strHcpLink;
lvItem.mask = LVIF_PARAM;
lvItem.iSubItem = 0;
lvItem.iItem = ListView_GetNextItem(hwndFileList,
-1,
LVNI_SELECTED
);
if (lvItem.iItem != -1) {
try {
ListView_GetItem(hwndFileList, &lvItem);
CDriverFile* pDrvFile = (CDriverFile*)lvItem.lParam;
ASSERT(pDrvFile);
if ((pHtmlHelpID = pDrvFile->GetBlockedDriverHtmlHelpID()) != NULL) {
strHcpLink.Format(TEXT("HELPCTR.EXE -url %s"), pHtmlHelpID);
TRACE((TEXT("launching %s"), pHtmlHelpID));
ShellExecute(m_hDlg,
TEXT("open"),
TEXT("HELPCTR.EXE"),
(LPTSTR)strHcpLink,
NULL,
SW_SHOWNORMAL);
}
}
catch (CMemoryException* e) {
e->Delete();
// report memory error
MsgBoxParam(m_hDlg, 0, 0, 0);
}
}
}
Reference in a new issue Copy permalink