TnbUsbHidPathName.h

[詳解]

#pragma once
#include "TnbStr.h"
#include "TnbRegistryAccessor.h"
#include "TnbWindowsVersion.h"
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#pragma pack(push,4)
 
// HIDUSAGE.H より
#ifndef __HIDUSAGE_H__
 
    typedef USHORT USAGE, *PUSAGE;
 
#endif // __HIDUSAGE_H__
 
// HIDPI.H より
#ifndef __HIDPI_H__
 
    typedef enum _HIDP_REPORT_TYPE
    {
        HidP_Input,
        HidP_Output,
        HidP_Feature
    } HIDP_REPORT_TYPE;
 
    typedef struct _HIDP_CAPS
    {
        USAGE   Usage;
        USAGE   UsagePage;
        USHORT  InputReportByteLength;
        USHORT  OutputReportByteLength;
        USHORT  FeatureReportByteLength;
        USHORT  Reserved[17];
 
        USHORT  NumberLinkCollectionNodes;
 
        USHORT  NumberInputButtonCaps;
        USHORT  NumberInputValueCaps;
        USHORT  NumberInputDataIndices;
 
        USHORT  NumberOutputButtonCaps;
        USHORT  NumberOutputValueCaps;
        USHORT  NumberOutputDataIndices;
 
        USHORT  NumberFeatureButtonCaps;
        USHORT  NumberFeatureValueCaps;
        USHORT  NumberFeatureDataIndices;
    } HIDP_CAPS, *PHIDP_CAPS;
 
    typedef struct _HIDP_LINK_COLLECTION_NODE
    {
        USAGE    LinkUsage;
        USAGE    LinkUsagePage;
        USHORT   Parent;
        USHORT   NumberOfChildren;
        USHORT   NextSibling;
        USHORT   FirstChild;
        ULONG    CollectionType: 8;  // As defined in 6.2.2.6 of HID spec
        ULONG    IsAlias : 1; // This link node is an allias of the next link node.
        ULONG    Reserved: 23;
        PVOID    UserContext; // The user can hang his coat here.
    } HIDP_LINK_COLLECTION_NODE, *PHIDP_LINK_COLLECTION_NODE;
 
    typedef struct _HIDP_BUTTON_CAPS
    {
        USAGE    UsagePage;
        UCHAR    ReportID;
        BOOLEAN  IsAlias;
 
        USHORT   BitField;
        USHORT   LinkCollection;   // A unique internal index pointer
 
        USAGE    LinkUsage;
        USAGE    LinkUsagePage;
 
        BOOLEAN  IsRange;
        BOOLEAN  IsStringRange;
        BOOLEAN  IsDesignatorRange;
        BOOLEAN  IsAbsolute;
 
        ULONG    Reserved[10];
        union {
            struct {
                USAGE    UsageMin,         UsageMax;
                USHORT   StringMin,        StringMax;
                USHORT   DesignatorMin,    DesignatorMax;
                USHORT   DataIndexMin,     DataIndexMax;
            } Range;
            struct  {
                USAGE    Usage,            Reserved1;
                USHORT   StringIndex,      Reserved2;
                USHORT   DesignatorIndex,  Reserved3;
                USHORT   DataIndex,        Reserved4;
            } NotRange;
        };
 
    } HIDP_BUTTON_CAPS, *PHIDP_BUTTON_CAPS;
 
    typedef struct _HIDP_VALUE_CAPS
    {
        USAGE    UsagePage;
        UCHAR    ReportID;
        BOOLEAN  IsAlias;
 
        USHORT   BitField;
        USHORT   LinkCollection;   // A unique internal index pointer
 
        USAGE    LinkUsage;
        USAGE    LinkUsagePage;
 
        BOOLEAN  IsRange;
        BOOLEAN  IsStringRange;
        BOOLEAN  IsDesignatorRange;
        BOOLEAN  IsAbsolute;
 
        BOOLEAN  HasNull;        // Does this channel have a null report   union
        UCHAR    Reserved;
        USHORT   BitSize;        // How many bits are devoted to this value?
 
        USHORT   ReportCount;    // See Note below.  Usually set to 1.
        USHORT   Reserved2[5];
 
        ULONG    UnitsExp;
        ULONG    Units;
 
        LONG     LogicalMin,       LogicalMax;
        LONG     PhysicalMin,      PhysicalMax;
 
        union {
            struct {
                USAGE    UsageMin,         UsageMax;
                USHORT   StringMin,        StringMax;
                USHORT   DesignatorMin,    DesignatorMax;
                USHORT   DataIndexMin,     DataIndexMax;
            } Range;
 
            struct {
                USAGE    Usage,            Reserved1;
                USHORT   StringIndex,      Reserved2;
                USHORT   DesignatorIndex,  Reserved3;
                USHORT   DataIndex,        Reserved4;
            } NotRange;
        };
    } HIDP_VALUE_CAPS, *PHIDP_VALUE_CAPS;
 
    typedef PUCHAR  PHIDP_REPORT_DESCRIPTOR;
    typedef struct _HIDP_PREPARSED_DATA * PHIDP_PREPARSED_DATA;
    #ifndef FACILITY_HID_ERROR_CODE
     #define FACILITY_HID_ERROR_CODE 0x11
    #endif
    #define HIDP_ERROR_CODES(SEV, CODE) \
            ((NTSTATUS) (((SEV) << 28) | (FACILITY_HID_ERROR_CODE << 16) | (CODE)))
    #define HIDP_STATUS_SUCCESS                  (HIDP_ERROR_CODES(0x0,0))
 
#endif // __HIDPI_H__
 
//HIDSDI.h より
#ifndef _HIDSDI_H
 
    typedef struct _HIDD_ATTRIBUTES 
    {
        ULONG   Size; // = sizeof (struct _HIDD_ATTRIBUTES)
        // Vendor ids of this hid device
        USHORT  VendorID;
        USHORT  ProductID;
        USHORT  VersionNumber;
        // Additional fields will be added to the end of this structure.
    } HIDD_ATTRIBUTES, *PHIDD_ATTRIBUTES;
    typedef LONG NTSTATUS;
 
#endif // _HIDSDI_H
 
#pragma pack(pop)
 
#endif // _TnbDOXYGEN
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CUsbHidApi
{
public:
 
    CUsbHidApi(void) : m_module(NULL)
    {
    }
    
    CUsbHidApi(const CUsbHidApi& other) : m_module(NULL)
    {
    }
 
    ~CUsbHidApi(void)
    {
        if ( m_module != NULL )
        {
            ::FreeLibrary(m_module);
            m_module = NULL;
        }
    }
 
    CUsbHidApi& operator=(const CUsbHidApi& other)
    {
        return *this;
    }
 
    BOOLEAN HidD_GetAttributes(HANDLE hidDeviceObject, PHIDD_ATTRIBUTES pAttributes) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PHIDD_ATTRIBUTES pAttributes) = 0;
        return Func(P, "HidD_GetAttributes")(hidDeviceObject, pAttributes);
    }
 
    BOOLEAN HidD_GetPreparsedData(HANDLE hidDeviceObject, PHIDP_PREPARSED_DATA* ppPreparsedData) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PHIDP_PREPARSED_DATA* ppPreparsedData) = 0;
        return Func(P, "HidD_GetPreparsedData")(hidDeviceObject, ppPreparsedData);
    }
 
    BOOLEAN HidD_FreePreparsedData(PHIDP_PREPARSED_DATA pPreparsedData) const
    {
        BOOLEAN (__stdcall *P)(PHIDP_PREPARSED_DATA pPreparsedData) = 0;
        return Func(P, "HidD_FreePreparsedData")(pPreparsedData);
    }
 
    BOOLEAN HidD_SetFeature(HANDLE hidDeviceObject,PVOID pReportBuffer, ULONG reportBufferLength)
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject,PVOID pReportBuffer, ULONG reportBufferLength) = 0;
        return Func(P, "HidD_SetFeature")(hidDeviceObject, pReportBuffer, reportBufferLength);
    }
 
    BOOLEAN HidD_GetFeature(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength) = 0;
        return Func(P, "HidD_GetFeature")(hidDeviceObject, pReportBuffer, reportBufferLength);
    }
 
    BOOLEAN HidD_SetOutputReport(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength)
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength) = 0;
        return Func(P, "HidD_SetOutputReport")(hidDeviceObject, pReportBuffer, reportBufferLength);
    }
 
    BOOLEAN HidD_GetInputReport(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pReportBuffer, ULONG reportBufferLength) = 0;
        return Func(P, "HidD_GetInputReport")(hidDeviceObject, pReportBuffer, reportBufferLength);
    }
        
    void HidD_GetHidGuid(LPGUID pHidGuid) const
    {
        void (__stdcall *P)(LPGUID pHidGuid) = NULL;
        Func(P, "HidD_GetHidGuid")(pHidGuid);
    }
 
    BOOLEAN HidD_GetManufacturerString(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) = 0;
        return Func(P, "HidD_GetManufacturerString")(hidDeviceObject, pBuffer, bufferLength);
    }
 
    BOOLEAN HidD_GetProductString(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) = 0;
        return Func(P, "HidD_GetProductString")(hidDeviceObject, pBuffer, bufferLength);
    }
 
    BOOLEAN HidD_GetSerialNumberString(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PVOID pBuffer, ULONG bufferLength) = 0;
        return Func(P, "HidD_GetSerialNumberString")(hidDeviceObject, pBuffer, bufferLength);
    }
 
    BOOLEAN HidD_GetIndexedString(HANDLE hidDeviceObject, ULONG stringIndex, PVOID pBuffer, ULONG bufferLength) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, ULONG stringIndex, PVOID pBuffer, ULONG bufferLength) = 0;
        return Func(P, "HidD_GetIndexedString")(hidDeviceObject, stringIndex, pBuffer, bufferLength);
    }
 
    BOOLEAN HidD_GetNumInputBuffers(HANDLE hidDeviceObject, PULONG pNumberBuffers) const
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, PULONG pNumberBuffers) = 0;
        return Func(P, "HidD_GetNumInputBuffers")(hidDeviceObject, pNumberBuffers);
    }
 
    BOOLEAN HidD_SetNumInputBuffers(HANDLE hidDeviceObject, ULONG numberBuffers)
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject, ULONG numberBuffers) = 0;
        return Func(P, "HidD_SetNumInputBuffers")(hidDeviceObject, numberBuffers);
    }
 
    BOOLEAN HidD_FlushQueue(HANDLE hidDeviceObject)
    {
        BOOLEAN (__stdcall *P)(HANDLE hidDeviceObject) = 0;
        return Func(P, "HidD_FlushQueue")(hidDeviceObject);
    }
    
    NTSTATUS HidP_GetCaps(PHIDP_PREPARSED_DATA pPreparsedData, PHIDP_CAPS pCapabilities) const
    {
        NTSTATUS (__stdcall *P)(PHIDP_PREPARSED_DATA pPreparsedData, PHIDP_CAPS pCapabilities) = 0;
        return Func(P, "HidP_GetCaps")(pPreparsedData, pCapabilities);
    }
    
    NTSTATUS HidP_GetLinkCollectionNodes(PHIDP_LINK_COLLECTION_NODE pLinkCollectionNodes, PULONG pLinkCollectionNodesLength, PHIDP_PREPARSED_DATA pPreparsedData)
    {
        NTSTATUS (__stdcall *P)(PHIDP_LINK_COLLECTION_NODE pLinkCollectionNodes, PULONG pLinkCollectionNodesLength, PHIDP_PREPARSED_DATA pPreparsedData) = 0;
        return Func(P, "HidP_GetLinkCollectionNodes")(pLinkCollectionNodes, pLinkCollectionNodesLength, pPreparsedData);
    }
 
    NTSTATUS HidP_GetSpecificButtonCaps(HIDP_REPORT_TYPE reportType, USAGE usagePage, USHORT linkCollection, USAGE usage, PHIDP_BUTTON_CAPS pButtonCaps, PUSHORT pButtonCapsLength, PHIDP_PREPARSED_DATA pPreparsedData)
    {
        NTSTATUS (__stdcall *P)(HIDP_REPORT_TYPE reportType, USAGE usagePage, USHORT linkCollection, USAGE usage, PHIDP_BUTTON_CAPS pButtonCaps, PUSHORT pButtonCapsLength, PHIDP_PREPARSED_DATA pPreparsedData) = 0;
        return Func(P, "HidP_GetSpecificButtonCaps")(reportType, usagePage, linkCollection, usage, pButtonCaps, pButtonCapsLength, pPreparsedData);
    }
 
    NTSTATUS HidP_GetButtonCaps(HIDP_REPORT_TYPE reportType, PHIDP_BUTTON_CAPS pButtonCaps, PUSHORT pButtonCapsLength, PHIDP_PREPARSED_DATA pPreparsedData)
    {
        return HidP_GetSpecificButtonCaps(reportType, 0, 0, 0, pButtonCaps, pButtonCapsLength, pPreparsedData);
    }
 
    NTSTATUS HidP_GetSpecificValueCaps(HIDP_REPORT_TYPE reportType, USAGE usagePage, USHORT linkCollection, USAGE usage, PHIDP_VALUE_CAPS pValueCaps, PUSHORT pValueCapsLength, PHIDP_PREPARSED_DATA pPreparsedData)
    {
        NTSTATUS (__stdcall *P)(HIDP_REPORT_TYPE reportType, USAGE usagePage, USHORT linkCollection, USAGE usage, PHIDP_VALUE_CAPS pValueCaps, PUSHORT pValueCapsLength, PHIDP_PREPARSED_DATA pPreparsedData) = 0;
        return Func(P, "HidP_GetSpecificValueCaps")(reportType, usagePage, linkCollection, usage, pValueCaps, pValueCapsLength, pPreparsedData);
    }
 
    NTSTATUS HidP_GetValueCaps(HIDP_REPORT_TYPE reportType, PHIDP_VALUE_CAPS pValueCaps, PUSHORT pValueCapsLength, PHIDP_PREPARSED_DATA pPreparsedData)
    {
        return HidP_GetSpecificValueCaps(reportType, 0, 0, 0, pValueCaps, pValueCapsLength, pPreparsedData);
    }
 
private:
 
    // EXPORT関数コール
    template<typename TYP>
    TYP Func(TYP typ, LPCSTR lpsz) const
    {
        if ( m_module == NULL )
        {
            m_module = ::LoadLibrary(_T("hid.dll"));
            ASSERT( m_module != NULL );
        }
        ForceSet(typ, ::GetProcAddress(m_module, lpsz));
        ASSERT1( typ != NULL, "CUsbHidApi::Func", "[%s]が見つかりませんでした", lpsz );
        return typ;
    }
 
    mutable HMODULE m_module;   
};
 
 
 
class CUsbHidPathName : CUsbHidApi
{
public:
 
    CUsbHidPathName(void) : m_vendorId(0), m_productId(0), m_pathName()
    {
        Zero(m_hidpCaps);
    }
 
    CUsbHidPathName(WORD wVid, WORD wPid, LPCTSTR lpszPathName, const HIDP_CAPS& cap)
        : m_vendorId(wVid), m_productId(wPid), m_pathName(lpszPathName), m_hidpCaps(cap)
    {
    }
 
    bool IsEmpty(void) const
    {
        return m_pathName.IsEmpty();
//      return m_vendorId != 0;
    }
 
    void Empty(void)
    {
        m_vendorId = 0;
        m_productId = 0;
        m_pathName.Empty();
        m_regPathHid.Empty();
        m_regPathUsb.Empty();
        Zero(m_hidpCaps);
    }
 
    DWORD SetPathName(LPCTSTR lpszPathName)
    {
        Empty();
        DWORD shareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE);
        HANDLE h = ::CreateFile(lpszPathName, GENERIC_WRITE, shareMode, NULL, OPEN_EXISTING, 0, 0);
        if ( h == INVALID_HANDLE_VALUE )
        {
            return _GetLastError("CreateFile");
        }
        DWORD dwResult = ERROR_SUCCESS;
        HIDD_ATTRIBUTES attr;
        attr.Size = sizeof(HIDD_ATTRIBUTES);
        // Vendor IDとProduct IDを取得
        if ( ! HidD_GetAttributes(h, &attr) )
        {
            dwResult = _GetLastError("HidD_GetAttributes");
        }
        else
        {
            PHIDP_PREPARSED_DATA pPreparsedData;
            if ( ! HidD_GetPreparsedData(h, &pPreparsedData) )
            {
                dwResult = _GetLastError("HidD_GetPreparsedData");
            }
            else
            {
                HidP_GetCaps(pPreparsedData, &m_hidpCaps);
                HidD_FreePreparsedData(pPreparsedData);
                m_vendorId = attr.VendorID;
                m_productId = attr.ProductID;
                m_pathName = lpszPathName;
                m_regPathHid.Empty();
                m_regPathUsb.Empty();
//              TRACE3("desc=[%s], loca=[%s], mfg=[%s]\n", GetDeviceDescription(), GetLocationInformation(), GetManufacturer());
            }
        }
        ::CloseHandle(h);
        return dwResult;
    }
 
    bool GetLinkCollectionNodes(CWorkMemT<HIDP_LINK_COLLECTION_NODE>& _vn)
    {
        _vn.Resize(m_hidpCaps.NumberLinkCollectionNodes);
        DWORD shareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE);
        HANDLE h = ::CreateFile(m_pathName, GENERIC_WRITE, shareMode, NULL, OPEN_EXISTING, 0, 0);
        if ( h == INVALID_HANDLE_VALUE )
        {
            _GetLastError("CreateFile");
            return false;
        }
        bool r = false;
        PHIDP_PREPARSED_DATA pPreparsedData;
        if ( HidD_GetPreparsedData(h, &pPreparsedData) )
        {
            ULONG ul = static_cast<ULONG>(_vn.GetSize());
            r = (HidP_GetLinkCollectionNodes(_vn.Ref(), &ul, pPreparsedData) == HIDP_STATUS_SUCCESS);
            HidD_FreePreparsedData(pPreparsedData);
        }
        ::CloseHandle(h);
        return r;
    }
 
    bool GetButtonCaps(CWorkMemT<HIDP_BUTTON_CAPS>& _vn, HIDP_REPORT_TYPE reportType)
    {
        switch ( reportType )
        {
        case HidP_Input:
            _vn.Resize(m_hidpCaps.NumberInputButtonCaps);
            break;
        case HidP_Output:
            _vn.Resize(m_hidpCaps.NumberOutputButtonCaps);
            break;
        case HidP_Feature:
        default:
            _vn.Resize(m_hidpCaps.NumberFeatureButtonCaps);
            break;
        }
        DWORD shareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE);
        HANDLE h = ::CreateFile(m_pathName, GENERIC_WRITE, shareMode, NULL, OPEN_EXISTING, 0, 0);
        if ( h == INVALID_HANDLE_VALUE )
        {
            _GetLastError("CreateFile");
            return false;
        }
        bool r = false;
        PHIDP_PREPARSED_DATA pPreparsedData;
        if ( HidD_GetPreparsedData(h, &pPreparsedData) )
        {
            USHORT ul = static_cast<USHORT>(_vn.GetSize());
            r = (HidP_GetButtonCaps(reportType, _vn.Ref(), &ul, pPreparsedData) == HIDP_STATUS_SUCCESS);
            HidD_FreePreparsedData(pPreparsedData);
        }
        ::CloseHandle(h);
        return r;
    }
 
    bool GetValueCaps(CWorkMemT<HIDP_VALUE_CAPS>& _vn, HIDP_REPORT_TYPE reportType)
    {
        switch ( reportType )
        {
        case HidP_Input:
            _vn.Resize(m_hidpCaps.NumberInputValueCaps);
            break;
        case HidP_Output:
            _vn.Resize(m_hidpCaps.NumberOutputValueCaps);
            break;
        case HidP_Feature:
        default:
            _vn.Resize(m_hidpCaps.NumberFeatureValueCaps);
            break;
        }
        DWORD shareMode = (FILE_SHARE_READ | FILE_SHARE_WRITE);
        HANDLE h = ::CreateFile(m_pathName, GENERIC_WRITE, shareMode, NULL, OPEN_EXISTING, 0, 0);
        if ( h == INVALID_HANDLE_VALUE )
        {
            _GetLastError("CreateFile");
            return false;
        }
        bool r = false;
        PHIDP_PREPARSED_DATA pPreparsedData;
        if ( HidD_GetPreparsedData(h, &pPreparsedData) )
        {
            USHORT ul = static_cast<USHORT>(_vn.GetSize());
            r = (HidP_GetValueCaps(reportType, _vn.Ref(), &ul, pPreparsedData) == HIDP_STATUS_SUCCESS);
            HidD_FreePreparsedData(pPreparsedData);
        }
        ::CloseHandle(h);
        return r;
    }
 
    const HIDP_CAPS& GetCapability(void) const
    {
        return m_hidpCaps;
    }
 
    const CStr& GetPathName(void) const
    {
        return m_pathName;
    }
 
    WORD GetVendorId(void) const
    {
        return m_vendorId;
    }
    
    WORD GetProductId(void) const
    {
        return m_productId;
    }
 
    size_t GetInputReportByteLength(void) const
    {
        return m_hidpCaps.InputReportByteLength;
    }
 
    size_t GetOutputReportByteLength(void) const
    {
        return m_hidpCaps.OutputReportByteLength;
    }
 
    size_t GetFeatureReportByteLength(void) const
    {
        return m_hidpCaps.FeatureReportByteLength;
    }
 
    CStr GetManufacturer(void) const
    {
        m_SearchRegPath();
        if ( ! m_regPathHid.IsEmpty() )
        {
            CRegistryAccessor reg(HKEY_LOCAL_MACHINE, m_GetBaseRegPath(), KEY_READ);
            return m_GetRegString(reg, m_regPathHid, _T("Mfg"));
        }
        return _T("");
    }
 
    CStr GetDeviceDescription(void) const
    {
        m_SearchRegPath();
        if ( ! m_regPathHid.IsEmpty() )
        {
            CRegistryAccessor reg(HKEY_LOCAL_MACHINE, m_GetBaseRegPath(), KEY_READ);
            return m_GetRegString(reg, m_regPathHid, _T("DeviceDesc"));
        }
        return _T("");
    }
 
    CStr GetLocationInformation(void) const
    {
        m_SearchRegPath();
        if ( ! m_regPathUsb.IsEmpty() )
        {
            CRegistryAccessor reg(HKEY_LOCAL_MACHINE, m_GetBaseRegPath(), KEY_READ);
            return m_GetRegString(reg, m_regPathUsb, _T("LocationInformation"));
        }
        return _T("");
    }
 
    struct TDescriptionStrings
    {
        CStr manufacturer;      
        CStr product;           
        CStr serialNumber;      
    };
 
    bool GetManufacturerString(TDescriptionStrings& _ds) const
    {
        _ds.manufacturer.Empty();
        _ds.product.Empty();
        _ds.serialNumber.Empty();
        HANDLE hDown = ::CreateFile(m_pathName, GENERIC_WRITE, (FILE_SHARE_READ | FILE_SHARE_WRITE), NULL, OPEN_EXISTING, 0, 0);
        if ( hDown == INVALID_HANDLE_VALUE )
        {
            return false;
        }
        CUnicode s;
        bool r = !! HidD_GetManufacturerString(hDown, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        if ( r )
        {
            _ds.manufacturer = s;
        }
        r = !! HidD_GetProductString(hDown, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        if ( r )
        {
            _ds.product = s;
        }
        r = !! HidD_GetSerialNumberString(hDown, s.GetBuffer(256), 256 * sizeof(WCHAR));
        s.ReleaseBuffer();
        if ( r )
        {
            _ds.serialNumber = s;
        }
        ::CloseHandle(hDown);
        return true;
    }
 
    CStr ToString(void) const
    {
        CStr str;
        USHORT vid = GetVendorId();
        USHORT pid = GetProductId();
        TDescriptionStrings ds;
        if ( GetManufacturerString(ds) )
        {
            if ( ds.manufacturer != _T("?") && ! ds.manufacturer.IsEmpty() )
            {
                str.Format(_T("VID=0x%04X, PID=0x%04X, [%s] - %s"), vid, pid, ds.product, ds.manufacturer);
                return str;
            }
        }
        CWindowsVersion wv;
        if ( wv.GetMajorVersion() <= 5/*XP,2000*/ )
        {
            str.Format(_T("VID=0x%04X, PID=0x%04X [%s]"), vid, pid, GetLocationInformation());
        }
        else
        {
            str.Format(_T("VID=0x%04X, PID=0x%04X, [%s] - %s"), vid, pid, GetDeviceDescription(), GetManufacturer());
        }
        return str;
    }
 
private:
    class CMyFinder : public CDeepAccessFinder
    {
    public:
        CStr    m_targetId;
        CStr    m_foundPath;
    protected:
        // セクション発見.
        virtual EResult OnFindSection(LPCTSTR lpszSection, IAccessor::CSection& sec, int depth)
        {
            if ( depth >= 2 )
            {
                return Previous;
            }
            if ( m_targetId.IsEqual(sec.QueryString(_T("ParentIdPrefix"))) )
            {
                m_foundPath = sec.GetSectionName();
                return Stop;
            }
            return Next;
        }
    };
    bool m_SearchRegPath(void) const
    {
        if ( m_regPathHid.IsEmpty() || m_regPathUsb.IsEmpty() )
        {
            INDEX f1 = m_pathName.Find('#');
            INDEX f2 = m_pathName.Find('#', f1 + 1);
            INDEX f3 = m_pathName.Find('#', f2 + 1);
            if ( f1 != INVALID_INDEX && f2 != INVALID_INDEX && f3 != INVALID_INDEX )
            {
                CMyFinder ff;
                CStr vpid = m_pathName.Mid(f1 + 1, f2 - f1 - 1);
                CStr vpid2 = vpid;
                INDEX f = vpid.Find('&', 18);
                if ( f != INVALID_INDEX )
                {
                    vpid2 = vpid.Left(f);
                }
                CStr key = m_pathName.Mid(f2 + 1, f3 - f2 - 1);
                ff.m_targetId = key.Left(key.GetLength() - 5);
                CRegistryAccessor reg(HKEY_LOCAL_MACHINE, m_GetBaseRegPath(), KEY_READ);
                ff.Execute(reg[_T("USB\\") + vpid2]);
                m_regPathUsb = ff.m_foundPath;
                CStrVector vs = reg.EnumSectionNames(_T("HID\\") + vpid);
                if ( ! vs.IsEmpty() )
                {
                    m_regPathHid.Format(_T("HID\\%s\\%s"), vpid, vs[0]);
                }
            }
        }
        return (! m_regPathHid.IsEmpty() && ! m_regPathUsb.IsEmpty());
    }
    CStr m_GetRegString(CRegistryAccessor& reg, LPCTSTR lpszSection, LPCTSTR lpszKey) const
    {
        CStr s = reg[lpszSection].QueryString(lpszKey).Trim();
        INDEX f = s.Find(';');
        if ( f != INVALID_INDEX )
        {
            s = s.Mid(f + 1);
        }
        return s;
    }
    LPCTSTR m_GetBaseRegPath(void) const
    {
        return _T("System\\currentControlSet\\Enum");
    }
    WORD            m_vendorId;         
    WORD            m_productId;        
    CStr            m_pathName;         
    HIDP_CAPS       m_hidpCaps;         
    mutable CStr    m_regPathHid;       
    mutable CStr    m_regPathUsb;       
};
 
 
 
}; // TNB