536 lines
22 KiB
C++
536 lines
22 KiB
C++
|
|
#ifndef __MACHINE_H_
|
|
#define __MACHINE_H_
|
|
|
|
/*++
|
|
|
|
Copyright (C) 1997-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
machine.h
|
|
|
|
Abstract:
|
|
|
|
header file that declares CMachine, CDevInfoist and CMachineList classes
|
|
|
|
Author:
|
|
|
|
William Hsieh (williamh) created
|
|
|
|
Revision History:
|
|
|
|
|
|
--*/
|
|
|
|
LRESULT CALLBACK dmNotifyWndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
typedef BOOL (*LPFNINSTALLDEVINST)(HWND hwndParent, LPCTSTR DeviceId, BOOL UpdateDriver, DWORD* pReboot);
|
|
typedef BOOL (*LPFNROLLBACKDRIVER)(HWND hwndParent, LPCTSTR RegistryKey, DWORD Flags, DWORD* pReboot);
|
|
|
|
class CDevice;
|
|
class CClass;
|
|
class CComputer;
|
|
class CLogConf;
|
|
class CResDes;
|
|
class CMachineList;
|
|
class CFolder;
|
|
|
|
#define DM_NOTIFY_TIMERID 0x444d4d44
|
|
|
|
//This class represents SETUPAPI's <Device Information List>
|
|
//
|
|
// WARNING !!!
|
|
// no copy constructor and assignment operator are provided ---
|
|
// DO NOT ASSIGN A CDevInfoList from one to another!!!!!
|
|
class CDevInfoList
|
|
{
|
|
public:
|
|
|
|
CDevInfoList(HDEVINFO hDevInfo = INVALID_HANDLE_VALUE, HWND hwndParent = NULL)
|
|
:m_hDevInfo(hDevInfo), m_hwndParent(hwndParent)
|
|
{
|
|
}
|
|
virtual ~CDevInfoList()
|
|
{
|
|
if (INVALID_HANDLE_VALUE != m_hDevInfo)
|
|
DiDestroyDeviceInfoList();
|
|
}
|
|
|
|
operator HDEVINFO()
|
|
{
|
|
return m_hDevInfo;
|
|
}
|
|
BOOL DiGetDeviceInfoListDetail(PSP_DEVINFO_LIST_DETAIL_DATA DetailData)
|
|
{
|
|
return SetupDiGetDeviceInfoListDetail(m_hDevInfo, DetailData);
|
|
}
|
|
BOOL DiOpenDeviceInfo(LPCTSTR DeviceID, HWND hwndParent, DWORD OpenFlags,
|
|
PSP_DEVINFO_DATA DevData)
|
|
{
|
|
return SetupDiOpenDeviceInfo(m_hDevInfo, DeviceID, hwndParent, OpenFlags,
|
|
DevData);
|
|
}
|
|
BOOL DiEnumDeviceInfo(DWORD Index, PSP_DEVINFO_DATA DevData)
|
|
{
|
|
return SetupDiEnumDeviceInfo(m_hDevInfo, Index, DevData);
|
|
}
|
|
BOOL DiBuildDriverInfoList(PSP_DEVINFO_DATA DevData, DWORD DriverType)
|
|
{
|
|
return SetupDiBuildDriverInfoList(m_hDevInfo, DevData, DriverType);
|
|
}
|
|
BOOL DiEnumDriverInfo(PSP_DEVINFO_DATA DevData, DWORD DriverType, DWORD Index,
|
|
PSP_DRVINFO_DATA DrvData)
|
|
{
|
|
return SetupDiEnumDriverInfo(m_hDevInfo, DevData, DriverType, Index, DrvData);
|
|
}
|
|
BOOL DiGetDriverInfoDetail(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DrvData,
|
|
PSP_DRVINFO_DETAIL_DATA DrvDetailData,
|
|
DWORD DrvDetailDataSize,
|
|
PDWORD RequiredSize)
|
|
{
|
|
return SetupDiGetDriverInfoDetail(m_hDevInfo, DevData, DrvData,
|
|
DrvDetailData,
|
|
DrvDetailDataSize,
|
|
RequiredSize);
|
|
}
|
|
BOOL DiDestroyDriverInfoList(PSP_DEVINFO_DATA DevData, DWORD DriverType)
|
|
{
|
|
return SetupDiDestroyDriverInfoList(m_hDevInfo, DevData, DriverType);
|
|
}
|
|
BOOL DiCallClassInstaller(DI_FUNCTION InstallFunction, PSP_DEVINFO_DATA DevData)
|
|
{
|
|
return SetupDiCallClassInstaller(InstallFunction, m_hDevInfo, DevData);
|
|
}
|
|
BOOL DiRemoveDevice(PSP_DEVINFO_DATA DevData)
|
|
{
|
|
return SetupDiRemoveDevice(m_hDevInfo, DevData);
|
|
}
|
|
BOOL DiChangeState(PSP_DEVINFO_DATA DevData)
|
|
{
|
|
return SetupDiChangeState(m_hDevInfo, DevData);
|
|
}
|
|
HKEY DiOpenDevRegKey(PSP_DEVINFO_DATA DevData, DWORD Scope, DWORD HwProfile,
|
|
DWORD KeyType, REGSAM samDesired)
|
|
{
|
|
return SetupDiOpenDevRegKey(m_hDevInfo, DevData, Scope, HwProfile,
|
|
KeyType, samDesired);
|
|
}
|
|
BOOL DiGetDeviceRegistryProperty(PSP_DEVINFO_DATA DevData, DWORD Property,
|
|
PDWORD PropertyDataType, PBYTE PropertyBuffer,
|
|
DWORD PropertyBufferSize, PDWORD RequiredSize)
|
|
{
|
|
return SetupDiGetDeviceRegistryProperty(m_hDevInfo, DevData,
|
|
Property, PropertyDataType,
|
|
PropertyBuffer,
|
|
PropertyBufferSize,
|
|
RequiredSize
|
|
);
|
|
}
|
|
BOOL DiGetDeviceInstallParams(PSP_DEVINFO_DATA DevData,
|
|
PSP_DEVINSTALL_PARAMS DevInstParams)
|
|
{
|
|
return SetupDiGetDeviceInstallParams(m_hDevInfo, DevData, DevInstParams);
|
|
}
|
|
BOOL DiGetClassInstallParams(PSP_DEVINFO_DATA DevData,
|
|
PSP_CLASSINSTALL_HEADER ClassInstallHeader,
|
|
DWORD ClassInstallParamsSize,
|
|
PDWORD RequiredSize)
|
|
{
|
|
return SetupDiGetClassInstallParams(m_hDevInfo, DevData,
|
|
ClassInstallHeader,
|
|
ClassInstallParamsSize,
|
|
RequiredSize);
|
|
}
|
|
BOOL DiSetDeviceInstallParams(PSP_DEVINFO_DATA DevData,
|
|
PSP_DEVINSTALL_PARAMS DevInstParams)
|
|
{
|
|
return SetupDiSetDeviceInstallParams(m_hDevInfo, DevData, DevInstParams);
|
|
}
|
|
BOOL DiSetClassInstallParams(PSP_DEVINFO_DATA DevData,
|
|
PSP_CLASSINSTALL_HEADER ClassInstallHeader,
|
|
DWORD ClassInstallParamsSize)
|
|
{
|
|
return SetupDiSetClassInstallParams(m_hDevInfo, DevData,
|
|
ClassInstallHeader,
|
|
ClassInstallParamsSize);
|
|
}
|
|
BOOL DiGetClassDevPropertySheet(PSP_DEVINFO_DATA DevData,
|
|
LPPROPSHEETHEADER PropertySheetHeader,
|
|
DWORD PagesAllowed,
|
|
DWORD Flags)
|
|
{
|
|
return SetupDiGetClassDevPropertySheets(m_hDevInfo, DevData,
|
|
PropertySheetHeader, PagesAllowed,
|
|
NULL, Flags);
|
|
}
|
|
|
|
BOOL DiGetExtensionPropSheetPage(PSP_DEVINFO_DATA DevData,
|
|
LPFNADDPROPSHEETPAGE pfnAddPropSheetPage,
|
|
DWORD PageType,
|
|
LPARAM lParam
|
|
);
|
|
|
|
BOOL DiGetSelectedDriver(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DriverInfoData)
|
|
{
|
|
return SetupDiGetSelectedDriver(m_hDevInfo, DevData, DriverInfoData);
|
|
}
|
|
BOOL DiSetSelectedDriver(PSP_DEVINFO_DATA DevData, PSP_DRVINFO_DATA DriverInfoData)
|
|
{
|
|
return SetupDiSetSelectedDriver(m_hDevInfo, DevData, DriverInfoData);
|
|
}
|
|
BOOL DiEnumDeviceInterfaces(DWORD Index, LPGUID InterfaceGuid, PSP_DEVICE_INTERFACE_DATA InterfaceData)
|
|
{
|
|
return SetupDiEnumDeviceInterfaces(m_hDevInfo, NULL, InterfaceGuid, Index, InterfaceData);
|
|
}
|
|
BOOL DiGetInterfaceDetailData(PSP_DEVICE_INTERFACE_DATA pInterfaceData,
|
|
PSP_DEVICE_INTERFACE_DETAIL_DATA pDetailData,
|
|
DWORD Size, DWORD* pRequiredSize)
|
|
{
|
|
return SetupDiGetDeviceInterfaceDetail(m_hDevInfo, pInterfaceData,
|
|
pDetailData, Size,
|
|
pRequiredSize, NULL);
|
|
}
|
|
BOOL DiTurnOnDiFlags(PSP_DEVINFO_DATA DevData, DWORD FlagMask );
|
|
BOOL DiTurnOffDiFlags(PSP_DEVINFO_DATA DevData, DWORD FlagsMask);
|
|
BOOL DiTurnOnDiExFlags(PSP_DEVINFO_DATA DevData, DWORD FlagMask );
|
|
BOOL DiTurnOffDiExFlags(PSP_DEVINFO_DATA DevData, DWORD FlagsMask);
|
|
BOOL InstallDevInst(HWND hwndParent, LPCTSTR DeviceID, BOOL UpdateDriver, DWORD* pReboot);
|
|
BOOL RollbackDriver(HWND hwndParent, LPCTSTR RegistryKeyName, DWORD Flags, DWORD* pReboot);
|
|
DWORD DiGetFlags(PSP_DEVINFO_DATA DevData = NULL);
|
|
DWORD DiGetExFlags(PSP_DEVINFO_DATA DevData = NULL);
|
|
void DiDestroyDeviceInfoList();
|
|
BOOL DiGetDeviceMFGString(PSP_DEVINFO_DATA DevData, String& str);
|
|
BOOL DiGetDeviceMFGString(PSP_DEVINFO_DATA DevData, TCHAR* pBuffer, DWORD Size, DWORD* pRequiredSize = NULL);
|
|
BOOL DiGetDeviceIDString(PSP_DEVINFO_DATA DevData, String& str);
|
|
BOOL DiGetDeviceIDString(PSP_DEVINFO_DATA DevData, TCHAR* pBuffer, DWORD Size, DWORD* pRequiredSize = NULL);
|
|
HWND OwnerWindow()
|
|
{
|
|
return m_hwndParent;
|
|
}
|
|
protected:
|
|
HDEVINFO m_hDevInfo;
|
|
HWND m_hwndParent;
|
|
|
|
private:
|
|
CDevInfoList(const CDevInfoList&);
|
|
CDevInfoList& operator=(const CDevInfoList&);
|
|
};
|
|
|
|
class CMachine : public CDevInfoList
|
|
{
|
|
public:
|
|
CMachine(LPCTSTR MachineName = NULL);
|
|
|
|
virtual ~CMachine();
|
|
operator HMACHINE()
|
|
{
|
|
return m_hMachine;
|
|
}
|
|
LPCTSTR GetMachineDisplayName()
|
|
{
|
|
return (LPCTSTR)m_strMachineDisplayName;
|
|
}
|
|
LPCTSTR GetMachineFullName()
|
|
{
|
|
return (LPCTSTR)m_strMachineFullName;
|
|
}
|
|
LPCTSTR GetRemoteMachineFullName()
|
|
{
|
|
return m_IsLocal ? NULL : (LPCTSTR)m_strMachineFullName;
|
|
}
|
|
HMACHINE GetHMachine()
|
|
{
|
|
return m_hMachine;
|
|
}
|
|
BOOL LoadStringWithMachineName(int StringId, LPTSTR Buffer, DWORD* BufferLen);
|
|
|
|
BOOL IsLocal()
|
|
{
|
|
return m_IsLocal;
|
|
}
|
|
BOOL AttachFolder(CFolder* pFolder);
|
|
void DetachFolder(CFolder* pFolder);
|
|
BOOL IsFolderAttached(CFolder* pFolder);
|
|
BOOL AttachPropertySheet(HWND hwndPropertySheet);
|
|
void DetachPropertySheet(HWND hwndPropertySheet);
|
|
HWND GetDeviceWindowHandle(LPCTSTR DeviceId);
|
|
HWND GetClassWindowHandle(LPGUID ClassGuid);
|
|
BOOL AttachChildMachine(CMachine* ChildMachine);
|
|
void DetachChildMachine(CMachine* ChildMachine);
|
|
BOOL EnuemerateDevice(int Index, CDevice** ppDevice);
|
|
|
|
BOOL Initialize(
|
|
HWND hwndParent = NULL,
|
|
LPCTSTR DeviceId = NULL,
|
|
LPGUID ClassGuid = NULL
|
|
);
|
|
|
|
DWORD GetNumberOfClasses() const
|
|
{
|
|
return m_listClass.GetCount();
|
|
}
|
|
DWORD GetNumberOfDevices() const
|
|
{
|
|
return (DWORD)m_listDevice.GetCount();
|
|
}
|
|
BOOL GetFirstClass(CClass** ppClass, PVOID& Context);
|
|
BOOL GetNextClass(CClass** ppClass, PVOID& Context);
|
|
BOOL GetFirstDevice(CDevice** ppDevice, PVOID& Context);
|
|
BOOL GetNextDevice(CDevice** ppDevice, PVOID& Context);
|
|
CDevice* DevNodeToDevice(DEVNODE dn);
|
|
CDevice* DeviceIDToDevice(LPCTSTR DeviceID);
|
|
CClass* ClassGuidToClass(LPGUID ClassGuid);
|
|
BOOL Reenumerate();
|
|
BOOL DoMiniRefresh();
|
|
BOOL Refresh();
|
|
int GetComputerIconIndex()
|
|
{
|
|
return m_ComputerIndex;
|
|
}
|
|
int GetResourceIconIndex()
|
|
{
|
|
return m_ResourceIndex;
|
|
}
|
|
BOOL ShouldPropertySheetDestroy()
|
|
{
|
|
return m_PropertySheetShoudDestroy;
|
|
}
|
|
void SetPropertySheetShouldDestroy()
|
|
{
|
|
m_PropertySheetShoudDestroy = TRUE;
|
|
}
|
|
BOOL GetDigitalSigner(LPTSTR FullInfPath, String& DigitalSigner);
|
|
BOOL DoNotCreateDevice(SC_HANDLE SCMHandle, LPGUID ClassGuid, DEVINST DevInst);
|
|
BOOL IsUserAGuest()
|
|
{
|
|
return m_UserIsAGuest;
|
|
}
|
|
HDEVINFO DiCreateDeviceInfoList(LPGUID ClassGuid, HWND hwndParent)
|
|
{
|
|
return SetupDiCreateDeviceInfoListEx(ClassGuid, hwndParent,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
HDEVINFO DiCreateDeviceInterfaceList(LPGUID InterfaceGuid, LPCTSTR DeviceId, HWND hwndParent)
|
|
{
|
|
return SetupDiGetClassDevsEx(InterfaceGuid, DeviceId, m_hwndParent, DIGCF_DEVICEINTERFACE,
|
|
NULL, GetRemoteMachineFullName(), NULL);
|
|
}
|
|
|
|
HDEVINFO DiGetClassDevs(LPGUID ClassGuid, LPCTSTR Enumerator, HWND hwndParent, DWORD Flags)
|
|
{
|
|
return SetupDiGetClassDevsEx(ClassGuid, Enumerator, hwndParent,
|
|
Flags, NULL, GetRemoteMachineFullName(), NULL
|
|
);
|
|
}
|
|
HIMAGELIST DiGetClassImageList()
|
|
{
|
|
return m_ImageListData.ImageList;
|
|
}
|
|
BOOL DiBuildClassInfoList(DWORD Flags, LPGUID ClassGuid,
|
|
DWORD ClassGuidListSize, PDWORD RequiredSize)
|
|
{
|
|
return SetupDiBuildClassInfoListEx(Flags, ClassGuid,
|
|
ClassGuidListSize, RequiredSize,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
BOOL DiGetClassDescription(LPGUID ClassGuid, LPTSTR ClassDescription,
|
|
DWORD ClassDescriptionSize, PDWORD RequiredSize)
|
|
{
|
|
return SetupDiGetClassDescriptionEx(ClassGuid, ClassDescription,
|
|
ClassDescriptionSize,
|
|
RequiredSize,
|
|
GetRemoteMachineFullName(),
|
|
NULL);
|
|
}
|
|
HKEY DiOpenClassRegKey(LPGUID ClassGuid, REGSAM samDesired, DWORD Flags)
|
|
{
|
|
return SetupDiOpenClassRegKeyEx(ClassGuid, samDesired, Flags,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
BOOL DiGetHwProfileList(PDWORD HwProfileList, DWORD HwProfileListSize,
|
|
PDWORD RequiredSize, PDWORD CurrentIndex)
|
|
{
|
|
return SetupDiGetHwProfileListEx(HwProfileList, HwProfileListSize,
|
|
RequiredSize, CurrentIndex,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
BOOL DiLoadClassIcon(LPGUID ClassGuid, HICON* LargeIcon, PINT MiniIconIndex)
|
|
{
|
|
return SetupDiLoadClassIcon(ClassGuid, LargeIcon, MiniIconIndex);
|
|
}
|
|
BOOL DiGetClassImageList(PSP_CLASSIMAGELIST_DATA pImageListData)
|
|
{
|
|
return SetupDiGetClassImageListEx(pImageListData,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
BOOL DiDestroyClassImageList(PSP_CLASSIMAGELIST_DATA pImageListData)
|
|
{
|
|
return SetupDiDestroyClassImageList(pImageListData);
|
|
}
|
|
|
|
BOOL DiGetClassImageIndex(LPGUID ClassGuid, PINT ImageIndex)
|
|
{
|
|
return SetupDiGetClassImageIndex(&m_ImageListData, ClassGuid, ImageIndex);
|
|
}
|
|
int DiDrawMiniIcon(HDC hdc, RECT rc, int IconIndex, DWORD Flags)
|
|
{
|
|
return SetupDiDrawMiniIcon(hdc, rc, IconIndex, Flags);
|
|
}
|
|
BOOL DiClassNameFromGuid(LPGUID ClassGuid, LPTSTR ClassName,
|
|
DWORD ClassNameSize, PDWORD RequiredSize)
|
|
{
|
|
return SetupDiClassNameFromGuidEx(ClassGuid, ClassName,
|
|
ClassNameSize, RequiredSize,
|
|
GetRemoteMachineFullName(), NULL);
|
|
}
|
|
BOOL DiGetHwProfileFriendlyName(DWORD HwProfile, LPTSTR FriendlyName,
|
|
DWORD FriendlyNameSize,
|
|
PDWORD RequiredSize)
|
|
|
|
{
|
|
return SetupDiGetHwProfileFriendlyNameEx(HwProfile, FriendlyName,
|
|
FriendlyNameSize,
|
|
RequiredSize,
|
|
GetRemoteMachineFullName(),
|
|
NULL);
|
|
}
|
|
BOOL DiGetClassFriendlyNameString(LPGUID Guid, String& strClass);
|
|
BOOL DiDestroyDeviceInfoList(HDEVINFO hDevInfo)
|
|
{
|
|
return SetupDiDestroyDeviceInfoList(hDevInfo);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
//// Configuration Manager APIs
|
|
////
|
|
CONFIGRET GetLastCR()
|
|
{
|
|
return m_LastCR;
|
|
}
|
|
BOOL CmGetConfigFlags(DEVNODE dn, DWORD* pFlags);
|
|
BOOL CmGetCapabilities(DEVNODE dn, DWORD* pCapabilities);
|
|
BOOL CmGetDeviceIDString(DEVNODE dn, String& str);
|
|
BOOL CmGetDescriptionString(DEVNODE dn, String& str);
|
|
BOOL CmGetMFGString(DEVNODE dn, String& str);
|
|
BOOL CmGetProviderString(DEVNODE dn, String& str);
|
|
BOOL CmGetDriverDateString(DEVNODE dn, String& str);
|
|
BOOL CmGetDriverDateData(DEVNODE dn, FILETIME *ft);
|
|
BOOL CmGetDriverVersionString(DEVNODE dn, String& str);
|
|
BOOL CmGetClassGuid(DEVNODE dn, GUID& Guid);
|
|
BOOL CmGetHardwareIDs(DEVNODE dn, PVOID Buffer, ULONG* BufferLen);
|
|
BOOL CmGetCompatibleIDs(DEVNODE dn, PVOID Buffer, ULONG* BufferLen);
|
|
BOOL CmGetStatus(DEVNODE dn, DWORD* pProblem, DWORD* pStatus);
|
|
BOOL CmGetKnownLogConf(DEVNODE dn, LOG_CONF* plc, DWORD* plcType);
|
|
BOOL CmReenumerate(DEVNODE dn, ULONG Flags);
|
|
BOOL CmGetHwProfileFlags(DEVNODE dn, ULONG Profile, ULONG* pFlags);
|
|
BOOL CmGetHwProfileFlags(LPCTSTR DeviceID, ULONG Profile, ULONG* pFlags);
|
|
BOOL CmSetHwProfileFlags(DEVNODE dn, ULONG Profile, ULONG Flags);
|
|
BOOL CmSetHwProfileFlags(LPCTSTR DeviceID, ULONG Profile, ULONG Flags);
|
|
BOOL CmGetCurrentHwProfile(ULONG* phwpf);
|
|
BOOL CmGetHwProfileInfo(int Index, PHWPROFILEINFO pHwProfileInfo);
|
|
BOOL CmGetBusGuid(DEVNODE dn, LPGUID Guid);
|
|
BOOL CmGetBusGuidString(DEVNODE dn, String& str);
|
|
DEVNODE CmGetParent(DEVNODE dn);
|
|
DEVNODE CmGetChild(DEVNODE dn);
|
|
DEVNODE CmGetSibling(DEVNODE dn);
|
|
DEVNODE CmGetRootDevNode();
|
|
BOOL CmHasResources(DEVNODE dn);
|
|
BOOL CmHasDrivers(DEVNODE dn);
|
|
DWORD CmGetResDesDataSize(RES_DES rd);
|
|
BOOL CmGetResDesData(RES_DES rd, PVOID pData, ULONG DataSize);
|
|
|
|
BOOL CmGetNextResDes(PRES_DES prdNext, RES_DES rd, RESOURCEID ForResource,
|
|
PRESOURCEID pTheResource);
|
|
void CmFreeResDesHandle(RES_DES rd);
|
|
void CmFreeResDes(PRES_DES prdPrev, RES_DES rd);
|
|
void CmFreeLogConfHandle(LOG_CONF lc);
|
|
int CmGetNumberOfBasicLogConf(DEVNODE dn);
|
|
BOOL CmGetFirstLogConf(DEVNODE dn, LOG_CONF* plc, ULONG Type);
|
|
BOOL CmGetNextLogConf(LOG_CONF* plcNext, LOG_CONF lcRef, ULONG Type);
|
|
ULONG CmGetArbitratorFreeDataSize(DEVNODE dn, RESOURCEID ResType);
|
|
BOOL CmGetArbitratorFreeData(DEVNODE dn, PVOID pBuffer, ULONG BufferSize,
|
|
RESOURCEID ResType);
|
|
BOOL CmTestRangeAvailable(RANGE_LIST RangeList, DWORDLONG dlBase,
|
|
DWORDLONG dlEnd);
|
|
void CmDeleteRange(RANGE_LIST RangeList, DWORDLONG dlBase, DWORDLONG dlLen);
|
|
BOOL CmGetFirstRange(RANGE_LIST RangeList, DWORDLONG* pdlBase,
|
|
DWORDLONG* pdlLen, RANGE_ELEMENT* pre);
|
|
BOOL CmGetNextRange(RANGE_ELEMENT* pre, DWORDLONG* pdlBase, DWORDLONG* pdlLen);
|
|
void CmFreeRangeList(RANGE_LIST RangeList);
|
|
BOOL CmGetDeviceIdListSize(LPCTSTR Fileter, ULONG* Size, ULONG Flags);
|
|
BOOL CmGetDeviceIdList(LPCTSTR Filter, TCHAR* Buffer, ULONG BufferSize, ULONG Flags);
|
|
CONFIGRET CmGetRegistryProperty(DEVNODE dn, ULONG Property,
|
|
PVOID pBuffer,
|
|
ULONG* BufferSize);
|
|
|
|
BOOL EnableRefresh(BOOL fEnable);
|
|
BOOL ScheduleRefresh();
|
|
void Lock()
|
|
{
|
|
EnterCriticalSection(&m_CriticalSection);
|
|
}
|
|
void Unlock()
|
|
{
|
|
LeaveCriticalSection(&m_CriticalSection);
|
|
}
|
|
CComputer* m_pComputer;
|
|
CMachine* m_ParentMachine;
|
|
UINT m_msgRefresh;
|
|
static DWORD WaitDialogThread(PVOID Parameter);
|
|
|
|
private:
|
|
|
|
// no copy constructor and no assigment operator
|
|
CMachine(const CMachine& MachineSrc);
|
|
CMachine& operator=(const CMachine& MachineSrc);
|
|
|
|
BOOL BuildClassesFromGuidList(LPGUID GuidList, DWORD Guids);
|
|
CONFIGRET CmGetRegistrySoftwareProperty(DEVNODE dn, LPCTSTR ValueName,
|
|
PVOID pBuffer, ULONG* pBufferSize);
|
|
void CreateDeviceTree(CDevice* pParent, CDevice* pSibling, DEVNODE dn);
|
|
BOOL CreateClassesAndDevices(LPCTSTR DeviceId = NULL, LPGUID ClassGuid = NULL);
|
|
void DestroyClassesAndDevices();
|
|
BOOL CreateNotifyWindow();
|
|
BOOL pGetOriginalInfName(LPTSTR InfName, String& OriginalInfName);
|
|
String m_strMachineDisplayName;
|
|
String m_strMachineFullName;
|
|
HMACHINE m_hMachine;
|
|
CONFIGRET m_LastCR;
|
|
CList<CClass*, CClass*> m_listClass;
|
|
SP_CLASSIMAGELIST_DATA m_ImageListData;
|
|
int m_ComputerIndex;
|
|
int m_ResourceIndex;
|
|
CList<CDevice*, CDevice*> m_listDevice;
|
|
DWORD m_Flags;
|
|
BOOL m_Initialized;
|
|
BOOL m_IsLocal;
|
|
BOOL m_PropertySheetShoudDestroy;
|
|
BOOL m_UserIsAGuest;
|
|
HWND m_hwndNotify;
|
|
CList<CFolder*, CFolder*> m_listFolders;
|
|
int m_RefreshDisableCounter;
|
|
BOOL m_RefreshPending;
|
|
BOOL m_ShowNonPresentDevices;
|
|
CRITICAL_SECTION m_CriticalSection;
|
|
CRITICAL_SECTION m_PropertySheetCriticalSection;
|
|
CRITICAL_SECTION m_ChildMachineCriticalSection;
|
|
CList<HWND, HWND> m_listPropertySheets;
|
|
CList<CMachine*, CMachine*> m_listChildMachines;
|
|
};
|
|
|
|
|
|
class CMachineList
|
|
{
|
|
public:
|
|
CMachineList() {};
|
|
~CMachineList();
|
|
BOOL CreateMachine(HWND hwndParent, LPCTSTR MachineName, CMachine** ppMachine);
|
|
CMachine* FindMachine(LPCTSTR MachineName);
|
|
private:
|
|
CMachineList(const CMachineList& MachineListSrc);
|
|
CMachineList& operator=(const CMachineList& MachineListSrc);
|
|
CList<CMachine*, CMachine*> m_listMachines;
|
|
};
|
|
#endif //__MACHINE_H_
|