devmgr.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	DEV_PRINT_ABSTRACT   (0)
#define	DEV_PRINT_SELECTED   (1)
#define	DEV_PRINT_ALL   (2)
#define	DPF_EXTENDED   (0x1)
#define	DPF_DEVICE_STATUS_ACTION   (0x2)
#define	DeviceManager_Execute   DeviceManager_ExecuteA
#define	DeviceProperties_RunDLL   DeviceProperties_RunDLLA
#define	DeviceProperties   DevicePropertiesA
#define	DeviceProblemText   DeviceProblemTextA
#define	DeviceProblemWizard   DeviceProblemWizardA
#define	DeviceProblemWizard_RunDLL   DeviceProblemWizard_RunDLLA
#define	DeviceManagerPrint   DeviceManagerPrintA
#define	DeviceAdvancedProperties   DeviceAdvancedPropertiesA
#define	DevicePropertiesEx   DevicePropertiesExA

Typedefs
typedef enum HWPAGE_DISPLAYMODE *	PHWPAGE_DISPLAYMODE

Enumerations
enum	HWPAGE_DISPLAYMODE {   HWPD_STANDARDLIST = 0 , HWPD_LARGELIST , HWPD_MAX = HWPD_LARGELIST , HWPD_STANDARDLIST = 0 ,   HWPD_LARGELIST , HWPD_MAX = HWPD_LARGELIST , HWPD_STANDARDLIST = 0 , HWPD_LARGELIST ,   HWPD_MAX = HWPD_LARGELIST , HWPD_STANDARDLIST = 0 , HWPD_LARGELIST , HWPD_MAX = HWPD_LARGELIST }

Functions
BOOL WINAPI	DeviceManager_ExecuteA (HWND hWndParent, HINSTANCE hInst, LPCSTR lpMachineName, int nCmdShow)
BOOL WINAPI	DeviceManager_ExecuteW (HWND hWndParent, HINSTANCE hInst, LPCWSTR lpMachineName, int nCmdShow)
VOID WINAPI	DeviceProperties_RunDLLA (HWND hWndParent, HINSTANCE hInst, LPCSTR lpDeviceCmd, int nCmdShow)
VOID WINAPI	DeviceProperties_RunDLLW (HWND hWndParent, HINSTANCE hInst, LPCWSTR lpDeviceCmd, int nCmdShow)
int WINAPI	DevicePropertiesA (HWND hWndParent, LPCSTR lpMachineName, LPCSTR lpDeviceID, BOOL bShowDevMgr)
int WINAPI	DevicePropertiesW (HWND hWndParent, LPCWSTR lpMachineName, LPCWSTR lpDeviceID, BOOL bShowDevMgr)
UINT WINAPI	DeviceProblemTextA (IN HMACHINE hMachine OPTIONAL, IN DEVINST dnDevInst, IN ULONG uProblemId, OUT LPSTR lpString, IN UINT uMaxString)
UINT WINAPI	DeviceProblemTextW (IN HMACHINE hMachine OPTIONAL, IN DEVINST dnDevInst, IN ULONG uProblemId, OUT LPWSTR lpString, IN UINT uMaxString)
BOOL WINAPI	DeviceProblemWizardA (IN HWND hWndParent OPTIONAL, IN LPCSTR lpMachineName OPTIONAL, IN LPCSTR lpDeviceID)
BOOL WINAPI	DeviceProblemWizardW (IN HWND hWndParent OPTIONAL, IN LPCWSTR lpMachineName OPTIONAL, IN LPCWSTR lpDeviceID)
VOID WINAPI	DeviceProblemWizard_RunDLLA (HWND hWndParent, HINSTANCE hInst, LPCSTR lpDeviceCmd, int nCmdShow)
VOID WINAPI	DeviceProblemWizard_RunDLLW (HWND hWndParent, HINSTANCE hInst, LPCWSTR lpDeviceCmd, int nCmdShow)
BOOL WINAPI	DeviceManagerPrintA (LPCSTR lpMachineName, LPCSTR lpPrinter, int nPrintMode, UINT uNumberOfGuids, LPGUID lpGuids)
BOOL WINAPI	DeviceManagerPrintW (LPCWSTR lpMachineName, LPCWSTR lpPrinter, int nPrintMode, UINT uNumberOfGuids, LPGUID lpGuids)
INT_PTR WINAPI	DeviceAdvancedPropertiesA (IN HWND hWndParent OPTIONAL, IN LPCSTR lpMachineName OPTIONAL, IN LPCSTR lpDeviceID)
INT_PTR WINAPI	DeviceAdvancedPropertiesW (IN HWND hWndParent OPTIONAL, IN LPCWSTR lpMachineName OPTIONAL, IN LPCWSTR lpDeviceID)
HWND WINAPI	DeviceCreateHardwarePage (HWND hWndParent, LPGUID lpGuid)
HWND WINAPI	DeviceCreateHardwarePageEx (IN HWND hWndParent, IN LPGUID lpGuids, IN UINT uNumberOfGuids, IN HWPAGE_DISPLAYMODE DisplayMode)
INT_PTR WINAPI	DevicePropertiesExA (IN HWND hWndParent OPTIONAL, IN LPCSTR lpMachineName OPTIONAL, IN LPCSTR lpDeviceID OPTIONAL, IN DWORD dwFlags OPTIONAL, IN BOOL bShowDevMgr)
INT_PTR WINAPI	DevicePropertiesExW (IN HWND hWndParent OPTIONAL, IN LPCWSTR lpMachineName OPTIONAL, IN LPCWSTR lpDeviceID OPTIONAL, IN DWORD dwFlags OPTIONAL, IN BOOL bShowDevMgr)

Macro Definition Documentation

DEV_PRINT_ABSTRACT

#define DEV_PRINT_ABSTRACT   (0)

Definition at line 93 of file devmgr.h.

DEV_PRINT_ALL

#define DEV_PRINT_ALL   (2)

Definition at line 95 of file devmgr.h.

DEV_PRINT_SELECTED

#define DEV_PRINT_SELECTED   (1)

Definition at line 94 of file devmgr.h.

DeviceAdvancedProperties

#define DeviceAdvancedProperties   DeviceAdvancedPropertiesA

Definition at line 181 of file devmgr.h.

DeviceManager_Execute

#define DeviceManager_Execute   DeviceManager_ExecuteA

Definition at line 174 of file devmgr.h.

DeviceManagerPrint

#define DeviceManagerPrint   DeviceManagerPrintA

Definition at line 180 of file devmgr.h.

DeviceProblemText

#define DeviceProblemText   DeviceProblemTextA

Definition at line 177 of file devmgr.h.

DeviceProblemWizard

#define DeviceProblemWizard   DeviceProblemWizardA

Definition at line 178 of file devmgr.h.

DeviceProblemWizard_RunDLL

#define DeviceProblemWizard_RunDLL   DeviceProblemWizard_RunDLLA

Definition at line 179 of file devmgr.h.

DeviceProperties

#define DeviceProperties   DevicePropertiesA

Definition at line 176 of file devmgr.h.

DeviceProperties_RunDLL

#define DeviceProperties_RunDLL   DeviceProperties_RunDLLA

Definition at line 175 of file devmgr.h.

DevicePropertiesEx

#define DevicePropertiesEx   DevicePropertiesExA

Definition at line 182 of file devmgr.h.

DPF_DEVICE_STATUS_ACTION

#define DPF_DEVICE_STATUS_ACTION   (0x2)

Definition at line 145 of file devmgr.h.

DPF_EXTENDED

#define DPF_EXTENDED   (0x1)

Definition at line 144 of file devmgr.h.

Typedef Documentation

PHWPAGE_DISPLAYMODE

typedef enum HWPAGE_DISPLAYMODE * PHWPAGE_DISPLAYMODE

Enumeration Type Documentation

HWPAGE_DISPLAYMODE

enum HWPAGE_DISPLAYMODE

Enumerator
HWPD_STANDARDLIST
HWPD_LARGELIST
HWPD_MAX
HWPD_STANDARDLIST
HWPD_LARGELIST
HWPD_MAX
HWPD_STANDARDLIST
HWPD_LARGELIST
HWPD_MAX
HWPD_STANDARDLIST
HWPD_LARGELIST
HWPD_MAX

Definition at line 125 of file devmgr.h.

{
    HWPD_STANDARDLIST = 0,
    HWPD_LARGELIST,
    HWPD_MAX = HWPD_LARGELIST
} HWPAGE_DISPLAYMODE, *PHWPAGE_DISPLAYMODE;

Function Documentation

DeviceAdvancedPropertiesA()

INT_PTR WINAPI DeviceAdvancedPropertiesA	(	IN HWND hWndParent	OPTIONAL,
		IN LPCSTR lpMachineName	OPTIONAL,
		IN LPCSTR	lpDeviceID
	)

Definition at line 118 of file api.cpp.

{
    LPWSTR lpMachineNameW = NULL;
    LPWSTR lpDeviceIDW = NULL;
    INT_PTR Ret = -1;
 
    if (lpMachineName != NULL)
    {
        if (!(lpMachineNameW = ConvertMultiByteToUnicode(lpMachineName,
                                                         CP_ACP)))
        {
            goto Cleanup;
        }
    }
    if (lpDeviceID != NULL)
    {
        if (!(lpDeviceIDW = ConvertMultiByteToUnicode(lpDeviceID,
                                                      CP_ACP)))
        {
            goto Cleanup;
        }
    }
 
    Ret = DeviceAdvancedPropertiesW(hWndParent,
                                    lpMachineNameW,
                                    lpDeviceIDW);
 
Cleanup:
    if (lpMachineNameW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpMachineNameW);
    }
    if (lpDeviceIDW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpDeviceIDW);
    }
 
    return Ret;
}

DeviceAdvancedPropertiesW()

INT_PTR WINAPI DeviceAdvancedPropertiesW	(	IN HWND hWndParent	OPTIONAL,
		IN LPCWSTR lpMachineName	OPTIONAL,
		IN LPCWSTR	lpDeviceID
	)

Definition at line 47 of file api.cpp.

{
    HDEVINFO hDevInfo;
    SP_DEVINFO_DATA DevInfoData;
    HINSTANCE hComCtl32;
    INT_PTR Ret = -1;
 
    if (lpDeviceID == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* dynamically load comctl32 */
    hComCtl32 = LoadAndInitComctl32();
    if (hComCtl32 != NULL)
    {
        hDevInfo = SetupDiCreateDeviceInfoListEx(NULL,
                                                 hWndParent,
                                                 lpMachineName,
                                                 NULL);
        if (hDevInfo != INVALID_HANDLE_VALUE)
        {
            DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
            if (SetupDiOpenDeviceInfo(hDevInfo,
                                      lpDeviceID,
                                      hWndParent,
                                      0,
                                      &DevInfoData))
            {
                Ret = DisplayDeviceAdvancedProperties(hWndParent,
                                                      lpDeviceID,
                                                      hDevInfo,
                                                      &DevInfoData,
                                                      hComCtl32,
                                                      lpMachineName,
                                                      0);
            }
 
            SetupDiDestroyDeviceInfoList(hDevInfo);
        }
 
        FreeLibrary(hComCtl32);
    }
 
    return Ret;
}

Referenced by DeviceAdvancedPropertiesA().

DeviceCreateHardwarePage()

HWND WINAPI DeviceCreateHardwarePage	(	HWND	hWndParent,
		LPGUID	lpGuid
	)

DeviceCreateHardwarePageEx()

HWND WINAPI DeviceCreateHardwarePageEx	(	IN HWND	hWndParent,
		IN LPGUID	lpGuids,
		IN UINT	uNumberOfGuids,
		IN HWPAGE_DISPLAYMODE	DisplayMode
	)

Definition at line 1021 of file hwpage.cpp.

{
    PHARDWARE_PAGE_DATA hpd;
 
    /* allocate the HARDWARE_PAGE_DATA structure. Make sure it is
       zeroed because the initialization code assumes that in
       failure cases! */
    hpd = (PHARDWARE_PAGE_DATA)HeapAlloc(GetProcessHeap(),
                                         HEAP_ZERO_MEMORY,
                                         DYNAMIC_FIELD_OFFSET(HARDWARE_PAGE_DATA,
                                                              ClassDevInfo[uNumberOfGuids]));
    if (hpd != NULL)
    {
        HWND hWnd;
        UINT i;
 
        hpd->DisplayMode = ((DisplayMode > HWPD_MAX) ? HWPD_STANDARDLIST : DisplayMode);
 
        /* initialize the HARDWARE_PAGE_DATA structure */
        hpd->NumberOfGuids = uNumberOfGuids;
        for (i = 0;
             i < uNumberOfGuids;
             i++)
        {
            hpd->ClassDevInfo[i].hDevInfo = INVALID_HANDLE_VALUE;
            hpd->ClassDevInfo[i].Guid = lpGuids[i];
        }
 
        /* load comctl32.dll dynamically */
        hpd->hComCtl32 = LoadAndInitComctl32();
        if (hpd->hComCtl32 == NULL)
        {
            goto Cleanup;
        }
 
        /* create the dialog */
        hWnd = CreateDialogParam(hDllInstance,
                                 MAKEINTRESOURCE(IDD_HARDWARE),
                                 hWndParent,
                                 HardwareDlgProc,
                                 (LPARAM)hpd);
        if (hWnd != NULL)
        {
            return hWnd;
        }
        else
        {
Cleanup:
            /* oops, something went wrong... */
            if (hpd->hComCtl32 != NULL)
            {
                FreeLibrary(hpd->hComCtl32);
            }
 
            HeapFree(GetProcessHeap(),
                     0,
                     hpd);
        }
    }
 
    return NULL;
}

Referenced by DeviceCreateHardwarePage().

DeviceManager_ExecuteA()

BOOL WINAPI DeviceManager_ExecuteA	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCSTR	lpMachineName,
		int	nCmdShow
	)

Definition at line 550 of file api.cpp.

{
    LPWSTR lpMachineNameW = NULL;
    BOOL Ret;
 
    if (lpMachineName != NULL)
    {
        if (!(lpMachineNameW = ConvertMultiByteToUnicode(lpMachineName,
                                                         CP_ACP)))
        {
            return FALSE;
        }
    }
 
    Ret = DeviceManager_ExecuteW(hWndParent,
                                 hInst,
                                 lpMachineNameW,
                                 nCmdShow);
 
    if (lpMachineNameW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpMachineNameW);
    }
 
 
    return Ret;
}

DeviceManager_ExecuteW()

BOOL WINAPI DeviceManager_ExecuteW	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCWSTR	lpMachineName,
		int	nCmdShow
	)

Definition at line 611 of file api.cpp.

{
    // FIXME: Call mmc with devmgmt.msc
 
    CDeviceManager DevMgr;
    return DevMgr.Create(hWndParent, hInst, lpMachineName, nCmdShow);
}

Referenced by DeviceManager_ExecuteA(), and wWinMain().

DeviceManagerPrintA()

BOOL WINAPI DeviceManagerPrintA	(	LPCSTR	lpMachineName,
		LPCSTR	lpPrinter,
		int	nPrintMode,
		UINT	uNumberOfGuids,
		LPGUID	lpGuids
	)

Definition at line 732 of file api.cpp.

{
    UNIMPLEMENTED;
    return FALSE;
}

DeviceManagerPrintW()

BOOL WINAPI DeviceManagerPrintW	(	LPCWSTR	lpMachineName,
		LPCWSTR	lpPrinter,
		int	nPrintMode,
		UINT	uNumberOfGuids,
		LPGUID	lpGuids
	)

Definition at line 776 of file api.cpp.

{
    UNIMPLEMENTED;
    return FALSE;
}

DeviceProblemTextA()

UINT WINAPI DeviceProblemTextA	(	IN HMACHINE hMachine	OPTIONAL,
		IN DEVINST	dnDevInst,
		IN ULONG	uProblemId,
		OUT LPSTR	lpString,
		IN UINT	uMaxString
	)

Definition at line 417 of file devprblm.cpp.

{
    LPWSTR lpBuffer = NULL;
    UINT Ret = 0;
 
    if (uMaxString != 0)
    {
        lpBuffer = (LPWSTR)HeapAlloc(GetProcessHeap(),
                                     0,
                                     (uMaxString + 1) * sizeof(WCHAR));
        if (lpBuffer == NULL)
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
    }
 
    Ret = DeviceProblemTextW(hMachine,
                             dnDevInst,
                             uProblemId,
                             lpBuffer,
                             uMaxString);
 
    if (lpBuffer != NULL)
    {
        if (Ret)
        {
            WideCharToMultiByte(CP_ACP,
                                0,
                                lpBuffer,
                                (int)Ret,
                                lpString,
                                (int)uMaxString,
                                NULL,
                                NULL);
        }
 
        HeapFree(GetProcessHeap(),
                 0,
                 lpBuffer);
    }
 
    return Ret;
}

DeviceProblemTextW()

UINT WINAPI DeviceProblemTextW	(	IN HMACHINE hMachine	OPTIONAL,
		IN DEVINST	dnDevInst,
		IN ULONG	uProblemId,
		OUT LPWSTR	lpString,
		IN UINT	uMaxString
	)

Definition at line 491 of file devprblm.cpp.

{
    UINT MessageId = IDS_UNKNOWN;
    UINT Ret = 0;
 
    if (uProblemId < sizeof(ProblemStringId) / sizeof(ProblemStringId[0]))
        MessageId = ProblemStringId[uProblemId];
 
    if (uProblemId == 0)
    {
        if (uMaxString != 0)
        {
            Ret = LoadString(hDllInstance,
                             MessageId,
                             lpString,
                             (int)uMaxString);
        }
        else
        {
            Ret = (UINT)LengthOfStrResource(hDllInstance,
                                            MessageId);
        }
    }
    else
    {
        LPWSTR szProblem;
        WCHAR szInfo[] = L"FIXME";
        DWORD dwRet;
        BOOL AdvFormat = FALSE;
        UINT StringIDs[] =
        {
            MessageId,
            IDS_DEVCODE,
        };
 
        switch (uProblemId)
        {
            case CM_PROB_DEVLOADER_FAILED:
            {
                /* FIXME - if not a root bus devloader then use IDS_DEV_DEVLOADER_FAILED2 */
                /* FIXME - get the type string (ie. ISAPNP, PCI or BIOS for root bus devloaders,
                           or FLOP, ESDI, SCSI, etc for others */
                AdvFormat = TRUE;
                break;
            }
 
            case CM_PROB_DEVLOADER_NOT_FOUND:
            {
                /* FIXME - 4 cases:
                   1) if it's a missing system devloader:
                      - get the system devloader name
                   2) if it's not a system devloader but still missing:
                      - get the devloader name (file name?)
                   3) if it's not a system devloader but the file can be found:
                      - use IDS_DEV_DEVLOADER_NOT_FOUND2
                   4) if it's a missing or empty software key
                      - use IDS_DEV_DEVLOADER_NOT_FOUND3
                      - AdvFormat = FALSE!
                 */
                AdvFormat = TRUE;
                break;
            }
 
            case CM_PROB_INVALID_DATA:
                /* FIXME - if the device isn't enumerated by the BIOS/ACPI use IDS_DEV_INVALID_DATA2 */
                AdvFormat = FALSE;
                break;
 
            case CM_PROB_NORMAL_CONFLICT:
                /* FIXME - get resource type (IRQ, DMA, Memory or I/O) */
                AdvFormat = TRUE;
                break;
 
            case CM_PROB_UNKNOWN_RESOURCE:
                /* FIXME - get the .inf file name */
                AdvFormat = TRUE;
                break;
 
            case CM_PROB_DISABLED:
                /* FIXME - if the device was disabled by the system use IDS_DEV_DISABLED2 */
                break;
        }
 
        if (AdvFormat)
        {
            StringIDs[1] = IDS_DEVCODE2;
            dwRet = LoadAndFormatStringsCat(hDllInstance,
                                            StringIDs,
                                            sizeof(StringIDs) / sizeof(StringIDs[0]),
                                            &szProblem,
                                            szInfo,
                                            uProblemId);
        }
        else
        {
            dwRet = LoadAndFormatStringsCat(hDllInstance,
                                            StringIDs,
                                            sizeof(StringIDs) / sizeof(StringIDs[0]),
                                            &szProblem,
                                            uProblemId);
        }
 
        if (dwRet != 0)
        {
            if (uMaxString != 0 && uMaxString >= dwRet)
            {
                wcscpy(lpString,
                       szProblem);
            }
 
            LocalFree((HLOCAL)szProblem);
 
            Ret = dwRet;
        }
    }
 
    return Ret;
}

Referenced by DeviceProblemTextA(), GetDeviceStatusString(), and InitProbeListPage().

DeviceProblemWizard_RunDLLA()

VOID WINAPI DeviceProblemWizard_RunDLLA	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCSTR	lpDeviceCmd,
		int	nCmdShow
	)

Definition at line 652 of file api.cpp.

{
    UNIMPLEMENTED;
}

DeviceProblemWizard_RunDLLW()

VOID WINAPI DeviceProblemWizard_RunDLLW	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCWSTR	lpDeviceCmd,
		int	nCmdShow
	)

Definition at line 690 of file api.cpp.

{
    UNIMPLEMENTED;
}

DeviceProblemWizardA()

BOOL WINAPI DeviceProblemWizardA	(	IN HWND hWndParent	OPTIONAL,
		IN LPCSTR lpMachineName	OPTIONAL,
		IN LPCSTR	lpDeviceID
	)

Definition at line 213 of file devprblm.cpp.

{
    LPWSTR lpMachineNameW = NULL;
    LPWSTR lpDeviceIDW = NULL;
    BOOL Ret = FALSE;
 
    if (lpMachineName != NULL)
    {
        if (!(lpMachineNameW = ConvertMultiByteToUnicode(lpMachineName,
                                                         CP_ACP)))
        {
            goto Cleanup;
        }
    }
    if (lpDeviceID != NULL)
    {
        if (!(lpDeviceIDW = ConvertMultiByteToUnicode(lpDeviceID,
                                                      CP_ACP)))
        {
            goto Cleanup;
        }
    }
 
    Ret = DeviceProblemWizardW(hWndParent,
                               lpMachineNameW,
                               lpDeviceIDW);
 
Cleanup:
    if (lpMachineNameW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpMachineNameW);
    }
    if (lpDeviceIDW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpDeviceIDW);
    }
 
    return Ret;
}

DeviceProblemWizardW()

BOOL WINAPI DeviceProblemWizardW	(	IN HWND hWndParent	OPTIONAL,
		IN LPCWSTR lpMachineName	OPTIONAL,
		IN LPCWSTR	lpDeviceID
	)

Definition at line 280 of file devprblm.cpp.

{
    HDEVINFO hDevInfo;
    SP_DEVINFO_DATA DevInfoData;
    HINSTANCE hComCtl32;
    CONFIGRET cr;
    HMACHINE hMachine;
    BOOL Ret = FALSE;
 
    if (lpDeviceID == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    /* dynamically load comctl32 */
    hComCtl32 = LoadAndInitComctl32();
    if (hComCtl32 != NULL)
    {
        hDevInfo = SetupDiCreateDeviceInfoListEx(NULL,
                                                 hWndParent,
                                                 lpMachineName,
                                                 NULL);
        if (hDevInfo != INVALID_HANDLE_VALUE)
        {
            cr = CM_Connect_Machine(lpMachineName,
                                    &hMachine);
            if (cr == CR_SUCCESS)
            {
                DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
                if (SetupDiOpenDeviceInfo(hDevInfo,
                                          lpDeviceID,
                                          hWndParent,
                                          0,
                                          &DevInfoData))
                {
                    Ret = ShowDeviceProblemWizard(hWndParent,
                                                  hDevInfo,
                                                  &DevInfoData,
                                                  hMachine);
                }
 
                CM_Disconnect_Machine(hMachine);
            }
 
            SetupDiDestroyDeviceInfoList(hDevInfo);
        }
 
        FreeLibrary(hComCtl32);
    }
 
    return Ret;
}

Referenced by DeviceProblemWizardA().

DeviceProperties_RunDLLA()

VOID WINAPI DeviceProperties_RunDLLA	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCSTR	lpDeviceCmd,
		int	nCmdShow
	)

Definition at line 443 of file api.cpp.

{
    LPWSTR lpDeviceCmdW = NULL;
 
    if (lpDeviceCmd != NULL)
    {
        if ((lpDeviceCmdW = ConvertMultiByteToUnicode(lpDeviceCmd,
                                                      CP_ACP)))
        {
            DeviceProperties_RunDLLW(hWndParent,
                                     hInst,
                                     lpDeviceCmdW,
                                     nCmdShow);
        }
    }
 
    if (lpDeviceCmdW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpDeviceCmdW);
    }
}

DeviceProperties_RunDLLW()

VOID WINAPI DeviceProperties_RunDLLW	(	HWND	hWndParent,
		HINSTANCE	hInst,
		LPCWSTR	lpDeviceCmd,
		int	nCmdShow
	)

Definition at line 498 of file api.cpp.

{
    WCHAR szDeviceID[MAX_DEVICE_ID_LEN + 1];
    WCHAR szMachineName[MAX_COMPUTERNAME_LENGTH + 1];
    LPWSTR lpString = (LPWSTR)lpDeviceCmd;
 
    if (!GetDeviceAndComputerName(lpString,
                                  szDeviceID,
                                  szMachineName))
    {
        ERR("DeviceProperties_RunDLLW DeviceID: %S, MachineName: %S\n", szDeviceID, szMachineName);
        return;
    }
 
    DevicePropertiesW(hWndParent,
                      szMachineName,
                      szDeviceID,
                      FALSE);
}

Referenced by DeviceProperties_RunDLLA().

DevicePropertiesA()

int WINAPI DevicePropertiesA	(	HWND	hWndParent,
		LPCSTR	lpMachineName,
		LPCSTR	lpDeviceID,
		BOOL	bShowDevMgr
	)

Definition at line 366 of file api.cpp.

{
    return DevicePropertiesExA(hWndParent,
                               lpMachineName,
                               lpDeviceID,
                               DPF_EXTENDED,
                               bShowDevMgr);
}

DevicePropertiesExA()

INT_PTR WINAPI DevicePropertiesExA	(	IN HWND hWndParent	OPTIONAL,
		IN LPCSTR lpMachineName	OPTIONAL,
		IN LPCSTR lpDeviceID	OPTIONAL,
		IN DWORD dwFlags	OPTIONAL,
		IN BOOL	bShowDevMgr
	)

Definition at line 193 of file api.cpp.

{
    LPWSTR lpMachineNameW = NULL;
    LPWSTR lpDeviceIDW = NULL;
    INT_PTR Ret = -1;
 
    if (lpMachineName != NULL)
    {
        if (!(lpMachineNameW = ConvertMultiByteToUnicode(lpMachineName,
                                                         CP_ACP)))
        {
            goto Cleanup;
        }
    }
    if (lpDeviceID != NULL)
    {
        if (!(lpDeviceIDW = ConvertMultiByteToUnicode(lpDeviceID,
                                                      CP_ACP)))
        {
            goto Cleanup;
        }
    }
 
    Ret = DevicePropertiesExW(hWndParent,
                              lpMachineNameW,
                              lpDeviceIDW,
                              dwFlags,
                              bShowDevMgr);
 
Cleanup:
    if (lpMachineNameW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpMachineNameW);
    }
    if (lpDeviceIDW != NULL)
    {
        HeapFree(GetProcessHeap(),
                 0,
                 lpDeviceIDW);
    }
 
    return Ret;
}

Referenced by DevicePropertiesA().

DevicePropertiesExW()

INT_PTR WINAPI DevicePropertiesExW	(	IN HWND hWndParent	OPTIONAL,
		IN LPCWSTR lpMachineName	OPTIONAL,
		IN LPCWSTR lpDeviceID	OPTIONAL,
		IN DWORD dwFlags	OPTIONAL,
		IN BOOL	bShowDevMgr
	)

Definition at line 272 of file api.cpp.

{
    INT_PTR Ret = -1;
 
    if (dwFlags & ~(DPF_EXTENDED | DPF_DEVICE_STATUS_ACTION))
    {
        FIXME("DevPropertiesExW: Invalid flags: 0x%x\n",
              dwFlags & ~(DPF_EXTENDED | DPF_DEVICE_STATUS_ACTION));
        SetLastError(ERROR_INVALID_FLAGS);
        return -1;
    }
 
    if (bShowDevMgr)
    {
        FIXME("DevPropertiesExW doesn't support bShowDevMgr!\n");
        SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
    }
    else
    {
        HDEVINFO hDevInfo;
        SP_DEVINFO_DATA DevInfoData;
        HINSTANCE hComCtl32;
 
        if (lpDeviceID == NULL)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
            return -1;
        }
 
        /* dynamically load comctl32 */
        hComCtl32 = LoadAndInitComctl32();
        if (hComCtl32 != NULL)
        {
            hDevInfo = SetupDiCreateDeviceInfoListEx(NULL,
                                                     hWndParent,
                                                     lpMachineName,
                                                     NULL);
            if (hDevInfo != INVALID_HANDLE_VALUE)
            {
                DevInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
                if (SetupDiOpenDeviceInfo(hDevInfo,
                                          lpDeviceID,
                                          hWndParent,
                                          0,
                                          &DevInfoData))
                {
                    Ret = DisplayDeviceAdvancedProperties(hWndParent,
                                                          lpDeviceID,
                                                          hDevInfo,
                                                          &DevInfoData,
                                                          hComCtl32,
                                                          lpMachineName,
                                                          dwFlags);
                }
 
                SetupDiDestroyDeviceInfoList(hDevInfo);
            }
 
            FreeLibrary(hComCtl32);
        }
    }
 
    return Ret;
}

Referenced by DevicePropertiesExA(), DevicePropertiesW(), and CDeviceView::DisplayPropertySheet().

DevicePropertiesW()

int WINAPI DevicePropertiesW	(	HWND	hWndParent,
		LPCWSTR	lpMachineName,
		LPCWSTR	lpDeviceID,
		BOOL	bShowDevMgr
	)

Definition at line 403 of file api.cpp.

{
    return DevicePropertiesExW(hWndParent,
                               lpMachineName,
                               lpDeviceID,
                               DPF_EXTENDED,
                               bShowDevMgr);
}

Referenced by DeviceProperties_RunDLLW().