hclient.c

/*++

Copyright (c) Microsoft 1998, All Rights Reserved

Module Name:

    hclient.c

Abstract:

    This module contains the code for handling HClient's main dialog box and 
    for performing/calling the appropriate other routines.

Environment:

    User mode

Revision History:

    Nov-97 : Created 

--*/

#define __HCLIENT_C__
#define LOG_FILE_NAME   NULL

//****************************************************************************
// HClient include files
//****************************************************************************

#include <windows.h>
#include <stdlib.h>
#include <wtypes.h>
#include <math.h>
#include <assert.h>
#include <dbt.h>
#include <Shellapi.h>
#include <fcntl.h>
#include <io.h>
#include "hidsdi.h"
#include "hid.h"
#include "resource.h"
#include "hclient.h"
#include "buffers.h"
#include "ecdisp.h"
#include "list.h"
#include <strsafe.h>

#pragma warning(disable:4057) // indirection to slightly different base types
#pragma warning(disable:4127) // conditional expression in constant //while (1)
#pragma warning(disable:4702) // unreachable code //ExitThead
#pragma warning(disable:28146) // Warning is meant for kernel mode drivers 
#pragma prefast(disable:17001, "By design, sample files are not internationalized.")
#pragma prefast(disable:38030, "By design, sample files are not internationalized.")

//****************************************************************************
// Local display macro definitions
//****************************************************************************

#define INPUT_BUTTON    1
#define INPUT_VALUE     2
#define OUTPUT_BUTTON   3
#define OUTPUT_VALUE    4
#define FEATURE_BUTTON  5
#define FEATURE_VALUE   6
#define HID_CAPS        7
#define DEVICE_ATTRIBUTES 8
                           
#define MAX_LB_ITEMS 200

#define MAX_WRITE_ELEMENTS 100
#define MAX_OUTPUT_ELEMENTS 50

#define CONTROL_COUNT 9
#define MAX_LABEL 128
#define MAX_VALUE 128
#define SMALL_BUFF 128

//****************************************************************************
// Macro definition to get device block from the main dialog box procedure
//****************************************************************************

#define GET_CURRENT_DEVICE(hDlg, pDevice)   \
{ \
    pDevice = NULL; \
    iIndex = (INT) SendDlgItemMessage(hDlg, \
                                      IDC_DEVICES, \
                                      CB_GETCURSEL, \
                                      0, \
                                      0); \
    if (CB_ERR != iIndex) { \
        pDevice = (PHID_DEVICE) SendDlgItemMessage(hDlg, \
                                                   IDC_DEVICES, \
                                                   CB_GETITEMDATA, \
                                                   iIndex, \
                                                   0); \
    } \
}

//****************************************************************************
// Data types local to the HClient display routines
//****************************************************************************

typedef struct rWriteDataStruct_type
{

    char szLabel[MAX_LABEL];
    char szValue[MAX_VALUE];

} rWriteDataStruct, *prWriteDataStruct;

typedef struct rGetWriteDataParams_type
{
        prWriteDataStruct   prItems;
        int                 iCount;
        
} rGetWriteDataParams, *prGetWriteDataParams;

typedef struct _DEVICE_LIST_NODE
{
    LIST_NODE_HDR   Hdr;
    HDEVNOTIFY      NotificationHandle;
    HID_DEVICE      HidDeviceInfo;
    BOOL            DeviceOpened;

} DEVICE_LIST_NODE, *PDEVICE_LIST_NODE;

//****************************************************************************
// Global program variables
//****************************************************************************

//
// Pointers to the HID.DLL functions that were added into the Win98 OSR and 
//  Windows 2000 but we're not included in the original implementation of 
//  HID.DLL in Windows 98.  By getting pointers to these functions instead of
//  statically linking with them, we can avoid the link error that would 
//  occur when this runs on Windows 98.  The typedefs to make this easier to
//  declare are also included below.
//

PGETEXTATTRIB __encoded_pointer pfnHidP_GetExtendedAttributes = NULL;

PINITREPORT   __encoded_pointer pfnHidP_InitializeReportForID = NULL;

   
//****************************************************************************
// Global module variables
//****************************************************************************
static HINSTANCE          hGInstance; //global application instance handle

static HANDLE             HIDDLLModuleHandle = NULL;

//
// Variables for handling the two different types of devices that can be loaded
//   into the system.  PhysicalDeviceList contains all the actual HID devices
//   attached via the USB bus. 
//

static LIST               PhysicalDeviceList;

//****************************************************************************
// Local data routine declarations
//****************************************************************************

VOID 
vReadDataFromControls(
    HWND hDlg,
    prWriteDataStruct prData,
    int iOffset,
    int iCount
);

INT_PTR CALLBACK 
bGetDataDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
);

INT_PTR CALLBACK 
bMainDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
);

INT_PTR CALLBACK 
bFeatureDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
);

INT_PTR CALLBACK 
bReadDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
);

VOID 
vLoadItemTypes(
    HWND hItemTypes
);

BOOL 
bGetData(
    prWriteDataStruct,
    int iCount,
    HWND hParent, 
    _In_ LPSTR pszDialogName
);

VOID 
vLoadDevices(
    HWND hDeviceCombo
);

VOID 
vFreeDeviceList(
    PHID_DEVICE  DeviceList,
    ULONG nDevices
);

VOID 
vDisplayInputButtons(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vDisplayInputValues(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vDisplayOutputButtons(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vDisplayOutputValues(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vDisplayFeatureButtons(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vDisplayFeatureValues(
    PHID_DEVICE pDevice,
    HWND hControl
);

VOID 
vWriteDataToControls(
    HWND hDlg,
    prWriteDataStruct prData,
    int iOffset,
    int iCount
);

int 
iPrepareDataFields(
    PHID_DATA pData, 
    ULONG ulDataLength, 
    rWriteDataStruct rWriteData[],
    int iMaxElements
);

BOOL 
bParseData(
    PHID_DATA pData,
    rWriteDataStruct rWriteData[],
    INT iCount,
    INT *piErrorLine
);

BOOL 
bSetButtonUsages(
    PHID_DATA     pCap,
    _In_ LPSTR    pszInputString
);

VOID
BuildReportIDList(
    IN  PHIDP_BUTTON_CAPS  phidButtonCaps,
    IN  USHORT             nButtonCaps,
    IN  PHIDP_VALUE_CAPS   phidValueCaps,
    IN  USHORT             nValueCaps,
    OUT UCHAR            **ppReportIDList,
    OUT INT               *nReportIDs
);

VOID
ReportToString(
   PHID_DATA    pData,
   _Inout_updates_bytes_(iBuffSize) LPSTR szBuff,
   UINT          iBuffSize
);

BOOL
RegisterHidDevice(
    IN  HWND                WindowHandle,
    IN  PDEVICE_LIST_NODE   DeviceNode
);

VOID
DestroyDeviceListCallback(
    IN  PLIST_NODE_HDR   ListNode
);

//****************************************************************************
// Function Definitions
//****************************************************************************
void
DumpDeviceAttr(
    _In_ PHIDD_ATTRIBUTES attr)
{
    printf("Vendor ID: 0x%x\n", attr->VendorID);
    printf("Product ID: 0x%x\n", attr->ProductID);
    printf("Version Number  0x%x\n", attr->VersionNumber);
    printf("\n");
}

void
DumpButtonInfo(
    _In_ PHIDP_BUTTON_CAPS pButton)
{
    ASSERT(pButton);

    printf("Report ID: 0x%x\n", pButton->ReportID);
    printf("Usage Page: 0x%x\n", pButton->UsagePage);
    printf("Alias: %s\n", pButton -> IsAlias ? "TRUE" : "FALSE");
    printf("Link Collection: %hu\n", pButton -> LinkCollection);
    printf("Link Usage Page: 0x%x\n", pButton -> LinkUsagePage);
    printf("Link Usage: 0x%x\n", pButton -> LinkUsage);
    if (pButton->IsRange) 
    {
        printf("Usage Min: 0x%x, Usage Max: 0x%x\n", 
            pButton->Range.UsageMin, 
            pButton->Range.UsageMax);
    }
    else
    {
        printf("Usage: 0x%x\n",pButton->NotRange.Usage);
    }
                
    if (pButton->IsRange)
    {
        printf("Data Index Min: 0x%x, Data Index Max: 0x%x\n",
            pButton->Range.DataIndexMin, 
            pButton->Range.DataIndexMax);
    }
    else
    {
        printf("DataIndex: 0x%x\n",pButton->NotRange.DataIndex);
    }

    if (pButton->IsStringRange)
    {
        printf("String Min: 0x%x, String Max: 0x%x\n",
            pButton->Range.StringMin, 
            pButton->Range.StringMax);
    }
    else
    {
        printf("String Index: 0x%x\n",pButton->NotRange.StringIndex);
    }

    if (pButton->IsDesignatorRange) 
    {
        printf("Designator Min: 0x%x, Designator Max: 0x%x\n",
            pButton->Range.DesignatorMin, 
            pButton->Range.DesignatorMax);
    }
    else
    {
        printf("Designator Index: 0x%x\n",
            pButton->NotRange.DesignatorIndex);
    }
                
    printf("Absolute: %s\n",(pButton->IsAbsolute)?"Yes":"No");
    printf("\n");
}

void
DumpValueInfo(
    _In_ PHIDP_VALUE_CAPS pValue)
{
    ASSERT(pValue);

    printf("Report ID 0x%x\n", pValue->ReportID);
    printf("Usage Page: 0x%x\n", pValue->UsagePage);
    printf("Bit size: 0x%x\n", pValue->BitSize);
    printf("Report Count: 0x%x\n", pValue->ReportCount);
    printf("Unit Exponent: 0x%x\n", pValue->UnitsExp);
    printf("Has Null: 0x%x\n", pValue->HasNull);
    printf("Alias: %s\n", pValue->IsAlias ? "TRUE" : "FALSE");

    if (pValue->IsRange)
    {
        printf("Usage Min: 0x%x, Usage Max 0x%x\n",
            pValue->Range.UsageMin, 
            pValue->Range.UsageMax);
    } 
    else
    {
        printf("Usage: 0x%x\n", pValue -> NotRange.Usage);
    } 

    if (pValue->IsRange)
    {
        printf("Data Index Min: 0x%x, Data Index Max: 0x%x\n",
            pValue->Range.DataIndexMin, 
            pValue->Range.DataIndexMax);
    } 
    else
    {
        printf("DataIndex: 0x%x\n", pValue->NotRange.DataIndex);
    } 

    printf("Physical Minimum: %d, Physical Maximum: %d\n",
        pValue->PhysicalMin, 
        pValue->PhysicalMax);

    printf("Logical Minimum: 0x%x, Logical Maximum: 0x%x\n",
        pValue->LogicalMin,
        pValue->LogicalMax);

    if (pValue->IsStringRange) 
    {
        printf("String  Min: 0x%x String Max 0x%x\n",
            pValue->Range.StringMin,
            pValue->Range.StringMax);
    } 
    else
    {
        printf("String Index: 0x%x\n",pValue->NotRange.StringIndex);
    } 

    if (pValue->IsDesignatorRange) 
    {
        printf("Designator Minimum: 0x%x, Max: 0x%x\n",
            pValue->Range.DesignatorMin, 
            pValue->Range.DesignatorMax);
    } 
    else 
    {
        printf("Designator Index: 0x%x\n",pValue->NotRange.DesignatorIndex);
    } 

    printf("Absolute: %s\n", pValue->IsAbsolute? "Yes" : "No");
    printf("\n");
}

BOOL
CLM_AttachConsole()
{
    HANDLE  stdOut = INVALID_HANDLE_VALUE;
    int     osfStdOut = -1;
    FILE    *cStdOut = NULL;

    if (AttachConsole(ATTACH_PARENT_PROCESS))
    {
        stdOut = GetStdHandle(STD_OUTPUT_HANDLE);
        if (INVALID_HANDLE_VALUE != stdOut)
        {
            osfStdOut = _open_osfhandle((intptr_t)stdOut, _O_TEXT);
            if (-1 != osfStdOut)
            {
                cStdOut = _fdopen(osfStdOut, "w");
            }
        }
    }

    if (NULL == cStdOut)
    {
        MessageBox(NULL, "Failed attaching the console", NULL, MB_OK);
        return FALSE;
    }
    else
    {
        *stdout = *cStdOut;
        printf("\n");
        return TRUE;
    }
}

void
CLM_ShowDeviceInfo(
    _In_ PHID_DEVICE pDevice)
{
    ULONG   iIndex;

    // Device Attributes
    printf("Device Attributes:\n");
    printf("------------------\n");
    DumpDeviceAttr(&pDevice->Attributes);

    // HID CAPS
    printf("HID CAPS:\n");
    printf("---------\n");
    printf("Usage Page: 0x%x\n", pDevice->Caps.UsagePage);
    printf("Input report byte length: %d\n", pDevice->Caps.InputReportByteLength);
    printf("Output report byte length: %d\n", pDevice->Caps.OutputReportByteLength);
    printf("Feature report byte length: %d\n", pDevice->Caps.FeatureReportByteLength);
    printf("Number of collection nodes: %d\n", pDevice->Caps.NumberLinkCollectionNodes);
    printf("\n");

    // Input Buttons
    if (0 == pDevice->Caps.NumberInputButtonCaps)
    {
        printf("No input buttons\n");
        printf("----------------\n");
        printf("\n");
    }
    else {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberInputButtonCaps; iIndex ++)
        {
            PHIDP_BUTTON_CAPS pButton;

            printf("Input Button #%d:\n", iIndex+1);
            printf("----------------\n");
                
            pButton = &pDevice->InputButtonCaps[iIndex];
            DumpButtonInfo(pButton);
        }
    }

    // Output Buttons
    if (0 == pDevice->Caps.NumberOutputButtonCaps)
    {
        printf("No output buttons\n");
        printf("-----------------\n");
        printf("\n");
    }
    else
    {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberOutputButtonCaps; iIndex ++)
        {
            PHIDP_BUTTON_CAPS pButton;
                
            printf("Output Button #%d:\n", iIndex+1);
            printf("-----------------\n");

            pButton = &pDevice->OutputButtonCaps[iIndex];
            DumpButtonInfo(pButton);
        }
    }

    // Feature Buttons
    if (0 == pDevice->Caps.NumberFeatureButtonCaps)
    {
        printf("No feature buttons\n");
        printf("------------------\n");
        printf("\n");
    }
    else 
    {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberFeatureButtonCaps; iIndex ++)
        {
            PHIDP_BUTTON_CAPS pButton;

            printf("Feature Button #%d:\n", iIndex+1);
            printf("------------------\n");

            pButton = &pDevice->FeatureButtonCaps[iIndex];
            DumpButtonInfo(pButton);
        }
    }

    // Input Values
    if (0 == pDevice->Caps.NumberInputValueCaps)
    {
        printf("No input values\n");
        printf("---------------\n");
        printf("\n");
    }
    else
    {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberInputValueCaps; iIndex ++)
        {
            PHIDP_VALUE_CAPS pValue;

            printf("Input Value #%d:\n", iIndex+1);
            printf("---------------\n");

            pValue = &pDevice->InputValueCaps[iIndex];
            DumpValueInfo(pValue);
        }
    }

    // Output Values
    if (0 == pDevice->Caps.NumberOutputValueCaps)
    {
        printf("No output values\n");
        printf("----------------\n");
        printf("\n");
    }
    else
    {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberOutputValueCaps; iIndex ++)
        {
            PHIDP_VALUE_CAPS pValue;

            printf("Output Value #%d:\n", iIndex+1);
            printf("----------------\n");

            pValue = &pDevice->OutputValueCaps[iIndex];
            DumpValueInfo(pValue);
        }
    }

    // Feature Values
    if (0 == pDevice->Caps.NumberFeatureValueCaps)
    {
        printf("No feature values\n");
        printf("-----------------\n");
        printf("\n");
    }
    else
    {
        for (iIndex = 0; iIndex < pDevice->Caps.NumberFeatureValueCaps; iIndex ++)
        {
            PHIDP_VALUE_CAPS pValue;

            printf("Feature Value #%d:\n", iIndex+1);
            printf("-----------------\n");

            pValue = &pDevice->FeatureValueCaps[iIndex];
            DumpValueInfo(pValue);
        }
    }
}

void
CLM_PrintInputReport(
    _In_ PHID_DEVICE  pDevice
    )
{
    ULONG   i;
    CHAR    szTempBuff[1024] = {0};

    printf("-------------------------------\n");

    printf("Raw Report Data: ");
    for (i = 0; i < pDevice->Caps.InputReportByteLength; i++) {
        printf("%02X ", (BYTE)pDevice->InputReportBuffer[i]);
    }
    printf("\n");

    if (FALSE == UnpackReport (pDevice->InputReportBuffer,
                                pDevice->Caps.InputReportByteLength,
                                HidP_Input,
                                pDevice->InputData,
                                pDevice->InputDataLength,
                                pDevice->Ppd))
    {
        printf("Failed parsing the report data\n");
    }
    else {
        printf("Parsed Data:\n");
        for (i = 0; i< pDevice->InputDataLength; i++)
        {
            ReportToString(&pDevice->InputData[i], szTempBuff, sizeof(szTempBuff));
            printf("HID_DATA[%d]: %s\n", i, szTempBuff);
        }
    }

    printf("-------------------------------\n");
}

void
CLM_SyncRead(
    _In_ PHID_DEVICE    pDevice,
    _In_ BYTE           reportID,
    _In_ ULONG          msecToSleep,
    _In_ ULONG          numReads)
{
    HID_DEVICE  syncDevice;
    ULONG       numReadsDone = 0;
    
    RtlZeroMemory(&syncDevice, sizeof(syncDevice));

    if (!OpenHidDevice(pDevice->DevicePath, 
                        TRUE,
                        FALSE,
                        FALSE,
                        FALSE,
                        &syncDevice))
    {
        printf("Failed opening the device for synchronous read.\n");
        goto Done;
    }

    printf("Synchronous read started...\n");

    while (INFINITE_READS == numReads || numReadsDone < numReads)
    {
        syncDevice.InputReportBuffer[0] = reportID;

        if (FALSE == HidD_GetInputReport(syncDevice.HidDevice,
                                         syncDevice.InputReportBuffer,
                                         syncDevice.Caps.InputReportByteLength ))
        {
            printf("HidD_GetInputReport() failed. Error: 0x%X\n", GetLastError());
            break;
        }

        numReadsDone++;

        printf("Read #%d:\n",numReadsDone);

        CLM_PrintInputReport(&syncDevice);
       
        if (msecToSleep > 0)
        {
            Sleep(msecToSleep);
        }
    }

    printf("Synchronous read stopped.\n");

Done:
    CloseHidDevice(&syncDevice);
}

void
CLM_AsyncRead(
    _In_ PHID_DEVICE pDevice,
    _In_ ULONG numReads)
{
    HID_DEVICE          asyncDevice;
    READ_THREAD_CONTEXT readContext;
    HANDLE              readThread;

    if (!OpenHidDevice(pDevice->DevicePath, 
                        TRUE,
                        FALSE,
                        FALSE,
                        FALSE,
                        &asyncDevice))
    {
        printf("Failed opening the device for asynchronous read.\n");
        return;
    }

    readContext.HidDevice = &asyncDevice;
    readContext.TerminateThread = FALSE;
    readContext.NumberOfReads = numReads;
    readContext.DisplayEvent = NULL;
    readContext.DisplayWindow = NULL;
                        
    readThread = CreateThread(  NULL,
                                0,
                                AsynchReadThreadProc,
                                &readContext,
                                CREATE_SUSPENDED,
                                NULL);
    if (NULL == readThread)
    {
        printf("Failed creating the thread for asynchronous read. Error: 0x%x",
                GetLastError());
    }
    else {
        printf("Asychronous read started.\n");
        ResumeThread(readThread);
        WaitForSingleObject(readThread, INFINITE);
        printf("Asychronous read stopped.\n");
    }

    if (readThread != NULL)
    {
        CloseHandle(readThread);
    }

    CloseHidDevice(&asyncDevice);
}

void
RunInCommandLineMode(
    _In_reads_(nArgs) LPWSTR *szArgList,
    _In_ int nArgs)
{
    DWORD       nArgCmd = 0;
    BOOL        bPrintHelp = FALSE;
    BOOL        bConsoleAttached = FALSE;
    PHID_DEVICE deviceList = NULL;
    ULONG       numDevices = 0;
    ULONG       nDevice = 0;
    ULONG       numReads = 0;
    ULONG       i;
    ULONG       reportID = 0;
    ULONG       msecToSleep = 0;

    if (nArgs < 2)
    {
        ASSERT(FALSE);
        return;
    }

    nArgCmd = wcstoul(szArgList[1], NULL, 10);

    bConsoleAttached = CLM_AttachConsole();

    if (!bConsoleAttached)
    {
        goto Done;
    }
        
    FindKnownHidDevices(&deviceList,&numDevices);

    switch (nArgCmd)
    {
    case 1:
        for (i = 0; i < numDevices; i++)
        {
            if (INVALID_HANDLE_VALUE != deviceList[i].HidDevice)
            {
                printf("Device #%d: VID: 0x%04X  PID: 0x%04X  UsagePage: 0x%X  Usage: 0x%X\n",
                        i,
                        deviceList[i].Attributes.VendorID,
                        deviceList[i].Attributes.ProductID,
                        deviceList[i].Caps.UsagePage,
                        deviceList[i].Caps.Usage);
            }
            else
            {
                printf("Device #%d: %s (error opening the device)\n",
                        i,
                        (NULL != deviceList[i].DevicePath) ? deviceList[i].DevicePath : "");
            }
        }
        break;

    case 2:
        if (nArgs < 3)
        {
            bPrintHelp = TRUE;
            break;
        }

        // Get the device ID argument
        nDevice = wcstoul(szArgList[2], NULL, 10);

        if (nDevice >= numDevices)
        {
            bPrintHelp = TRUE;
            break;
        }
        
        if (INVALID_HANDLE_VALUE == deviceList[nDevice].HidDevice)
        {
            printf("An error occurred while opening device #%d.\n", nDevice);
            break;
        }

        CLM_ShowDeviceInfo(&deviceList[nDevice]);

        break;

    case 3:
        if (nArgs < 4)
        {
            bPrintHelp = TRUE;
            break;
        }
        
        // szArgList[2]: device_num
        nDevice = wcstoul(szArgList[2], NULL, 10);
        if (nDevice >= numDevices)
        {
            bPrintHelp = TRUE;
            break;
        }
        
        if (INVALID_HANDLE_VALUE == deviceList[nDevice].HidDevice)
        {
            printf("An error occurred while opening device #%d.\n", nDevice);
            break;
        }

        // szArgList[3]: report_ID
        reportID = wcstoul(szArgList[3], NULL, 10);
        if (reportID>255) {
            bPrintHelp = TRUE;
            break;
        }

        // szArgList[4]: msec_to_sleep
        if (nArgs >= 5)
        {
            msecToSleep = wcstoul(szArgList[4], NULL, 10);
        }

        // szArgList[5]: num_reads
        if (nArgs >= 6)
        {
            numReads = wcstoul(szArgList[5], NULL, 10);
            if (0 == numReads)
            {
                numReads = 1;
            }
        }
        else
        {
            numReads = INFINITE_READS;
        }
        
        CLM_SyncRead(&deviceList[nDevice], (BYTE)reportID, msecToSleep, numReads);

        break;

    case 4:
        if (nArgs < 3)
        {
            bPrintHelp = TRUE;
            break;
        }
        
        // szArgList[2]: device_num
        nDevice = wcstoul(szArgList[2], NULL, 10);
        if (nDevice >= numDevices)
        {
            bPrintHelp = TRUE;
            break;
        }
        
        if (INVALID_HANDLE_VALUE == deviceList[nDevice].HidDevice)
        {
            printf("An error occurred while opening device #%d.\n", nDevice);
            break;
        }

        // szArgList[3]: num_reads
        if (nArgs >= 4)
        {
            numReads = wcstoul(szArgList[3], NULL, 10);
            if (0 == numReads)
            {
                numReads = 1;
            }
        }
        else
        {
            numReads = INFINITE_READS;
        }

        CLM_AsyncRead(&deviceList[nDevice], numReads);

        break;

    default:
        bPrintHelp = TRUE;
    }

    if (bPrintHelp)
    {
        printf("Syntax:  HCLIENT.EXE <action> [arguments]\n"
               "\n"
               " action: 1 - List HID devices.\n"
               "\n"
               "         2 - Show device info.\n"
               "             arguments: device_num\n"
               "\n"
               "         3 - Do sync reads by calling HidD_GetInputReport.\n"
               "             arguments: device_num report_id [msec_to_sleep] [num_of_reads]\n"
               "\n"
               "         4 - Do async reads by calling ReadFile.\n"
               "             arguments: device_num [num_of_reads]\n");
    }

    printf("Press enter to exit.\n");

Done:
    if (NULL != deviceList)
    {
        free(deviceList);
        deviceList = NULL;
    }

    if (bConsoleAttached)
    {
        FreeConsole();
        bConsoleAttached = FALSE;
    }
}


/*******************************
*WinMain: Windows Entry point  *
*******************************/
int PASCAL 
WinMain(
    _In_ HINSTANCE hInstance,
    _In_opt_ HINSTANCE hPrevInstance,
    _In_ LPSTR     lpCmdLine,
    _In_ int       nCmdShow
)
{
    LPWSTR  *szArgList = NULL;
    int     nArgs;

    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    UNREFERENCED_PARAMETER(nCmdShow);

    //
    // Save instance of the application for further reference
    //

    hGInstance = hInstance;

    //
    // Attempt to load HID.DLL...This should already be loaded due to the 
    //  static linking of HID.DLL to this app on compilation.  However,
    //  to insure that this application runs on Windows 98 gold, we cannot
    //  directly reference the new functions HidP_GetExtendedAttributes and 
    //  HidP_InitializeReportForID so to use them, we'll get pointers to their
    //  functions instead.
    //

    HIDDLLModuleHandle = LoadLibrary("HID.DLL");

    if (NULL == HIDDLLModuleHandle) 
    {
        //
        // Something really bad happened here...Throw up and error dialog
        //  and bolt.
        //

        MessageBox(NULL, 
                   "Unable to open HID.DLL\n"
                   "This should never occur",
                   HCLIENT_ERROR,
                   MB_ICONSTOP);

        goto Done;
    }

    //
    // Get the function pointers,
    //

    pfnHidP_GetExtendedAttributes = (PGETEXTATTRIB) GetProcAddress(HIDDLLModuleHandle,
                                                                   "HidP_GetExtendedAttributes");

    pfnHidP_InitializeReportForID = (PINITREPORT) GetProcAddress(HIDDLLModuleHandle,
                                                                 "HidP_InitializeReportForID");

    if (NULL == pfnHidP_GetExtendedAttributes ||
        NULL == pfnHidP_InitializeReportForID)
    {
        goto Done;
    }

    szArgList = CommandLineToArgvW(GetCommandLineW(), &nArgs);

    if (NULL != szArgList && nArgs > 1)
    {
        //
        // Command Line mode
        //

        RunInCommandLineMode(szArgList, nArgs);
    }
    else
    {
        //
        // Try to create the main dialog box.  Cannot do much else if it fails
        //   so we'll throw up a message box and then exit the app
        //

        if (-1 == DialogBox(hInstance, "MAIN_DIALOG", NULL, bMainDlgProc)) 
        {
            MessageBox(NULL,
                       "Unable to create root dialog!",
                       "DialogBox failure",
                       MB_ICONSTOP);
        }
    }

Done:
    if (NULL != szArgList)
    {
        LocalFree(szArgList);
        szArgList = NULL;
    }

    if (NULL != HIDDLLModuleHandle)
    {
        FreeLibrary (HIDDLLModuleHandle);
    }

    return (0);
}
 
/*************************************************
 * Main Dialog proc                              *
 *************************************************/

//
// This the dialog box procedure for the main dialog display.
//

INT_PTR CALLBACK 
bMainDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
)
{
    static HWND                             hComboCtrl;
    static rWriteDataStruct                 rWriteData[MAX_OUTPUT_ELEMENTS];
    static HDEVNOTIFY                       diNotifyHandle;
    INT                              iIndex;
    INT                              iCount;
    CHAR                             szTempBuff[SMALL_BUFF];
    PHID_DEVICE                      pDevice;
    PHIDP_BUTTON_CAPS                pButtonCaps;
    PHIDP_VALUE_CAPS                 pValueCaps;
    INT                              iErrorLine;
    INT                              iItemType;
    PHID_DEVICE                      tempDeviceList = NULL;
    ULONG                            numberDevices;
    PDEVICE_LIST_NODE                listNode;
    DEV_BROADCAST_DEVICEINTERFACE    broadcastInterface;
    HID_DEVICE                       writeDevice;
    BOOL                             status = FALSE;
    PDEV_BROADCAST_HDR               broadcastHdr;

    ZeroMemory(&writeDevice, sizeof(writeDevice));

    switch (message)
    {
        case WM_INITDIALOG:

            //
            // Initialize the device list.
            //  -- PhysicalDeviceList is for devices that are actually attached
            //     to the HID bus
            //
            
            InitializeList(&PhysicalDeviceList);
            
            //
            // Begin by finding all the Physical HID devices currently attached to
            //  the system. If that fails, exit the dialog box.  
            //
            
            if (!FindKnownHidDevices(&tempDeviceList, &numberDevices)) 
            {
                EndDialog(hDlg, 0);
                return FALSE;                
            }
          
            //
            // For each device in the newly acquired list, create a device list
            //  node and add it the the list of physical device on the system  
            //
            
            pDevice = tempDeviceList;
            for (iIndex = 0; (ULONG) iIndex < numberDevices; iIndex++, pDevice++)
            {
                listNode = malloc(sizeof(DEVICE_LIST_NODE));

                if (NULL == listNode) {

                    //
                    // When freeing up the device list, we need to kill those
                    //  already in the Physical Device List and close
                    //  that have not been added yet in the enumerated list
                    //
                    
                    DestroyListWithCallback(&PhysicalDeviceList, DestroyDeviceListCallback);

                    CloseHidDevices(pDevice, numberDevices - iIndex);

                    free(tempDeviceList);
                    
                    EndDialog(hDlg, 0);
                    return FALSE;
                }

                listNode -> HidDeviceInfo = *pDevice;
                listNode -> DeviceOpened = (INVALID_HANDLE_VALUE == pDevice->HidDevice) ? FALSE : TRUE;

                if (listNode -> DeviceOpened)
                {
                    //
                    // Register this device node with the PnP system so the dialog
                    //  window can recieve notification if this device is unplugged.
                    //

                    if (!RegisterHidDevice(hDlg, listNode)) 
                    {
                        StringCbPrintf(szTempBuff,
                                       SMALL_BUFF,
                                       "Failed registering device notifications for device #%d. Device changes won't be handled",
                                       iIndex);

                        MessageBox(hDlg,
                                   szTempBuff,
                                   HCLIENT_ERROR,
                                   MB_ICONEXCLAMATION);
                    }
                }

                InsertTail(&PhysicalDeviceList, listNode);
            }

            //
            // Free the temporary device list...It is no longer needed
            //
            
            free(tempDeviceList);
            
            //
            // Register for notification from the HidDevice class.  Doing so 
            //  allows the dialog box to receive device change notifications 
            //  whenever a new HID device is added to the system
            //  

            broadcastInterface.dbcc_size = sizeof(DEV_BROADCAST_DEVICEINTERFACE);
            broadcastInterface.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;

            HidD_GetHidGuid(&broadcastInterface.dbcc_classguid);

            diNotifyHandle = RegisterDeviceNotification(hDlg,
                                                        &broadcastInterface,
                                                        DEVICE_NOTIFY_WINDOW_HANDLE
                                                       );
            if (NULL == diNotifyHandle)
            {
                MessageBox(hDlg,
                           "Failed registering HID device class notifications. New devices won't be handled.",
                            HCLIENT_ERROR,
                            MB_ICONEXCLAMATION);
            }
                    
            //
            // Update the device list box...
            // 
            //

            vLoadDevices(GetDlgItem(hDlg, IDC_DEVICES));

            //
            // Load the types box
            //
            
            vLoadItemTypes(GetDlgItem(hDlg, IDC_TYPE));
                          
            //
            // Post a message that the device changed so the appropriate
            //   data for the first device in the system can be displayed
            //

            PostMessage(hDlg,
                        WM_COMMAND,
                        IDC_DEVICES + (CBN_SELCHANGE<<16),
                        (LPARAM) GetDlgItem(hDlg, IDC_DEVICES));

            break; // end WM_INITDIALOG case

        case WM_COMMAND:

            switch(LOWORD(wParam))
            {
                //
                // For a read, simply get the current device instance
                //   from the DEVICES combo box and call the read procedure
                //   with the HID_DEVICE block 
                //

                case IDC_READ:
                    GET_CURRENT_DEVICE(hDlg, pDevice);

                    if (NULL != pDevice)
                    {
                        DialogBoxParam(hGInstance,
                                                      "READDATA",
                                                      hDlg,
                                                      bReadDlgProc,
                                                      (LPARAM) pDevice);
                    } 
                    break;

                //
                // For a write, the following steps are performed:
                //   1) Get the current device data from the combo box
                //   2) Prepare the data fields for display based on the data
                //       output data stored in the device data
                //   3) Retrieve the data the from the user that is to be sent
                //       to the device
                //   4) If all goes well and the data parses correctly, send the
                //        the new data values to the device
                //

                case IDC_WRITE:

                    GET_CURRENT_DEVICE(hDlg, pDevice);

                    if (NULL != pDevice) 
                    {
                        //
                        // In order to write to the device, need to get a
                        //  writable handle to the device.  In this case, the
                        //  write will be a synchronous write.  Begin by
                        //  trying to open a second instance of this device with
                        //  write access
                        //
                        
                        status = OpenHidDevice(pDevice -> DevicePath, 
                                                FALSE,
                                                TRUE,
                                                FALSE,
                                                FALSE,
                                                &writeDevice);
                                            
                        if (!status) 
                        {
                            MessageBox(hDlg,
                                       "Couldn't open device for write access",
                                       HCLIENT_ERROR,
                                       MB_ICONEXCLAMATION);
                        }
                        else 
                        {
                            iCount = iPrepareDataFields(writeDevice.OutputData,
                                                        writeDevice.OutputDataLength,
                                                        rWriteData,
                                                        MAX_OUTPUT_ELEMENTS);

                            if (bGetData(rWriteData, iCount, hDlg, "WRITEDATA"))
                            {

                                if (bParseData(writeDevice.OutputData, rWriteData, iCount, &iErrorLine))
                                {
                                    Write(&writeDevice);
                                }
                                else
                                {
                                    if (FAILED(StringCbPrintf(szTempBuff,
                                                   SMALL_BUFF,
                                                   "Unable to parse line %x of output data",
                                                   iErrorLine)))
                                    {
                                        MessageBox(hDlg,
                                                   "StringCbPrintf failed",
                                                   HCLIENT_ERROR,
                                                   MB_ICONEXCLAMATION);
                                    }
                                    else
                                    {
                                        MessageBox(hDlg,
                                                   szTempBuff,
                                                   HCLIENT_ERROR,
                                                   MB_ICONEXCLAMATION);
                                    }
                                }
                            }
                            CloseHidDevice(&writeDevice);
                        }                            
                        
                    } 
                    break; //end case IDC_WRITE//
                    
                //
                // For processing features, get the current device data and call
                //   the Features dialog box,  This dialog box will deal with 
                //   sending and retrieving the features.
                //

                case IDC_FEATURES:
                    GET_CURRENT_DEVICE(hDlg, pDevice);

                    if (NULL != pDevice) 
                    {
                        DialogBoxParam(hGInstance, 
                                                      "FEATURES", 
                                                      hDlg, 
                                                      bFeatureDlgProc, 
                                                      (LPARAM) pDevice);
                    }
                    break;
                    
                //
                // Likewise with extended calls dialog box.  This procedure
                //   passes the address to the device data structure and lets
                //   the dialog box procedure manipulate the data however it 
                //   wants to.
                //

                case IDC_EXTCALLS:
                    GET_CURRENT_DEVICE(hDlg, pDevice);

                    if (NULL != pDevice) 
                    {
                        DialogBoxParam(hGInstance,
                                                      "EXTCALLS",
                                                      hDlg,
                                                      bExtCallDlgProc,
                                                      (LPARAM) pDevice);
                    }
                    break;
                                          
                //
                // If there was a device change, issue an IDC_TYPE
                //   change to insure that the currently displayed types are
                //    updated to reflect the values of the device that has
                //    been selected
                //

                case IDC_DEVICES:
                    switch (HIWORD(wParam)) 
                    {
                        case CBN_SELCHANGE:

                            GET_CURRENT_DEVICE(hDlg, pDevice);

                            EnableWindow(GetDlgItem(hDlg, IDC_EXTCALLS),
                                         (pDevice != NULL));

                            EnableWindow(GetDlgItem(hDlg, IDC_READ), 
                                         (pDevice != NULL) && 
                                         (pDevice -> Caps.InputReportByteLength));

                            EnableWindow(GetDlgItem(hDlg, IDC_WRITE), 
                                         (pDevice != NULL) && 
                                         (pDevice -> Caps.OutputReportByteLength));
                                         
                            EnableWindow(GetDlgItem(hDlg, IDC_FEATURES),
                                         (pDevice != NULL) && 
                                         (pDevice -> Caps.FeatureReportByteLength));
                                         
                            PostMessage(hDlg,
                                        WM_COMMAND,
                                        IDC_TYPE + (CBN_SELCHANGE<<16),
                                        (LPARAM) GetDlgItem(hDlg,IDC_TYPE));
                            break;

                    } 
                    break;

                //
                // On a type change, retrieve the currently active device
                //   from the IDC_DEVICES box and display the data that 
                //   corresponds to the item just selected
                //
                
                case IDC_TYPE:
                    switch (HIWORD(wParam))
                    {
                        case CBN_SELCHANGE:
                            GET_CURRENT_DEVICE(hDlg, pDevice);
                            
                            SendDlgItemMessage(hDlg,
                                               IDC_ITEMS,
                                               LB_RESETCONTENT,
                                               0,
                                               0);

                            SendDlgItemMessage(hDlg,
                                               IDC_ATTRIBUTES,
                                               LB_RESETCONTENT,
                                               0,
                                               0);
                            
                            if (NULL != pDevice)
                            {
                                iIndex = (INT) SendDlgItemMessage(hDlg,
                                                                  IDC_TYPE,
                                                                  CB_GETCURSEL,
                                                                  0,
                                                                  0);

                                iItemType = (INT) SendDlgItemMessage(hDlg,
                                                                     IDC_TYPE,
                                                                     CB_GETITEMDATA,
                                                                     iIndex,
                                                                     0);

                                switch(iItemType)
                                {
                                    case INPUT_BUTTON:
                                        vDisplayInputButtons(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                        break;

                                    case INPUT_VALUE:
                                         vDisplayInputValues(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                         break;

                                    case OUTPUT_BUTTON:
                                        vDisplayOutputButtons(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                        break;

                                    case OUTPUT_VALUE:
                                        vDisplayOutputValues(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                        break;

                                    case FEATURE_BUTTON:
                                        vDisplayFeatureButtons(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                        break;

                                    case FEATURE_VALUE:
                                        vDisplayFeatureValues(pDevice,GetDlgItem(hDlg,IDC_ITEMS));
                                        break;
                                } 

                                PostMessage(hDlg,
                                            WM_COMMAND,
                                            IDC_ITEMS + (LBN_SELCHANGE << 16),
                                            (LPARAM) GetDlgItem(hDlg,IDC_ITEMS));
                            } 
                            break; // case CBN_SELCHANGE

                    } //end switch HIWORD wParam
                    break; //case IDC_TYPE control

                case IDC_ITEMS:
                    switch(HIWORD(wParam))
                    {
                        case LBN_SELCHANGE:

                            iItemType = 0;

                            iIndex = (INT) SendDlgItemMessage(hDlg,
                                                              IDC_TYPE,
                                                              CB_GETCURSEL,
                                                              0,
                                                              0);

                            if (-1 != iIndex)
                            {
                                iItemType = (INT) SendDlgItemMessage(hDlg,
                                                                     IDC_TYPE,
                                                                     CB_GETITEMDATA,
                                                                     iIndex,
                                                                     0);
                            }

                            iIndex = (INT) SendDlgItemMessage(hDlg,
                                                              IDC_ITEMS,
                                                              LB_GETCURSEL,
                                                              0,
                                                              0);

                            switch (iItemType)
                            {
                                case INPUT_BUTTON:
                                case OUTPUT_BUTTON:
                                case FEATURE_BUTTON:

                                    pButtonCaps = NULL;

                                    if (-1 != iIndex)
                                    {
                                        pButtonCaps = (PHIDP_BUTTON_CAPS) SendDlgItemMessage(hDlg,
                                                                                             IDC_ITEMS,
                                                                                             LB_GETITEMDATA,
                                                                                             iIndex,
                                                                                             0);
                                    }

                                    SendDlgItemMessage(hDlg, IDC_ATTRIBUTES, LB_RESETCONTENT, 0, 0);
                                    if (NULL != pButtonCaps)
                                    {
                                        vDisplayButtonAttributes(pButtonCaps, GetDlgItem(hDlg,IDC_ATTRIBUTES));
                                    }
                                    break;

                                case INPUT_VALUE:
                                case OUTPUT_VALUE:
                                case FEATURE_VALUE:

                                    pValueCaps = NULL;

                                    if (-1 != iIndex)
                                    {
                                        pValueCaps = (PHIDP_VALUE_CAPS) SendDlgItemMessage(hDlg,
                                                                                             IDC_ITEMS,
                                                                                             LB_GETITEMDATA,
                                                                                             iIndex,
                                                                                             0);
                                    }

                                    SendDlgItemMessage(hDlg, IDC_ATTRIBUTES, LB_RESETCONTENT, 0, 0);

                                    if (NULL != pValueCaps) 
                                    {
                                        vDisplayValueAttributes(pValueCaps,GetDlgItem(hDlg,IDC_ATTRIBUTES));
                                    }
                                    break;

                                case HID_CAPS:
                                    GET_CURRENT_DEVICE(hDlg, pDevice);

                                    if (NULL != pDevice)
                                    {
                                        vDisplayDeviceCaps(&(pDevice -> Caps),GetDlgItem(hDlg,IDC_ATTRIBUTES));
                                    }
                                    break;

                                case DEVICE_ATTRIBUTES:
                                    GET_CURRENT_DEVICE(hDlg, pDevice);

                                    if (NULL != pDevice) 
                                    {
                                        SendDlgItemMessage(hDlg, IDC_ATTRIBUTES, LB_RESETCONTENT, 0, 0);

                                        vDisplayDeviceAttributes(&(pDevice -> Attributes) ,GetDlgItem(hDlg,IDC_ATTRIBUTES));
                                    }
                                    break;

                            } //end switch iItemType//
                            break; //end case LBN_SELCHANGE in IDC_ITEMS//

                    } //end switch HIWORD wParam//
                    break; //case IDC_ITEMS//

                case IDC_ABOUT:

                    MessageBox(hDlg,
                               "Sample HID client Application.  Microsoft Corp \nCopyright (C) 1997",
                               "About HClient",
                               MB_ICONINFORMATION);
                    break;

                case IDOK:
                case IDCANCEL:

                    //
                    // Destroy the physical device list for exit
                    //

                    DestroyListWithCallback(&PhysicalDeviceList, DestroyDeviceListCallback);

                    EndDialog(hDlg,0);

                    break;

            } //end switch wParam//
            break;

        //
        // For a device change message, we are only concerned about the 
        //    DBT_DEVICEREMOVECOMPLETE and DBT_DEVICEARRIVAL events. I have
        //    yet to determine how to process the device change message
        //    only for HID devices.  Therefore, there are two problems
        //    with the below implementation.  First of all, we must reload
        //    the device list any time a device is added to the system.  
        //    Secondly, at least two DEVICEARRIVAL messages are received 
        //    per HID.  One corresponds to the physical device.  The second
        //    change and any more correspond to each collection on the 
        //    physical device so a system that has one HID device with
        //    two top level collections (a keyboard and a mouse) will receive
        //    three DEVICEARRIVAL/REMOVALs causing the program to reload it's
        //    device list more than once.
        //

        //
        // To handle dynamic changing of devices, we have already registered
        //    notification for both HID class changes and for notification 
        //    for our open file objects.  Since we are only concerned about
        //    arrival/removal of devices, we only need to process those wParam.
        //    lParam points to some sort of DEV_BROADCAST_HDR struct.  For device
        //    arrival, we only deal with the message if that struct is a 
        //    DEV_BROADCAST_DEVICEINTERFACE structure.  For device removal, we're
        //    only concerned if the struct is a DEV_BROADCAST_HANDLE structure.
        //

        case WM_DEVICECHANGE:
            switch (wParam) 
            {

                case DBT_DEVICEARRIVAL:

                    broadcastHdr = (PDEV_BROADCAST_HDR) lParam;

                    if (DBT_DEVTYP_DEVICEINTERFACE == broadcastHdr -> dbch_devicetype)
                    {
                        PDEV_BROADCAST_DEVICEINTERFACE  pbroadcastInterface;
                        PDEVICE_LIST_NODE               currNode, nextNode;
                        BOOLEAN                         phyDevListChanged = FALSE;
                        
                        pbroadcastInterface = (PDEV_BROADCAST_DEVICEINTERFACE) lParam;

                        //
                        // Search for a previous instance of this device
                        //  in the device list...In some cases, multiple
                        //  messages are received for the same device.  We
                        //  obviously only want one instance of the device
                        //  showing up in the dialog box.
                        //

                        currNode = (PDEVICE_LIST_NODE) GetListHead(&PhysicalDeviceList);
                            
                        //
                        // Check if the device is already in the list
                        //  - If yes and the device is opened, ignore this notification.
                        //  - If yes but the device is not opened, remove this node and 
                        //     then continne to process it as a new device. (We may have
                        //     failed opening this device earlier, so it was not removed
                        //     the list when the device was removed. Now it's connected
                        //     again and we should keep only one instance in the list.)
                        //  - If no, continue to process it as a new device.
                        //
                            
                        while (currNode != (PDEVICE_LIST_NODE)&PhysicalDeviceList)
                        {
                            //
                            // save the next node pointer first as we may remove 
                            //  the current node.
                            //

                            nextNode = (PDEVICE_LIST_NODE) GetNextEntry(currNode);

                            if ((NULL != currNode->HidDeviceInfo.DevicePath) &&
                                (0 == strcmp(currNode -> HidDeviceInfo.DevicePath, 
                                            pbroadcastInterface -> dbcc_name))) 
                            {
                                if (currNode -> DeviceOpened == FALSE)
                                {
                                    //
                                    // Remove the node from the list
                                    //

                                    RemoveNode(currNode);

                                    //
                                    // Let it free the memory of the device path string
                                    //

                                    CloseHidDevice(&currNode -> HidDeviceInfo);

                                    //
                                    // Free the memory of the node structure
                                    //

                                    free(currNode);
                                    
                                    phyDevListChanged = TRUE;
                                }
                                else
                                {
                                    return (TRUE);
                                }
                            }
                                
                            //
                            // Move to the next node
                            //
                            currNode = nextNode;
                        }

                        //
                        // In this structure, we are given the name of the device
                        //    to open.  So all that needs to be done is open 
                        //    a new hid device with the string
                        //

                        listNode = (PDEVICE_LIST_NODE) malloc(sizeof(DEVICE_LIST_NODE));

                        if (NULL == listNode)
                        {
                            MessageBox(hDlg,
                               "Error -- Couldn't allocate memory for new device list node",
                               HCLIENT_ERROR,
                               MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL);
                        }
                        else
                        {
                       
                            //
                            // Open the hid device for query access
                            //
                        
                            if (!OpenHidDevice (pbroadcastInterface -> dbcc_name,
                                                FALSE,
                                                FALSE,
                                                FALSE,
                                                FALSE,
                                                &(listNode -> HidDeviceInfo)))
                            {
                                //
                                // Save the device path so it can be still listed.
                                //

                                INT     iDevicePathSize;

                                iDevicePathSize = (INT)strlen(pbroadcastInterface -> dbcc_name) + 1;

                                listNode -> HidDeviceInfo.DevicePath = malloc(iDevicePathSize);

                                if (NULL == listNode -> HidDeviceInfo.DevicePath) 
                                {
                                    MessageBox(hDlg,
                                       "Error -- Couldn't allocate memory for new device path",
                                       HCLIENT_ERROR,
                                       MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL);
                                
                                    free(listNode);
                                    
                                    listNode = NULL;
                                }
                                else
                                {
                                    StringCbCopy(listNode -> HidDeviceInfo.DevicePath, iDevicePathSize, pbroadcastInterface -> dbcc_name);
                                }
                            }

                            if (NULL != listNode)
                            {
                                listNode -> DeviceOpened = (INVALID_HANDLE_VALUE == listNode -> HidDeviceInfo.HidDevice) ? FALSE : TRUE;

                                if (listNode -> DeviceOpened) {

                                    if (!RegisterHidDevice(hDlg, listNode))
                                    {
                                        MessageBox(hDlg,
                                           "Error -- Couldn't register handle notification",
                                           HCLIENT_ERROR,
                                           MB_ICONEXCLAMATION | MB_OK | MB_TASKMODAL);
                                    }
                                }

                                InsertTail(&PhysicalDeviceList, listNode);
                            
                                phyDevListChanged = TRUE;
                            }
                        }

                        if (phyDevListChanged)
                        {
                            vLoadDevices(GetDlgItem(hDlg,IDC_DEVICES));

                            PostMessage(hDlg,
                                       WM_COMMAND,
                                       IDC_DEVICES + (CBN_SELCHANGE << 16),
                                       (LPARAM) GetDlgItem(hDlg,IDC_DEVICES));
                        }
                    }
                    break;

                case DBT_DEVICEQUERYREMOVE:

                    //
                    // If this message is received, the device is either
                    //  being disabled or removed through device manager.
                    //  To properly handle this request, we need to close
                    //  the handle to the device.
                    //

                    broadcastHdr = (PDEV_BROADCAST_HDR) lParam;

                    if (DBT_DEVTYP_HANDLE == broadcastHdr -> dbch_devicetype)
                    {
                        PDEV_BROADCAST_HANDLE broadcastHandle;
                        PDEVICE_LIST_NODE     currNode;
                        HDEVNOTIFY            notificationHandle;
                        
                        broadcastHandle = (PDEV_BROADCAST_HANDLE) lParam;
                        
                        //
                        // Get the handle to the notification registration
                        //
                        
                        notificationHandle = broadcastHandle -> dbch_hdevnotify;

                        //
                        // Search the physical device list for the handle that
                        //  was removed...
                        //

                        currNode = (PDEVICE_LIST_NODE) GetListHead(&PhysicalDeviceList);

                        //
                        // Find out the device to close its handle
                        //
                        
                        while (currNode != (PDEVICE_LIST_NODE)&PhysicalDeviceList)
                        {
                            if (currNode ->NotificationHandle == notificationHandle)
                            {
                                if (currNode -> DeviceOpened)
                                {
                                    CloseHidDevice(&(currNode -> HidDeviceInfo));

                                    currNode -> DeviceOpened = FALSE;
                                }
                            
                                break;
                            }

                            currNode = (PDEVICE_LIST_NODE) GetNextEntry(currNode);
                        }

                    }
                    return (TRUE);

                case DBT_DEVICEREMOVEPENDING:
                case DBT_DEVICEREMOVECOMPLETE:

                    //
                    // Do the same steps for DBT_DEVICEREMOVEPENDING and 
                    //   DBT_DEVICEREMOVECOMPLETE.  We do not receive the 
                    //   remove complete request for a device if it is
                    //   disabled or removed via Device Manager.  However,
                    //   in that case will receive the remove pending.  
                    //   We remove the device from our currently displayed
                    //   list of devices and unregister notification.
                    //
                    
                    broadcastHdr = (PDEV_BROADCAST_HDR) lParam;

                    if (DBT_DEVTYP_HANDLE == broadcastHdr -> dbch_devicetype)
                    {
                        PDEV_BROADCAST_HANDLE broadcastHandle;
                        PDEVICE_LIST_NODE     currNode;
                        HDEVNOTIFY            notificationHandle;
                        
                        broadcastHandle = (PDEV_BROADCAST_HANDLE) lParam;

                        //
                        // Get the handle for device notification
                        //
                        
                        notificationHandle = broadcastHandle -> dbch_hdevnotify;

                        //
                        // Search the physical device list for the handle that
                        //  was removed...
                        //

                        currNode = (PDEVICE_LIST_NODE) GetListHead(&PhysicalDeviceList);

                        while (currNode != (PDEVICE_LIST_NODE)&PhysicalDeviceList)
                        {
                            if(currNode ->NotificationHandle == notificationHandle)
                            {
                                //
                                // Node in PhysicalDeviceList has been found, do:
                                //  1) Unregister notification
                                //  2) Close the hid device
                                //  3) Remove the entry from the list
                                //  4) Free the memory for the entry
                                //

                                PostMessage(hDlg, 
                                            WM_UNREGISTER_HANDLE, 
                                            0, 
                                            (LPARAM) currNode -> NotificationHandle);

                                //
                                // Close the device if still opened...This would 
                                //  occur on surprise removal.
                                //

                                if (currNode -> DeviceOpened) 
                                {
                                    CloseHidDevice(&(currNode -> HidDeviceInfo));
                                }

                                RemoveNode(currNode);

                                free(currNode);
                
                                //
                                // Reload the device list
                                //
                        
                                vLoadDevices(GetDlgItem(hDlg,IDC_DEVICES));

                                PostMessage(hDlg,
                                           WM_COMMAND,
                                           IDC_DEVICES + (CBN_SELCHANGE << 16),
                                           (LPARAM) GetDlgItem(hDlg,IDC_DEVICES));
                                break;
                            }

                            //
                            // The node has not been found yet. Move on to the next
                            //

                            currNode = (PDEVICE_LIST_NODE) GetNextEntry(currNode);
                        }

                        return TRUE;
                    }
                    break;
    
                default:
                    break;
            }
            break;

        //
        // Application specific message used to defer the unregistering of a 
        //  file object for device change notification.  This separte message
        //  is sent when a WM_DEVICECHANGE (DBT_DEVICEREMOVECOMPLETE) has been
        //  received.  The Unregistering of the notification must be deferred
        //  until after the WM_DEVICECHANGE message has been processed or the 
        //  system will deadlock.  The handle that is to be freed will be passed
        //  in as lParam for this message
        //
        
        case WM_UNREGISTER_HANDLE:
            UnregisterDeviceNotification ( (HDEVNOTIFY) lParam ); 
            break;
                           
   } // end switch message
   return FALSE;
} // end MainDlgProc


BOOL 
bParseData(
    PHID_DATA           pData,
    rWriteDataStruct    rWriteData[],
    int                 iCount,
    int                 *piErrorLine
)
{  
    INT       iCap;
    PHID_DATA pWalk;
    BOOL      noError = TRUE;

    pWalk = pData;

    for (iCap = 0; (iCap < iCount) && noError; iCap++)
    {
        //
        // Check to see if our data is a value cap or not
        //

        if (!pWalk->IsButtonData)
        {
            pWalk -> ValueData.Value = atol(rWriteData[iCap].szValue);
        } 
        else
        {
            if (!bSetButtonUsages(pWalk, rWriteData[iCap].szValue) )
            {
               *piErrorLine = iCap;

               noError = FALSE;
            } 
        } 
        pWalk++;
    }
    return (noError);
}

BOOL 
bSetButtonUsages(
    PHID_DATA   pCap,
    _In_ LPSTR  pszInputString
)
{
    CHAR   szTempString[SMALL_BUFF];
    CHAR   pszDelimiter[] = " ";
    CHAR   *pszContext = NULL;
    PCHAR  pszToken;
    INT    iLoop;
    PUSAGE pUsageWalk;
    BOOL   bNoError=TRUE;

    if(FAILED(StringCbCopy(szTempString, SMALL_BUFF, pszInputString) ))
    {
        return FALSE;
    }

#pragma warning(push)
#pragma prefast(disable:28193, "pszToken and pUsageWalk are examined")

    pszToken = strtok_s(szTempString, pszDelimiter, &pszContext);
    
    pUsageWalk = pCap -> ButtonData.Usages;

    memset(pUsageWalk, 0, pCap->ButtonData.MaxUsageLength * sizeof(USAGE));

    for (iLoop = 0; ((ULONG) iLoop < pCap->ButtonData.MaxUsageLength) && (pszToken != NULL) && bNoError; iLoop++)
    {
        *pUsageWalk = (USAGE) atoi(pszToken);

        pszToken = strtok_s(NULL, pszDelimiter, &pszContext);

        pUsageWalk++;
    } 
#pragma warning(pop)    

     return bNoError;
} //end function bSetButtonUsages//


INT 
iPrepareDataFields(
    PHID_DATA           pData,
    ULONG               ulDataLength, 
    rWriteDataStruct    rWriteData[],
    int                 iMaxElements
)
{
    INT i;
    PHID_DATA pWalk;

    pWalk = pData;

    for (i = 0; (i < iMaxElements) && ((unsigned) i < ulDataLength); i++)
    {
        if (!pWalk->IsButtonData) 
        {
            StringCbPrintf(rWriteData[i].szLabel,
                           MAX_LABEL,
                           "ValueCap; ReportID: 0x%x, UsagePage=0x%x, Usage=0x%x",
                           pWalk->ReportID,
                           pWalk->UsagePage,
                           pWalk->ValueData.Usage);
        }
        else
        {
            StringCbPrintf(rWriteData[i].szLabel,
                           MAX_LABEL,
                           "Button; ReportID: 0x%x, UsagePage=0x%x, UsageMin: 0x%x, UsageMax: 0x%x",
                           pWalk->ReportID,
                           pWalk->UsagePage,
                           pWalk->ButtonData.UsageMin,
                           pWalk->ButtonData.UsageMax);
        }
        pWalk++;
     } 
     return i;
}  //end function iPrepareDataFields//


INT_PTR CALLBACK 
bReadDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
)
{
    static INT                  iLbCounter;
    static CHAR                 szTempBuff[1024];
    static READ_THREAD_CONTEXT  readContext;
    static HANDLE               readThread;
    static HID_DEVICE           syncDevice;
    static HID_DEVICE           asyncDevice;
    static BOOL                 doAsyncReads;
    static BOOL                 doSyncReads;

           PHID_DEVICE          pDevice;
           DWORD                threadID;
           INT                  iIndex;
           PHID_DATA            pData;
           UINT                 uLoop;


    switch(message)
    {
        case WM_INITDIALOG:

            //
            // Initialize the list box counter, the readThread, and the 
            //  readContext.DisplayEvent.
            //
            
            iLbCounter = 0;
            readThread = NULL;
            readContext.DisplayEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

            if (NULL == readContext.DisplayEvent)
            {
                EndDialog(hDlg, 0);
            } 
            
            //
            // Get the opened device information for the device to perform
            //  reads upon
            //
            
            pDevice = (PHID_DEVICE) lParam;

            //
            // To do sync and async reads requires file handles with different
            //  attributes (ie. an async must be opened with the OVERLAPPED flag
            //  set).  The device node that was passed in the context parameter
            //  was not opened for reading.  Therefore, two more devices will
            //  be opened, one for async reads and one for sync reads.
            //
            
            doSyncReads = OpenHidDevice(pDevice -> DevicePath, 
                                       TRUE,
                                       FALSE,
                                       FALSE,
                                       FALSE,
                                       &syncDevice);

            if (!doSyncReads)
            {
                MessageBox(hDlg, 
                           "Unable to open device for synchronous reading",
                           HCLIENT_ERROR,
                           MB_ICONEXCLAMATION);
            }

            //
            // For asynchronous read, default to using the same information
            //    passed in as the lParam.  This is because data related to
            //    Ppd and such cannot be retrieved using the standard HidD_ 
            //    functions.  However, it is necessary to parse future reports.
            //
            
            doAsyncReads = OpenHidDevice(pDevice -> DevicePath, 
                                       TRUE,
                                       FALSE,
                                       TRUE,
                                       FALSE,
                                       &asyncDevice);

            if (!doAsyncReads) 
            {
                MessageBox(hDlg, 
                           "Unable to open device for asynchronous reading",
                           HCLIENT_ERROR,
                           MB_ICONEXCLAMATION);
            }

            PostMessage(hDlg, WM_READ_DONE, 0, 0);
            break; 

        case WM_DISPLAY_READ_DATA:

            //
            // LParam is the device that was read from
            // 

            pDevice = (PHID_DEVICE) lParam;
            
            //
            // Display all the data stored in the Input data field for the device
            //
            
            pData = pDevice -> InputData;

            SendDlgItemMessage(hDlg,
                               IDC_OUTPUT,
                               LB_ADDSTRING,
                               0,
                               (LPARAM)"-------------------------------------------");
                               
            iLbCounter++;

            if (iLbCounter > MAX_LB_ITEMS)
            {
                SendDlgItemMessage(hDlg,
                                   IDC_OUTPUT,
                                   LB_DELETESTRING,
                                   0,
                                   0);
            }

            for (uLoop = 0; uLoop < pDevice->InputDataLength; uLoop++)
            {
                ReportToString(pData, szTempBuff, sizeof(szTempBuff));
          
                iIndex = (INT) SendDlgItemMessage(hDlg,
                                                  IDC_OUTPUT,
                                                  LB_ADDSTRING,
                                                  0,
                                                  (LPARAM) szTempBuff);

                SendDlgItemMessage(hDlg,
                                   IDC_OUTPUT,
                                   LB_SETCURSEL,
                                   iIndex,
                                   0);

                iLbCounter++;

                if (iLbCounter > MAX_LB_ITEMS)
                {
                    SendDlgItemMessage(hDlg,
                                       IDC_OUTPUT,
                                       LB_DELETESTRING,
                                       0,
                                       0);
                }
                pData++;
            }
            SetEvent( readContext.DisplayEvent );
            break;

        case WM_READ_DONE:
            EnableWindow(GetDlgItem(hDlg, IDOK), TRUE);
            EnableWindow(GetDlgItem(hDlg, IDC_READ_SYNCH), doSyncReads);
            EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_ONCE), doAsyncReads);
            EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_CONT), doAsyncReads);

            SetWindowText(GetDlgItem(hDlg, IDC_READ_ASYNCH_ONCE), 
                          "One Asynchronous Read");       

            SetWindowText(GetDlgItem(hDlg, IDC_READ_ASYNCH_CONT),
                          "Continuous Asynchronous Read");       

            readThread = NULL;
            break;
            
        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_READ_SYNCH:

                    EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
                    EnableWindow(GetDlgItem(hDlg, IDC_READ_SYNCH), FALSE);
                    EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_ONCE), FALSE);
                    EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_CONT), FALSE);

                    Read(&syncDevice);

                    PostMessage(hDlg, WM_DISPLAY_READ_DATA, 0, (LPARAM) &syncDevice);
                    PostMessage(hDlg, WM_READ_DONE, 0, 0);

                    break;

                case IDC_READ_ASYNCH_ONCE:
                case IDC_READ_ASYNCH_CONT:

                    //
                    // When these buttons are pushed there are two options:
                    //  1) Start a new asynch read thread (readThread == NULL)
                    //  2) Stop a previous asych read thread
                    //
                    
                    if (NULL == readThread) 
                    {
                        //
                        // Start a new read thread
                        //

                        readContext.HidDevice = &asyncDevice;
                        readContext.TerminateThread = FALSE;
                        readContext.NumberOfReads = (IDC_READ_ASYNCH_ONCE == LOWORD(wParam))?1:INFINITE_READS;
                        readContext.DisplayWindow = hDlg;
                        
                        readThread = CreateThread(  NULL,
                                                    0,
                                                    AsynchReadThreadProc,
                                                    &readContext,
                                                    0,
                                                    &threadID);

                        if (NULL == readThread)
                        {
                            MessageBox(hDlg,
                                       "Unable to create read thread",
                                       HCLIENT_ERROR,
                                       MB_ICONEXCLAMATION);
                        }
                        else
                        {
                            EnableWindow(GetDlgItem(hDlg, IDOK), FALSE);
                            EnableWindow(GetDlgItem(hDlg, IDC_READ_SYNCH), FALSE);
                            EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_ONCE),
                                         IDC_READ_ASYNCH_ONCE == LOWORD(wParam));

                            EnableWindow(GetDlgItem(hDlg, IDC_READ_ASYNCH_CONT),
                                         IDC_READ_ASYNCH_CONT == LOWORD(wParam));

                            SetWindowText(GetDlgItem(hDlg, LOWORD(wParam)), 
                                          "Stop Asynchronous Read");
                        }
                    }
                    else
                    {
                        //
                        // Signal the terminate thread variable and
                        //  wait for the read thread to complete.
                        //
                        
                        readContext.TerminateThread = TRUE;
                        WaitForSingleObject(readThread, INFINITE);
                    }
                    break;
                        
                case IDCANCEL:
                    readContext.TerminateThread = TRUE;
                    WaitForSingleObject(readThread, INFINITE);
                    //Fall through!!!

                case IDOK:
                    CloseHidDevice(&asyncDevice);
                    CloseHidDevice(&syncDevice);
                    EndDialog(hDlg,0);
                    break;
            }
            break;
     } // end switch message 
     return FALSE;
} // end bReadDlgProc 

VOID
ReportToString(
   PHID_DATA pData,
   _Inout_updates_bytes_(iBuffSize) LPSTR szBuff,
   UINT      iBuffSize
)
{
    PCHAR   pszWalk;
    PUSAGE  pUsage;
    ULONG   i;
    UINT    iRemainingBuffer;
    UINT    iStringLength;
    UINT     j;

    //
    // For button data, all the usages in the usage list are to be displayed
    //
    
    if (pData -> IsButtonData)
    {
        if(FAILED(StringCbPrintf (szBuff,
                        iBuffSize,
                        "Usage Page: 0x%x, Usages: ",
                        pData -> UsagePage)))
        {
            for(j=0; j<iBuffSize; j++)
            {
                szBuff[j] = '\0';
            }
            return;  // error case
        }

        iRemainingBuffer = 0;
        iStringLength = (UINT)strlen(szBuff);
        pszWalk = szBuff + iStringLength;
        if (iStringLength < iBuffSize)
        {
            iRemainingBuffer = iBuffSize - iStringLength;
        }

        for (i = 0, pUsage = pData -> ButtonData.Usages;
                     i < pData -> ButtonData.MaxUsageLength;
                         i++, pUsage++) 
        {
            if (0 == *pUsage)
            {
                break; // A usage of zero is a non button.
            }
            if(FAILED(StringCbPrintf (pszWalk, iRemainingBuffer, " 0x%x", *pUsage)))
            {
                return; // error case
            }
            iRemainingBuffer -= (UINT)strlen(pszWalk);
            pszWalk += strlen(pszWalk);
        }   
    }
    else
    {
        if(FAILED(StringCbPrintf (szBuff,
                        iBuffSize,
                        "Usage Page: 0x%x, Usage: 0x%x, Scaled: %d Value: %d",
                        pData->UsagePage,
                        pData->ValueData.Usage,
                        pData->ValueData.ScaledValue,
                        pData->ValueData.Value)))
        {
            return; // error case
        }
    }
}

INT_PTR CALLBACK 
bFeatureDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
)
{
    static PHID_DEVICE       pDevice;
    static INT               iLbCounter;
    static rWriteDataStruct  rWriteData[MAX_WRITE_ELEMENTS];
    static CHAR              szTempBuff[1024];
           INT               iIndex;
           INT               iCount;
           INT               iErrorLine;
           PHID_DATA         pData;
           UINT              uLoop;

    switch(message)
    {
        case WM_INITDIALOG:
            iLbCounter = 0;
            pDevice = (PHID_DEVICE) lParam;
            break; 

        case WM_COMMAND:
            switch(LOWORD(wParam))
            {
                case IDC_READ:

                    GetFeature(pDevice);

                    pData = pDevice -> FeatureData;

                    SendDlgItemMessage(hDlg,
                                       IDC_OUTPUT,
                                       LB_ADDSTRING,
                                       0,
                                       (LPARAM)"------------ Read Features ---------------");

                    iLbCounter++;

                    if (iLbCounter > MAX_LB_ITEMS) 
                    {
                        SendDlgItemMessage(hDlg,
                                           IDC_OUTPUT,
                                           LB_DELETESTRING,
                                           0,
                                           0);
                    }

                    for (uLoop = 0; uLoop < pDevice -> FeatureDataLength; uLoop++)
                    {
                        ReportToString(pData, szTempBuff, sizeof(szTempBuff));

                        iIndex = (INT) SendDlgItemMessage(hDlg,
                                                          IDC_OUTPUT,
                                                          LB_ADDSTRING,
                                                          0,
                                                          (LPARAM) szTempBuff);
                                                   
                        SendDlgItemMessage(hDlg,
                                           IDC_OUTPUT,
                                           LB_SETCURSEL,
                                           iIndex,
                                           (LPARAM) 0);

                        iLbCounter++;
                        if (iLbCounter > MAX_LB_ITEMS)
                        {
                            SendDlgItemMessage(hDlg,
                                               IDC_OUTPUT,
                                               LB_DELETESTRING,
                                               0,
                                               0);
                        }
                        pData++;
                    } 
                    break;

                case IDC_WRITE:
                    iCount = iPrepareDataFields(pDevice -> FeatureData, 
                                                pDevice -> FeatureDataLength,
                                                rWriteData,
                                                MAX_OUTPUT_ELEMENTS);

                    if (bGetData(rWriteData, iCount, hDlg, "WRITEFEATURE"))
                    {
                        if (!bParseData(pDevice -> FeatureData, rWriteData,iCount, &iErrorLine)) 
                        {
                            StringCbPrintf(szTempBuff,
                                           sizeof(szTempBuff),
                                           "Unable to parse line %x of output data",
                                           iErrorLine);
                            
                            MessageBox(hDlg,
                                        szTempBuff,
                                        HCLIENT_ERROR,
                                        MB_ICONEXCLAMATION);
                        }
                        else
                        {
                            if ( SetFeature(pDevice) )
                            {
                                SendDlgItemMessage(hDlg,
                                                   IDC_OUTPUT,
                                                   LB_ADDSTRING,
                                                   0,
                                                   (LPARAM)"------------ Write Feature ---------------");                                             
                            }
                            else
                            {
                                 SendDlgItemMessage(hDlg,
                                                    IDC_OUTPUT,
                                                    LB_ADDSTRING,
                                                    0,
                                                    (LPARAM)"------------ Write Feature Error ---------------");                                             
                            }                                                             
                        }
                     }
                     break;
                      
                      
                 case IDOK:
                 case IDCANCEL:
                     EndDialog(hDlg,0);
                     break;
            }
            break;
   } //end switch message//
   return FALSE;
} //end bReadDlgProc//

VOID 
vDisplayDeviceCaps(
    IN PHIDP_CAPS pCaps,
    IN HWND hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];

    SendMessage(hControl, LB_RESETCONTENT, 0, 0);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage Page: 0x%x", pCaps -> UsagePage);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage: 0x%x",pCaps -> Usage);
    SendMessage(hControl,LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Input report byte length: %d",pCaps -> InputReportByteLength);
    SendMessage(hControl,LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Output report byte length: %d",pCaps -> OutputReportByteLength);
    SendMessage(hControl,LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Feature report byte length: %d",pCaps -> FeatureReportByteLength);
    SendMessage(hControl,LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Number of collection nodes %d: ", pCaps -> NumberLinkCollectionNodes);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    return;
}

VOID
vDisplayDeviceAttributes(
    PHIDD_ATTRIBUTES pAttrib,
    HWND hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Vendor ID: 0x%x", pAttrib -> VendorID);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Product ID: 0x%x", pAttrib -> ProductID);
    SendMessage(hControl, LB_ADDSTRING, 0,(LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Version Number  0x%x", pAttrib -> VersionNumber);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    return;
}

VOID
vDisplayDataAttributes(
    PHIDP_DATA pData, 
    BOOL IsButton, 
    HWND hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];

    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) "================");

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Index: 0x%x", pData -> DataIndex);
    SendMessage(hControl,LB_ADDSTRING, 0, (LPARAM) szTempBuff);
    
    StringCbPrintf(szTempBuff, SMALL_BUFF, "IsButton: %s", IsButton ? "TRUE" : "FALSE");
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (IsButton) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Button pressed: %s", pData -> On ? "TRUE" : "FALSE");
        SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
    }
    else
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Data value: 0x%x", pData -> RawValue);
        SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
    }
}

VOID 
vDisplayButtonAttributes(
    IN PHIDP_BUTTON_CAPS pButton,
    IN HWND hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];
   
    StringCbPrintf(szTempBuff, SMALL_BUFF, "Report ID: 0x%x", pButton->ReportID);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
     
    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage Page: 0x%x", pButton->UsagePage);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
        
    StringCbPrintf(szTempBuff,
                   SMALL_BUFF, 
                   "Alias: %s",
                   pButton -> IsAlias ? "TRUE" : "FALSE");
    
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
   
    StringCbPrintf(szTempBuff,
                   SMALL_BUFF,
                   "Link Collection: %hu",
                   pButton -> LinkCollection);

    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
   
    StringCbPrintf(szTempBuff,
                   SMALL_BUFF,
                   "Link Usage Page: 0x%x",
                   pButton -> LinkUsagePage);
 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);        
   
    StringCbPrintf(szTempBuff,
                   SMALL_BUFF,
                   "Link Usage: 0x%x",
                   pButton -> LinkUsage);

    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pButton->IsRange) 
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Usage Min: 0x%x, Usage Max: 0x%x",
                       pButton->Range.UsageMin, 
                       pButton->Range.UsageMax);
    } 
    else
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage: 0x%x",pButton->NotRange.Usage);

    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pButton->IsRange)
    {
         StringCbPrintf(szTempBuff,
                        SMALL_BUFF,
                        "Data Index Min: 0x%x, Data Index Max: 0x%x",
                        pButton->Range.DataIndexMin, 
                        pButton->Range.DataIndexMax);

    } 
    else 
    {
         StringCbPrintf(szTempBuff, SMALL_BUFF, "DataIndex: 0x%x",pButton->NotRange.DataIndex);
    } 

    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pButton->IsStringRange)
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "String Min: 0x%x, String Max: 0x%x",
                       pButton->Range.StringMin, 
                       pButton->Range.StringMax);
    } 
    else
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "String Index: 0x%x",pButton->NotRange.StringIndex);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pButton->IsDesignatorRange) 
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Designator Min: 0x%x, Designator Max: 0x%x",
                       pButton->Range.DesignatorMin, 
                       pButton->Range.DesignatorMax);

    } 
    else
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Designator Index: 0x%x",
                       pButton->NotRange.DesignatorIndex);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0,(LPARAM) szTempBuff);

    if (pButton->IsAbsolute)
    {
        SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) "Absolute: Yes");
    }
    else
    {
        SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) "Absolute: No");
    }
    return;
} 

VOID
vDisplayValueAttributes(
    IN PHIDP_VALUE_CAPS pValue,
    HWND hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Report ID 0x%x", pValue->ReportID);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
 
    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage Page: 0x%x", pValue->UsagePage);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Bit size: 0x%x", pValue->BitSize);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Report Count: 0x%x", pValue->ReportCount);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Unit Exponent: 0x%x", pValue->UnitsExp);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Has Null: 0x%x", pValue->HasNull);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);    

 
    if (pValue->IsAlias)
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Alias");
    }
    else 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "=====");
    }
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pValue->IsRange)
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Usage Min: 0x%x, Usage Max 0x%x",
                       pValue->Range.UsageMin, 
                       pValue->Range.UsageMax);
    } 
    else
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage: 0x%x", pValue -> NotRange.Usage);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pValue->IsRange)
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Data Index Min: 0x%x, Data Index Max: 0x%x",
                       pValue->Range.DataIndexMin, 
                       pValue->Range.DataIndexMax);
    } 
    else
    {
         StringCbPrintf(szTempBuff, SMALL_BUFF, "DataIndex: 0x%x", pValue->NotRange.DataIndex);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff,
                   SMALL_BUFF,
                   "Physical Minimum: %d, Physical Maximum: %d",
                   pValue->PhysicalMin, 
                   pValue->PhysicalMax);

    SendMessage(hControl, LB_ADDSTRING, 0,(LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff,
                   SMALL_BUFF,
                   "Logical Minimum: 0x%x, Logical Maximum: 0x%x",
                   pValue->LogicalMin,
                   pValue->LogicalMax);

    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pValue->IsStringRange) 
    {
       StringCbPrintf(szTempBuff,
                      SMALL_BUFF,
                      "String  Min: 0x%x String Max 0x%x",
                      pValue->Range.StringMin,
                      pValue->Range.StringMax);
    } 
    else
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "String Index: 0x%x",pValue->NotRange.StringIndex);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

    if (pValue->IsDesignatorRange) 
    {
        StringCbPrintf(szTempBuff,
                       SMALL_BUFF,
                       "Designator Minimum: 0x%x, Max: 0x%x",
                       pValue->Range.DesignatorMin, 
                       pValue->Range.DesignatorMax);
    } 
    else 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Designator Index: 0x%x",pValue->NotRange.DesignatorIndex);
    } 
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
 
    if (pValue->IsAbsolute) 
    { 
        SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) "Absolute: Yes");
    }
    else
    {
        SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) "Absolute: No");
    }
    return;
}

VOID 
vDisplayInputButtons(
    IN PHID_DEVICE pDevice,
    IN HWND hControl
)
{
    INT               iLoop;
    PHIDP_BUTTON_CAPS pButtonCaps;
    static CHAR       szTempBuff[SMALL_BUFF];
    INT               iIndex;

    SendMessage(hControl, LB_RESETCONTENT, 0, (LPARAM) 0);

    pButtonCaps = pDevice->InputButtonCaps;
    for (iLoop = 0; iLoop < pDevice->Caps.NumberInputButtonCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Input button cap # %d", iLoop);

        iIndex = (INT) SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

        if (-1 != iIndex)
        {
            SendMessage(hControl, LB_SETITEMDATA, iIndex,(LPARAM) pButtonCaps);
        }

        pButtonCaps++;
    } 
    SendMessage(hControl, LB_SETCURSEL, 0, 0 );
}

VOID 
vDisplayOutputButtons(
   IN PHID_DEVICE pDevice,
   IN HWND hControl
)
{
    INT               iLoop;
    static CHAR       szTempBuff[SMALL_BUFF];
    INT               iIndex;
    PHIDP_BUTTON_CAPS pButtonCaps; 

    SendMessage(hControl, LB_RESETCONTENT, 0, (LPARAM) 0);

    pButtonCaps = pDevice -> OutputButtonCaps;

    for (iLoop = 0; iLoop < pDevice->Caps.NumberOutputButtonCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Output button cap # %d", iLoop);
        iIndex = (INT) SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

        if (-1 != iIndex)
        {
            SendMessage(hControl, LB_SETITEMDATA, iIndex, (LPARAM) pButtonCaps);
        }
        pButtonCaps++;
    }

    SendMessage(hControl, LB_SETCURSEL, 0, 0);
    return;
}

VOID 
vDisplayInputValues(
    IN PHID_DEVICE pDevice,
    IN HWND hControl
)
{
    INT              iLoop;
    static CHAR      szTempBuff[SMALL_BUFF];
    INT              iIndex;
    PHIDP_VALUE_CAPS pValueCaps; 

    SendMessage(hControl, LB_RESETCONTENT, 0, 0);

    pValueCaps = pDevice -> InputValueCaps;

    for (iLoop=0; iLoop < pDevice->Caps.NumberInputValueCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Input value cap # %d",iLoop);
        iIndex = (INT) SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

        if (-1 != iIndex) 
        {
           SendMessage(hControl, LB_SETITEMDATA, iIndex,(LPARAM) pValueCaps);
        }
        pValueCaps++;
    }

    SendMessage(hControl, LB_SETCURSEL, 0, 0);
    return;
}

VOID
vDisplayOutputValues(
    IN PHID_DEVICE pDevice,
    IN HWND hControl)
{
    INT              iLoop;
    static CHAR      szTempBuff[SMALL_BUFF];
    INT              iIndex;
    PHIDP_VALUE_CAPS pValueCaps; 
   
    SendMessage(hControl, LB_RESETCONTENT, 0, 0);
    pValueCaps = pDevice -> OutputValueCaps;
   
    for (iLoop = 0; iLoop < pDevice->Caps.NumberOutputValueCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Output value cap # %d", iLoop);
        iIndex = (INT) SendMessage(hControl, 
                                   LB_ADDSTRING, 
                                   0, 
                                   (LPARAM) szTempBuff);
       
        if (-1 != iIndex) 
        {
            SendMessage(hControl, LB_SETITEMDATA, iIndex, (LPARAM) pValueCaps);
        }
        pValueCaps++;
    }

    SendMessage(hControl, LB_SETCURSEL, 0, 0);

    return;
}

VOID
vDisplayFeatureButtons(
    IN PHID_DEVICE pDevice,
    IN HWND hControl
)
{
    INT               iLoop;
    static CHAR       szTempBuff[SMALL_BUFF];
    INT               iIndex;
    PHIDP_BUTTON_CAPS pButtonCaps; 

    SendMessage(hControl, LB_RESETCONTENT, 0, 0);

    pButtonCaps = pDevice -> FeatureButtonCaps;

    for (iLoop = 0; iLoop < pDevice->Caps.NumberFeatureButtonCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Feature button cap # %d", iLoop);
        iIndex = (INT) SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

        if (-1 != iIndex) 
        {
            SendMessage(hControl, LB_SETITEMDATA, iIndex, (LPARAM) pButtonCaps);
        }
        pButtonCaps++;
    } 
    SendMessage(hControl, LB_SETCURSEL, 0, 0);
    return;
}

VOID
vDisplayFeatureValues(
    IN PHID_DEVICE pDevice,
    IN HWND hControl
)
{
    INT              iLoop;
    static CHAR      szTempBuff[SMALL_BUFF];
    INT              iIndex;
    PHIDP_VALUE_CAPS pValueCaps; 

    SendMessage(hControl, LB_RESETCONTENT, 0, 0);
    pValueCaps = pDevice ->FeatureValueCaps;

    for (iLoop = 0; iLoop < pDevice->Caps.NumberFeatureValueCaps; iLoop++) 
    {
        StringCbPrintf(szTempBuff, SMALL_BUFF, "Feature value cap # %d", iLoop);
        iIndex = (INT) SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);

        if (-1 != iIndex) 
        {
            SendMessage(hControl, LB_SETITEMDATA, iIndex, (LPARAM) pValueCaps);
        }

        pValueCaps++;
    } 
    SendMessage(hControl, LB_SETCURSEL, 0, 0);
    return;
}

VOID
vLoadItemTypes(
    IN HWND hItemTypes
)
{
    INT iIndex;

    iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "INPUT BUTTON");

    if (-1 != iIndex) 
    {
        SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, INPUT_BUTTON);

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0 ,(LPARAM) "INPUT VALUE");
        if (-1 != iIndex) 
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, INPUT_VALUE);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "OUTPUT BUTTON");
        if (-1 != iIndex)
        {
            SendMessage(hItemTypes,CB_SETITEMDATA,iIndex,OUTPUT_BUTTON);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "OUTPUT VALUE");
        if (-1 != iIndex)
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, OUTPUT_VALUE);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "FEATURE BUTTON");
        if (-1 != iIndex) 
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, FEATURE_BUTTON);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "FEATURE VALUE");
        if (-1 != iIndex)
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, FEATURE_VALUE);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "HID CAPS");
        if (-1 != iIndex )
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, HID_CAPS);
        }

        iIndex = (INT) SendMessage(hItemTypes, CB_ADDSTRING, 0, (LPARAM) "DEVICE ATTRIBUTES");
        if (-1 != iIndex)
        {
            SendMessage(hItemTypes, CB_SETITEMDATA, iIndex, DEVICE_ATTRIBUTES);
        }

        SendMessage(hItemTypes, CB_SETCURSEL, 0, 0);
    }
} 

VOID vLoadDevices(
    HWND    hDeviceCombo
)
{
    PDEVICE_LIST_NODE   currNode;
    
    static CHAR szTempBuff[SMALL_BUFF];
    INT         i = 0; 
    INT         iIndex; 

    //
    // Reset the content of the device list box.
    //

    SendMessage(hDeviceCombo, CB_RESETCONTENT, 0, 0);


    if (!IsListEmpty(&PhysicalDeviceList))
    {
        currNode = (PDEVICE_LIST_NODE) GetListHead(&PhysicalDeviceList);
          
        do
        {
            if (INVALID_HANDLE_VALUE != currNode -> HidDeviceInfo.HidDevice)
            {
                StringCbPrintf(szTempBuff,
                               SMALL_BUFF,
                               "Device #%d: VID: 0x%04X  PID: 0x%04X  UsagePage: 0x%X  Usage: 0x%X",
                                i++,
                                currNode -> HidDeviceInfo.Attributes.VendorID,
                                currNode -> HidDeviceInfo.Attributes.ProductID,
                                currNode -> HidDeviceInfo.Caps.UsagePage,
                                currNode -> HidDeviceInfo.Caps.Usage);
            }
            else
            {
                StringCbPrintf(szTempBuff,
                               SMALL_BUFF,
                               "*Device #%d: %s",
                                i++,
                                (NULL != currNode -> HidDeviceInfo.DevicePath) ? (currNode -> HidDeviceInfo.DevicePath) : "");
            }

            iIndex = (INT) SendMessage(hDeviceCombo, CB_ADDSTRING, 0, (LPARAM) szTempBuff);

            if (CB_ERR != iIndex && INVALID_HANDLE_VALUE != currNode -> HidDeviceInfo.HidDevice)
            {
                SendMessage(hDeviceCombo, CB_SETITEMDATA, iIndex, (LPARAM) &(currNode -> HidDeviceInfo));
            }

            currNode = (PDEVICE_LIST_NODE) GetNextEntry(currNode);
            
        } while ((PLIST) currNode != &PhysicalDeviceList);
       
    } 

   
    SendMessage(hDeviceCombo, CB_SETCURSEL, 0, 0);
  
    return;
}

BOOL
bGetData(
    prWriteDataStruct pItems,
    INT               iCount,
    HWND              hParent, 
    _In_ LPSTR        pszDialogName
)
{
    rGetWriteDataParams        rParams;
    static rWriteDataStruct    arTempItems[MAX_WRITE_ELEMENTS];
    INT                        iResult;


    if (iCount > MAX_WRITE_ELEMENTS) 
    {
        iCount = MAX_WRITE_ELEMENTS;
    }

    memcpy( &(arTempItems[0]), pItems, sizeof(rWriteDataStruct)*iCount);

    rParams.iCount = iCount;
    rParams.prItems = &(arTempItems[0]);

    iResult = (INT) DialogBoxParam(hGInstance,
                                   pszDialogName,
                                   hParent,
                                   bGetDataDlgProc,
                                   (LPARAM) &rParams);
    if (iResult) 
    {
       memcpy(pItems, arTempItems, sizeof(rWriteDataStruct)*iCount);
    }
    return iResult;
} 

INT_PTR CALLBACK 
bGetDataDlgProc(
    HWND hDlg, 
    UINT message, 
    WPARAM wParam, 
    LPARAM lParam
)
{
    static prWriteDataStruct    prData;
    static prGetWriteDataParams pParams;
    static INT                  iDisplayCount;
    static INT                  iScrollRange;
    static INT                  iCurrentScrollPos=0;
    static HWND                 hScrollBar;
           INT                  iTemp;
           SCROLLINFO           rScrollInfo;

    switch(message) 
    {
        case WM_INITDIALOG:

            pParams = (prGetWriteDataParams) lParam;
            prData = pParams -> prItems;
            hScrollBar = GetDlgItem(hDlg, IDC_SCROLLBAR);

            if (pParams -> iCount > CONTROL_COUNT) 
            {
                iDisplayCount = CONTROL_COUNT;
                iScrollRange = pParams -> iCount - CONTROL_COUNT;
                rScrollInfo.fMask = SIF_RANGE | SIF_POS;
                rScrollInfo.nPos = 0;
                rScrollInfo.nMin = 0;
                rScrollInfo.nMax = iScrollRange;
                rScrollInfo.cbSize = sizeof(rScrollInfo);
                rScrollInfo.nPage = CONTROL_COUNT;
                SetScrollInfo(hScrollBar,SB_CTL,&rScrollInfo,TRUE);
            }
            else
            {
                iDisplayCount=pParams->iCount;
                EnableWindow(hScrollBar,FALSE);
            }
            vWriteDataToControls(hDlg, prData, 0, pParams->iCount);
            break;

        case WM_COMMAND:
            switch(LOWORD(wParam)) 
            {
                case IDOK:
                case ID_SEND:
                    vReadDataFromControls(hDlg, prData, iCurrentScrollPos, iDisplayCount);
                    EndDialog(hDlg,1);
                    break;

                case IDCANCEL:
                    EndDialog(hDlg,0);
                    break;
             } 
             break;

        case WM_VSCROLL:
            vReadDataFromControls(hDlg, prData, iCurrentScrollPos, iDisplayCount);

            switch(LOWORD(wParam)) 
            {
                case SB_LINEDOWN:
                    ++iCurrentScrollPos;
                    break;

                case SB_LINEUP:
                    --iCurrentScrollPos;
                    break;

                case SB_THUMBPOSITION:
                    iCurrentScrollPos = HIWORD(wParam);

                case SB_PAGEUP:
                    iCurrentScrollPos -= CONTROL_COUNT;
                    break;

                case SB_PAGEDOWN:
                    iCurrentScrollPos += CONTROL_COUNT;
                    break;
            }

            if (iCurrentScrollPos < 0) 
            {
                iCurrentScrollPos = 0;
            }
             
            if (iCurrentScrollPos > iScrollRange)
            {
                iCurrentScrollPos = iScrollRange; 
            }

            SendMessage(hScrollBar, SBM_SETPOS, iCurrentScrollPos, TRUE);
            iTemp = LOWORD(wParam);

            if ( (iTemp == SB_LINEDOWN) || (iTemp == SB_LINEUP) || (iTemp == SB_THUMBPOSITION)|| (iTemp == SB_PAGEUP) || (iTemp==SB_PAGEDOWN) )
            {
                vWriteDataToControls(hDlg, prData, iCurrentScrollPos, iDisplayCount);
            }
            break; 
    } 
    return FALSE;
} //end function bGetDataDlgProc//

VOID
vReadDataFromControls(
    HWND hDlg,
    prWriteDataStruct prData,
    INT iOffset,
    INT iCount
)
{
    INT               iLoop;
    INT               iValueControlID = IDC_OUT_EDIT1;
    prWriteDataStruct pDataWalk;
    HWND              hValueWnd;

    pDataWalk = prData + iOffset;
    for (iLoop = 0; (iLoop < iCount) && (iLoop < CONTROL_COUNT); iLoop++) 
    {
        hValueWnd = GetDlgItem(hDlg, iValueControlID);

        GetWindowText(hValueWnd, pDataWalk -> szValue, MAX_VALUE);

        iValueControlID++;

        pDataWalk++;
    } 

    return;
} 

VOID
vWriteDataToControls(
    HWND                hDlg,
    prWriteDataStruct   prData,
    INT                 iOffset,
    INT                 iCount
)
{
    INT               iLoop;
    INT               iLabelControlID = IDC_OUT_LABEL1;
    INT               iValueControlID = IDC_OUT_EDIT1;
    HWND              hLabelWnd, hValueWnd;
    prWriteDataStruct pDataWalk;

    pDataWalk = prData + iOffset;

    for (iLoop = 0; (iLoop < iCount) && (iLoop < CONTROL_COUNT); iLoop++) 
    {
         hLabelWnd = GetDlgItem(hDlg, iLabelControlID);
         hValueWnd = GetDlgItem(hDlg, iValueControlID);
         
         ShowWindow(hLabelWnd, SW_SHOW);
         ShowWindow(hValueWnd, SW_SHOW);
         
         SetWindowText(hLabelWnd, pDataWalk -> szLabel);
         SetWindowText(hValueWnd, pDataWalk -> szValue);
         
         iLabelControlID++;
         iValueControlID++;
         pDataWalk++;
    }     
     
    //
    // Hide the controls
    //

    for (; iLoop < CONTROL_COUNT; iLoop++) 
    {
        hLabelWnd = GetDlgItem(hDlg,iLabelControlID);
        hValueWnd = GetDlgItem(hDlg,iValueControlID);
        
        ShowWindow(hLabelWnd,SW_HIDE);
        ShowWindow(hValueWnd,SW_HIDE);
        
        iLabelControlID++;
        iValueControlID++;
     } 
} 

VOID
vCreateUsageString(
    _In_  PUSAGE        pUsageList,
    _Out_writes_(uiStringSize) CHAR szString[],
    _In_ UINT                uiStringSize
)
{
    
    StringCbPrintf(szString,
                   uiStringSize,
                   "Usage: %#04x",
                   *pUsageList);

    return;
}

VOID
vCreateUsageAndPageString(
    _In_  PUSAGE_AND_PAGE        pUsageList,
    _Out_writes_(uiStringSize) CHAR szString[],
    _In_  UINT                   uiStringSize
)
{
    
    StringCbPrintf(szString,
                   uiStringSize,
                   "Usage Page: %#04x  Usage: %#04x",
                   pUsageList->UsagePage,
                   pUsageList->Usage);

    return;
}

VOID
vDisplayLinkCollectionNode(
    IN  PHIDP_LINK_COLLECTION_NODE  pLCNode,
    IN  ULONG                       ulLinkIndex,
    IN  HWND                        hControl
)
{
    static CHAR szTempBuff[SMALL_BUFF];

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Index: 0x%x", ulLinkIndex);
    SendMessage(hControl, LB_ADDSTRING, 0, (LPARAM) szTempBuff);
    
    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage Page: 0x%x", pLCNode -> LinkUsagePage);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM)szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Usage: 0x%x", pLCNode -> LinkUsage);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Parent Index: 0x%x", pLCNode -> Parent);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Number of Children: 0x%x", pLCNode -> NumberOfChildren);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "Next Sibling: 0x%x", pLCNode -> NextSibling);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) szTempBuff);

    StringCbPrintf(szTempBuff, SMALL_BUFF, "First Child: 0x%x", pLCNode -> FirstChild);
    SendMessage(hControl, LB_ADDSTRING,0, (LPARAM) szTempBuff);

    return;
}

VOID
vCreateUsageValueStringFromArray(
    _In_reads_(uiBufferSize)PCHAR       pBuffer,
    _In_ UINT        uiBufferSize,
    _In_ USHORT      BitSize,
    _In_ USHORT      UsageIndex,
    _Out_writes_(uiStringSize)  CHAR       szString[],
    _In_  UINT       uiStringSize
)
/*++
Routine Description:
    Given a report buffer, pBuffer, this routine extracts the given usage
    at UsageIndex from the array and outputs to szString the string
    representation of that value.  The input parameter BitSize specifies
    the number of bits representing that value in the array.  This is
    useful for extracting individual members of a UsageValueArray.
--*/
{
    UINT           iByteIndex;
    USHORT      iByteOffset;
    UCHAR       ucLeftoverBits;
    ULONG       ulMask;
    ULONG       ulValue;

    //
    // Calculate the byte and byte offset into the buffer for the given
    //   index value
    //
    
    iByteIndex = (UsageIndex * BitSize) >> 3;
    iByteOffset = (UsageIndex * BitSize) & 7;

    //
    // Make sure we don't go past our buffer
    //
    if(iByteIndex + (UINT)4 > uiBufferSize)
    {
        if(sizeof(szString) <= uiStringSize)
        {
            StringCbPrintf(szString, uiStringSize, "ERR");
        }
        return;
    }

    //
    // Extract the 32-bit value beginning at ByteIndex.  This value
    //   will contain some or all of the value we are attempting to retrieve
    //
    
    ulValue = *(PULONG) (pBuffer + iByteIndex);

    //
    // Shift that value to the right by our byte offset..
    //
    
    ulValue = ulValue >> iByteOffset;

    //
    // At this point, ulValue contains the first 32-iByteOffset bits beginning
    //    the appropriate offset in the buffer.  There are now two cases to 
    //    look at:
    //      
    //    1) BitSize > 32-iByteOffset -- In which case, we need to extract
    //                                   iByteOffset bits from the next
    //                                   byte in the array and OR them as
    //                                   the MSBs of ulValue
    //
    //    2) BitSize < 32-iByteOffset -- Need to get only the BitSize LSBs
    //                                   
    //

    //
    // Case #1
    //
    
    if (BitSize > sizeof(ULONG)*8 - iByteOffset) 
    {
        //
        // Get the next byte of the report following the four bytes we
        //   retrieved earlier for ulValue
        //
        if ( (iByteIndex+4) < uiBufferSize )
        {
            ucLeftoverBits =  *(pBuffer+iByteIndex+4);
        }
        else
        {
            StringCbPrintf(szString, uiStringSize, "ERR");
            return;  // error case
        }

        //
        // Shift those bits to the left for anding to our previous value
        //
        
        ulMask = ucLeftoverBits << (24 + (8 - iByteOffset));
        ulValue |= ulMask;

    }
    else if (BitSize < sizeof(ULONG)*8 - iByteOffset) 
    {
        //
        // Need to mask the most significant bits that are part of another
        //    value(s), not the one we are currently working with.
        //
        
        ulMask = (1 << BitSize) - 1;
        ulValue &= ulMask;
    }
    
    //
    // We've now got the correct value, now output to the string
    //

    StringCbPrintf(szString, uiStringSize, "Usage value: %lu", ulValue);

    return;
}


BOOL
RegisterHidDevice(
    IN  HWND                WindowHandle,
    IN  PDEVICE_LIST_NODE   DeviceNode
)
{
    DEV_BROADCAST_HANDLE broadcastHandle;
    
    broadcastHandle.dbch_size = sizeof(DEV_BROADCAST_HANDLE);
    broadcastHandle.dbch_devicetype = DBT_DEVTYP_HANDLE;
    broadcastHandle.dbch_handle = DeviceNode -> HidDeviceInfo.HidDevice;

    DeviceNode -> NotificationHandle = RegisterDeviceNotification( 
                                                WindowHandle,
                                                &broadcastHandle,
                                                DEVICE_NOTIFY_WINDOW_HANDLE);

    return (NULL != DeviceNode -> NotificationHandle);
}   

VOID
DestroyDeviceListCallback(
    PLIST_NODE_HDR   ListNode
)
{
    PDEVICE_LIST_NODE   deviceNode;

    deviceNode = (PDEVICE_LIST_NODE) ListNode;
    
    //
    // The callback function needs to do the following steps...
    //   1) Close the HidDevice
    //   2) Unregister device notification (if registered)
    //   3) Free the allocated memory block
    //

    CloseHidDevice(&(deviceNode -> HidDeviceInfo));

    if (NULL != deviceNode -> NotificationHandle) 
    {
        UnregisterDeviceNotification(deviceNode -> NotificationHandle);
    }

    free (deviceNode);

    return;
}

DWORD WINAPI
AsynchReadThreadProc( 
    PREAD_THREAD_CONTEXT    Context
)
{
    HANDLE  completionEvent;
    BOOL    readResult;
    DWORD   waitStatus;
    ULONG   numReadsDone;
    OVERLAPPED overlap;
    DWORD      bytesTransferred;

    
    //
    // Create the completion event to send to the the OverlappedRead routine
    //

    completionEvent = CreateEvent(NULL, FALSE, FALSE, NULL);

    //
    // If NULL returned, then we cannot proceed any farther so we just exit the 
    //  the thread
    //
    
    if (NULL == completionEvent) 
    {
        goto AsyncRead_End;
    }

    //
    // Now we enter the main read loop, which does the following:
    //  1) Calls ReadOverlapped()
    //  2) Waits for read completion with a timeout just to check if 
    //      the main thread wants us to terminate our the read request
    //  3) If the read fails, we simply break out of the loop
    //      and exit the thread
    //  4) If the read succeeds, we call UnpackReport to get the relevant
    //      info and then post a message to main thread to indicate that
    //      there is new data to display.
    //  5) We then block on the display event until the main thread says
    //      it has properly displayed the new data
    //  6) Look to repeat this loop if we are doing more than one read
    //      and the main thread has yet to want us to terminate
    //

    numReadsDone = 0;

    do 
    {
        //
        // Call ReadOverlapped() and if the return status is TRUE, the ReadFile
        //  succeeded so we need to block on completionEvent, otherwise, we just
        //  exit
        //

        readResult = ReadOverlapped( Context->HidDevice, completionEvent, &overlap );


        if (!readResult)
        {
           break;
        }

        while (!Context -> TerminateThread) 
        {
            //
            // Wait for the completion event to be signaled or a timeout
            //
            
            waitStatus = WaitForSingleObject (completionEvent, READ_THREAD_TIMEOUT );

            //
            // If completionEvent was signaled, then a read just completed
            //   so let's get the status and leave this loop and process the data 
            //
            
            if ( WAIT_OBJECT_0 == waitStatus)
            {
                readResult = GetOverlappedResult(Context->HidDevice->HidDevice, &overlap, &bytesTransferred, TRUE);
                break;
            }
        }

        //
        // Check the TerminateThread again...If it is not set, then data has
        //  been read.  In this case, we want to Unpack the report into our
        //  input info and then send a message to the main thread to display
        //  the new data.
        //
        
        if (!Context -> TerminateThread) 
        {
            numReadsDone++;

            UnpackReport(Context -> HidDevice -> InputReportBuffer,
                          Context -> HidDevice -> Caps.InputReportByteLength,
                          HidP_Input,
                          Context -> HidDevice -> InputData,
                          Context -> HidDevice -> InputDataLength,
                          Context -> HidDevice -> Ppd);
            
            if (NULL != Context -> DisplayEvent)
            {
                PostMessage(Context -> DisplayWindow,
                            WM_DISPLAY_READ_DATA,
                            0,
                            (LPARAM) Context -> HidDevice);

                WaitForSingleObject( Context -> DisplayEvent, INFINITE );
            }
            else if (NULL != Context->DisplayWindow)
            {
                CHAR        szTempBuff[1024];
                PHID_DEVICE pDevice;
                PHID_DATA   pData;
                UINT        uLoop;

                pDevice = (PHID_DEVICE)Context->HidDevice;

                //
                // Display all the data stored in the Input data field for the device
                //
                pData = pDevice->InputData;

                SendMessage(GetDlgItem(Context->DisplayWindow, IDC_CALLOUTPUT),
                    LB_ADDSTRING,
                    0,
                    (LPARAM)"-------------------------------------------");

                for (uLoop = 0; uLoop < pDevice->InputDataLength; uLoop++)
                {
                    ReportToString(pData, szTempBuff, sizeof(szTempBuff));

                    SendMessage(GetDlgItem(Context->DisplayWindow, IDC_CALLOUTPUT),
                        LB_ADDSTRING,
                        0,
                        (LPARAM)szTempBuff);

                    pData++;
                }
            }
            else if (NULL == Context -> DisplayWindow)
            {
                // Running in console mode
                printf("Read #%d\n", numReadsDone);
                CLM_PrintInputReport(Context -> HidDevice);
            }
        }
    } while ( readResult &&
              !Context->TerminateThread &&
              (INFINITE_READS == Context -> NumberOfReads || 
              numReadsDone < Context -> NumberOfReads));


AsyncRead_End:

    PostMessage( Context -> DisplayWindow, WM_READ_DONE, 0, 0);
    ExitThread(0);
    return (0);
}

DWORD WINAPI
SynchReadThreadProc(
    PREAD_THREAD_CONTEXT    Context
)
{
    ULONG   numReadsDone = 0;
    do 
    {
        Read(Context -> HidDevice);

        if (Context->TerminateThread) {
            break;
        }

        numReadsDone ++;

        UnpackReport(Context -> HidDevice -> InputReportBuffer,
                     Context -> HidDevice -> Caps.InputReportByteLength,
                     HidP_Input,
                     Context -> HidDevice -> InputData,
                     Context -> HidDevice -> InputDataLength,
                     Context -> HidDevice -> Ppd);

        if (NULL != Context -> DisplayEvent) 
        {
            PostMessage(Context -> DisplayWindow,
                        WM_DISPLAY_READ_DATA,
                        0,
                        (LPARAM) Context -> HidDevice);

            WaitForSingleObject( Context -> DisplayEvent, INFINITE );
        }
        else if (NULL != Context->DisplayWindow)
        {
            CHAR        szTempBuff[1024];
            PHID_DEVICE pDevice;
            PHID_DATA   pData;
            UINT        uLoop;

            pDevice = (PHID_DEVICE)Context->HidDevice;

            //
            // Display all the data stored in the Input data field for the device
            //
            pData = pDevice->InputData;

            SendMessage(GetDlgItem(Context->DisplayWindow, IDC_CALLOUTPUT),
                LB_ADDSTRING,
                0,
                (LPARAM)"-------------------------------------------");

            for (uLoop = 0; uLoop < pDevice->InputDataLength; uLoop++)
            {
                ReportToString(pData, szTempBuff, sizeof(szTempBuff));

                SendMessage(GetDlgItem(Context->DisplayWindow, IDC_CALLOUTPUT),
                    LB_ADDSTRING,
                    0,
                    (LPARAM)szTempBuff);

                pData++;
            }
        }
        else if (NULL == Context->DisplayWindow)
        {
            // Running in console mode
            printf("Read #%d\n", numReadsDone);
            CLM_PrintInputReport(Context->HidDevice);
        }
    } while (!Context->TerminateThread &&
        (INFINITE_READS == Context->NumberOfReads ||
        numReadsDone < Context->NumberOfReads));

    PostMessage( Context -> DisplayWindow, WM_READ_DONE, 0, 0);
    ExitThread(0);
    return (0);
}